channels/chan_sip.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Implementation of Session Initiation Protocol
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14 #include <stdio.h>
  15 #include <ctype.h>
  16 #include <pthread.h>
  17 #include <string.h>
  18 #include <asterisk/lock.h>
  19 #include <asterisk/channel.h>
  20 #include <asterisk/channel_pvt.h>
  21 #include <asterisk/config.h>
  22 #include <asterisk/logger.h>
  23 #include <asterisk/module.h>
  24 #include <asterisk/pbx.h>
  25 #include <asterisk/options.h>
  26 #include <asterisk/lock.h>
  27 #include <asterisk/sched.h>
  28 #include <asterisk/io.h>
  29 #include <asterisk/rtp.h>
  30 #include <asterisk/acl.h>
  31 #include <asterisk/callerid.h>
  32 #include <asterisk/cli.h>
  33 #include <asterisk/md5.h>
  34 #include <asterisk/app.h>
  35 #include <asterisk/musiconhold.h>
  36 #include <asterisk/dsp.h>
  37 #include <asterisk/parking.h>
  38 #include <asterisk/acl.h>
  39 #include <asterisk/srv.h>
  40 #include <asterisk/astdb.h>
  41 #include <asterisk/causes.h>
  42 #include <sys/socket.h>
  43 #include <sys/ioctl.h>
  44 #include <net/if.h>
  45 #include <errno.h>
  46 #include <unistd.h>
  47 #include <stdlib.h>
  48 #include <fcntl.h>
  49 #include <netdb.h>
  50 #include <arpa/inet.h>
  51 #include <sys/signal.h>
  52 #include <netinet/in_systm.h>
  53 #include <netinet/ip.h>
  54
  55 #ifdef MYSQL_FRIENDS
  56 #include <mysql/mysql.h>
  57 #endif
  58
  59 #ifndef IPTOS_MINCOST
  60 #define IPTOS_MINCOST 0x02
  61 #endif
  62
  63 /* #define VOCAL_DATA_HACK */
  64
  65 #define SIPDUMPER
  66 #define DEFAULT_DEFAULT_EXPIRY  120
  67 #define DEFAULT_MAX_EXPIRY      3600
  68 #define EXPIRY_GUARD_SECS       15
  69
  70 #define CALLERID_UNKNOWN        "Unknown"
  71
  72 #define SIP_DTMF_RFC2833        (1 << 0)
  73 #define SIP_DTMF_INBAND         (1 << 1)
  74 #define SIP_DTMF_INFO           (1 << 2)
  75
  76 static int max_expiry = DEFAULT_MAX_EXPIRY;
  77 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
  78
  79 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
  80 #define DEFAULT_FREQ_OK         60 * 1000               /* How often to check for the host to be up */
  81 #define DEFAULT_FREQ_NOTOK      10 * 1000               /* How often to check, if the host is down... */
  82
  83 #define DEFAULT_RETRANS         1000                    /* How frequently to retransmit */
  84 #define MAX_RETRANS                     5                               /* Try only 5 times for retransmissions */
  85
  86 #ifdef MYSQL_FRIENDS
  87 static ast_mutex_t mysqllock = AST_MUTEX_INITIALIZER;
  88 static MYSQL *mysql;
  89 static char mydbuser[80];
  90 static char mydbpass[80];
  91 static char mydbhost[80];
  92 static char mydbname[80];
  93 #endif
  94
  95 static char *desc = "Session Initiation Protocol (SIP)";
  96 static char *type = "SIP";
  97 static char *tdesc = "Session Initiation Protocol (SIP)";
  98 static char *config = "sip.conf";
  99
 100 #define DEFAULT_SIP_PORT        5060    /* From RFC 2543 */
 101 #define SIP_MAX_PACKET  1500            /* Also from RFC 2543, should sub headers tho */
 102
 103 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
 104
 105 static char context[AST_MAX_EXTENSION] = "default";
 106
 107 static char language[MAX_LANGUAGE] = "";
 108
 109 static char callerid[AST_MAX_EXTENSION] = "asterisk";
 110
 111 static char fromdomain[AST_MAX_EXTENSION] = "";
 112
 113 static char notifymime[AST_MAX_EXTENSION] = "application/simple-message-summary";
 114
 115 static int srvlookup = 0;
 116
 117 static int pedanticsipchecking = 0;
 118
 119 static int autocreatepeer = 0;
 120
 121 static int usecnt =0;
 122 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
 123
 124 /* Protect the interface list (of sip_pvt's) */
 125 static ast_mutex_t iflock = AST_MUTEX_INITIALIZER;
 126
 127 /* Protect the monitoring thread, so only one process can kill or start it, and not
 128    when it's doing something critical. */
 129 static ast_mutex_t netlock = AST_MUTEX_INITIALIZER;
 130
 131 static ast_mutex_t monlock = AST_MUTEX_INITIALIZER;
 132
 133 /* This is the thread for the monitor which checks for input on the channels
 134    which are not currently in use.  */
 135 static pthread_t monitor_thread = 0;
 136
 137 static int restart_monitor(void);
 138
 139 /* Codecs that we support by default: */
 140 static int capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
 141 static int noncodeccapability = AST_RTP_DTMF;
 142
 143 static char ourhost[256];
 144 static struct in_addr __ourip;
 145 static int ourport;
 146
 147 static int sipdebug = 0;
 148
 149 static int tos = 0;
 150
 151 static int videosupport = 0;
 152
 153 static int globaldtmfmode = SIP_DTMF_RFC2833;
 154
 155 /* Expire slowly */
 156 static int expiry = 900;
 157
 158 static struct sched_context *sched;
 159 static struct io_context *io;
 160 /* The private structures of the  sip channels are linked for
 161    selecting outgoing channels */
 162
 163 #define SIP_MAX_HEADERS         64
 164 #define SIP_MAX_LINES           64
 165
 166 #define DEC_IN_USE      0
 167 #define INC_IN_USE      1
 168 #define DEC_OUT_USE     2
 169 #define INC_OUT_USE     3
 170
 171 static struct sip_codec_pref {
 172         int codec;
 173         struct sip_codec_pref *next;
 174 } *prefs;
 175
 176 struct sip_request {
 177   char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
 178   char *rlPart2; /* The Request URI or Response Status */
 179         int len;
 180         int headers;                                    /* SIP Headers */
 181         char *header[SIP_MAX_HEADERS];
 182         int lines;                                              /* SDP Content */
 183         char *line[SIP_MAX_LINES];
 184         char data[SIP_MAX_PACKET];
 185 };
 186
 187 struct sip_pkt;
 188
 189 struct sip_route {
 190         struct sip_route *next;
 191         char hop[0];
 192 };
 193
 194 static struct sip_pvt {
 195         ast_mutex_t lock;                               /* Channel private lock */
 196         char callid[80];                                        /* Global CallID */
 197         char randdata[80];      /* Random data */
 198         unsigned int ocseq;                                     /* Current outgoing seqno */
 199         unsigned int icseq;                                     /* Current incoming seqno */
 200         unsigned int callgroup;
 201         unsigned int pickupgroup;
 202         int lastinvite;                                         /* Last Cseq of invite */
 203         int alreadygone;                                        /* Whether or not we've already been destroyed by or peer */
 204         int needdestroy;                                        /* if we need to be destroyed */
 205         int capability;                                         /* Special capability */
 206         int jointcapability;                            /* Supported capability at both ends */
 207         int noncodeccapability;
 208         int outgoing;                                           /* Outgoing or incoming call? */
 209         int authtries;                                          /* Times we've tried to authenticate */
 210         int insecure;                                           /* Don't check source port/ip */
 211         int expiry;                                             /* How long we take to expire */
 212         int branch;                                                     /* One random number */
 213         int canreinvite;                                        /* Do we support reinvite */
 214         int ringing;                                            /* Have sent 180 ringing */
 215         int progress;                                           /* Have sent 183 message progress */
 216         int tag;                                                        /* Another random number */
 217         int nat;                                                        /* Whether to try to support NAT */
 218         int sessionid;                                          /* SDP Session ID */
 219         int sessionversion;                                     /* SDP Session Version */
 220         struct sockaddr_in sa;                          /* Our peer */
 221         struct sockaddr_in redirip;                     /* Where our RTP should be going if not to us */
 222         struct sockaddr_in vredirip;            /* Where our Video RTP should be going if not to us */
 223         struct sockaddr_in recv;                        /* Received as */
 224         struct in_addr ourip;                           /* Our IP */
 225         struct ast_channel *owner;                      /* Who owns us */
 226         char exten[AST_MAX_EXTENSION];          /* Extention where to start */
 227         char refer_to[AST_MAX_EXTENSION];       /* Place to store REFER-TO extension */
 228         char referred_by[AST_MAX_EXTENSION];/* Place to store REFERRED-BY extension */
 229         char refer_contact[AST_MAX_EXTENSION];/* Place to store Contact info from a REFER extension */
 230         struct sip_pvt *refer_call;                     /* Call we are referring */
 231         struct sip_route *route;                        /* Head of linked list of routing steps (fm Record-Route) */
 232         char remote_party_id[256];
 233         char from[256];
 234         char context[AST_MAX_EXTENSION];
 235         char fromdomain[AST_MAX_EXTENSION];     /* Domain to show in the from field */
 236         char fromuser[AST_MAX_EXTENSION];       /* Domain to show in the user field */
 237         char tohost[AST_MAX_EXTENSION];         /* Host we should put in the "to" field */
 238         char language[MAX_LANGUAGE];
 239         char rdnis[256];                                /* Referring DNIS */
 240         char theirtag[256];                             /* Their tag */
 241         char username[256];
 242         char peername[256];
 243         char uri[256];                                  /* Original requested URI */
 244         char peersecret[256];
 245         char peermd5secret[256];
 246         char callerid[256];                                     /* Caller*ID */
 247         int restrictcid;                        /* hide presentation from remote user */
 248         char via[256];
 249         char accountcode[20];                           /* Account code */
 250         char our_contact[256];                          /* Our contact header */
 251         char realm[256];                                /* Authorization realm */
 252         char nonce[256];                                /* Authorization nonce */
 253         char domain[256];                               /* Authorization nonce */
 254         char lastmsg[256];                              /* Last Message sent/received */
 255         int amaflags;                                           /* AMA Flags */
 256         int pendinginvite;                                      /* Any pending invite */
 257         int pendingbye;                                         /* Need to send bye after we ack? */
 258         int gotrefer;                                           /* Got a refer? */
 259         struct sip_request initreq;                     /* Initial request */
 260
 261         int maxtime;                                            /* Max time for first response */
 262         int initid;                                                     /* Auto-congest ID if appropriate */
 263         int autokillid;                                         /* Auto-kill ID */
 264
 265         int subscribed;
 266         int stateid;
 267         int dialogver;
 268
 269         int dtmfmode;
 270         struct ast_dsp *vad;
 271
 272         struct sip_peer *peerpoke;                      /* If this calls is to poke a peer, which one */
 273         struct sip_registry *registry;                  /* If this is a REGISTER call, to which registry */
 274         struct ast_rtp *rtp;                            /* RTP Session */
 275         struct ast_rtp *vrtp;                           /* Video RTP session */
 276         struct sip_pkt *packets;                        /* Packets scheduled for re-transmission */
 277         struct sip_pvt *next;
 278 } *iflist = NULL;
 279
 280 struct sip_pkt {
 281         struct sip_pkt *next;                           /* Next packet */
 282         int retrans;                                            /* Retransmission number */
 283         int seqno;                                                      /* Sequence number */
 284         int resp;                                                       /* non-zero if this is a response packet (e.g. 200 OK) */
 285         struct sip_pvt *owner;                          /* Owner call */
 286         int retransid;                                          /* Retransmission ID */
 287         int packetlen;                                          /* Length of packet */
 288         char data[0];
 289 };
 290
 291 struct sip_user {
 292         /* Users who can access various contexts */
 293         char name[80];
 294         char secret[80];
 295         char md5secret[80];
 296         char context[80];
 297         char callerid[80];
 298         char methods[80];
 299         char accountcode[20];
 300         char language[MAX_LANGUAGE];
 301         unsigned int callgroup;
 302         unsigned int pickupgroup;
 303         int nat;
 304         int hascallerid;
 305         int amaflags;
 306         int insecure;
 307         int canreinvite;
 308         int capability;
 309         int dtmfmode;
 310         int inUse;
 311         int incominglimit;
 312         int outUse;
 313         int outgoinglimit;
 314         int restrictcid;
 315         struct ast_ha *ha;
 316         struct sip_user *next;
 317 };
 318
 319 struct sip_peer {
 320         char name[80];
 321         char secret[80];
 322         char md5secret[80];
 323         char context[80];               /* JK02: peers need context too to allow parking etc */
 324         char methods[80];
 325         char username[80];
 326         char tohost[80];
 327         char fromuser[80];
 328         char fromdomain[80];
 329         char mailbox[AST_MAX_EXTENSION];
 330         int lastmsgssent;
 331         time_t  lastmsgcheck;
 332         int dynamic;
 333         int expire;
 334         int expiry;
 335         int capability;
 336         int insecure;
 337         int nat;
 338         int canreinvite;
 339         unsigned int callgroup;
 340         unsigned int pickupgroup;
 341         int dtmfmode;
 342         struct sockaddr_in addr;
 343         struct in_addr mask;
 344
 345         /* Qualification */
 346         struct sip_pvt *call;           /* Call pointer */
 347         int pokeexpire;                         /* When to expire poke */
 348         int lastms;                                     /* How long last response took (in ms), or -1 for no response */
 349         int maxms;                                      /* Max ms we will accept for the host to be up, 0 to not monitor */
 350         struct timeval ps;                      /* Ping send time */
 351
 352         struct sockaddr_in defaddr;
 353         struct ast_ha *ha;
 354         int delme;
 355         int selfdestruct;
 356         int lastmsg;
 357         int temponly;
 358         struct sip_peer *next;
 359 };
 360
 361 static struct ast_user_list {
 362         struct sip_user *users;
 363         ast_mutex_t lock;
 364 } userl = { NULL, AST_MUTEX_INITIALIZER };
 365
 366 static struct ast_peer_list {
 367         struct sip_peer *peers;
 368         ast_mutex_t lock;
 369 } peerl = { NULL, AST_MUTEX_INITIALIZER };
 370
 371 ast_mutex_t sip_reload_lock = AST_MUTEX_INITIALIZER;
 372
 373 #define REG_STATE_UNREGISTERED 0
 374 #define REG_STATE_REGSENT          1
 375 #define REG_STATE_AUTHSENT         2
 376 #define REG_STATE_REGISTERED   3
 377 #define REG_STATE_REJECTED         4
 378 #define REG_STATE_TIMEOUT          5
 379 #define REG_STATE_NOAUTH           6
 380
 381 struct sip_registry {
 382         ast_mutex_t lock;                               /* Channel private lock */
 383         struct sockaddr_in addr;                /* Who we connect to for registration purposes */
 384         char username[80];                              /* Who we are registering as */
 385         char authuser[80];                              /* Who we *authenticate* as */
 386         char hostname[80];
 387         char secret[80];                        /* Password or key name in []'s */
 388         char md5secret[80];
 389         char contact[80];                       /* Contact extension */
 390         char random[80];
 391         int expire;                                     /* Sched ID of expiration */
 392         int timeout;                                    /* sched id of sip_reg_timeout */
 393         int refresh;                                    /* How often to refresh */
 394         struct sip_pvt *call;                           /* create a sip_pvt structure for each outbound "registration call" in progress */
 395         int regstate;
 396         int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
 397         char callid[80];                /* Global CallID for this registry */
 398         unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
 399         struct sockaddr_in us;                  /* Who the server thinks we are */
 400         struct sip_registry *next;
 401 };
 402
 403 #define REINVITE_INVITE         1
 404 #define REINVITE_UPDATE         2
 405
 406 static int sip_do_register(struct sip_registry *r);
 407 static struct sip_registry *registrations;
 408
 409 static int sipsock  = -1;
 410 static int globalnat = 0;
 411 static int globalcanreinvite = REINVITE_INVITE;
 412
 413
 414 static struct sockaddr_in bindaddr;
 415 static struct sockaddr_in localnet;
 416 static struct sockaddr_in localmask;
 417 static struct sockaddr_in externip;
 418
 419 static struct ast_frame  *sip_read(struct ast_channel *ast);
 420 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
 421 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
 422 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable);
 423 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable);
 424 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable);
 425 static int transmit_invite(struct sip_pvt *p, char *msg, int sendsdp, char *auth, char *authheader, char *vxml_url,char *distinctive_ring, int init);
 426 static int transmit_reinvite_with_sdp(struct sip_pvt *p, struct ast_rtp *rtp, struct ast_rtp *vrtp);
 427 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
 428 static int transmit_message_with_text(struct sip_pvt *p, char *text);
 429 static int transmit_refer(struct sip_pvt *p, char *dest);
 430 static struct sip_peer *temp_peer(char *name);
 431 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
 432 // static char *getsipuri(char *header);
 433 static void free_old_route(struct sip_route *route);
 434 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
 435 static int find_user(struct sip_pvt *fup, int event);
 436 static void prune_peers(void);
 437
 438 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
 439 {
 440         int res;
 441         if (p->nat)
 442             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
 443         else
 444             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
 445         if (res != len) {
 446                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s returned %d: %s\n", data, len, inet_ntoa(p->sa.sin_addr), res, strerror(errno));
 447         }
 448         return res;
 449 }
 450
 451 static void sip_destroy(struct sip_pvt *p);
 452
 453 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
 454 {
 455         /*
 456           check to see if them is contained in our localnet/mask,
 457           if not, use our externip for us, otherwise use the
 458           real internal address in bindaddr
 459          */
 460         if (localnet.sin_addr.s_addr && externip.sin_addr.s_addr &&
 461             ((htonl(them->s_addr) & htonl(localnet.sin_addr.s_addr)) != htonl(localnet.sin_addr.s_addr)))
 462                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
 463         else if (bindaddr.sin_addr.s_addr)
 464                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
 465         else
 466                 return ast_ouraddrfor(them, us);
 467         return 0;
 468 }
 469
 470 static int retrans_pkt(void *data)
 471 {
 472         struct sip_pkt *pkt=data;
 473         int res = 0;
 474         ast_mutex_lock(&pkt->owner->lock);
 475         if (pkt->retrans < MAX_RETRANS) {
 476                 pkt->retrans++;
 477                 if (sipdebug) {
 478                         if (pkt->owner->nat)
 479                                 ast_verbose("Retransmitting #%d (NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, inet_ntoa(pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port));
 480                         else
 481                                 ast_verbose("Retransmitting #%d (no NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, inet_ntoa(pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port));
 482                 }
 483                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
 484                 res = 1;
 485         } else {
 486                 ast_log(LOG_WARNING, "Maximum retries exceeded on call %s for seqno %d (%s)\n", pkt->owner->callid, pkt->seqno, pkt->resp ? "Response" : "Request");
 487                 pkt->retransid = -1;
 488                 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
 489                         ast_mutex_unlock(&pkt->owner->lock);
 490                         usleep(1);
 491                         ast_mutex_lock(&pkt->owner->lock);
 492                 }
 493                 if (pkt->owner->owner) {
 494                         /* XXX Potential deadlocK?? XXX */
 495                         ast_queue_hangup(pkt->owner->owner, 0);
 496                         ast_mutex_unlock(&pkt->owner->owner->lock);
 497                 } else {
 498                         /* If no owner, destroy now */
 499                         pkt->owner->needdestroy = 1;
 500                 }
 501         }
 502         if (pkt)
 503                 ast_mutex_unlock(&pkt->owner->lock);
 504         return res;
 505 }
 506
 507 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len)
 508 {
 509         struct sip_pkt *pkt;
 510         pkt = malloc(sizeof(struct sip_pkt) + len);
 511         if (!pkt)
 512                 return -1;
 513         memset(pkt, 0, sizeof(struct sip_pkt));
 514         memcpy(pkt->data, data, len);
 515         pkt->packetlen = len;
 516         pkt->next = p->packets;
 517         pkt->owner = p;
 518         pkt->seqno = seqno;
 519         pkt->resp = resp;
 520         /* Schedule retransmission */
 521         pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
 522         pkt->next = p->packets;
 523         p->packets = pkt;
 524         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
 525         if (!strncasecmp(pkt->data, "INVITE", 6)) {
 526                 /* Note this is a pending invite */
 527                 p->pendinginvite = seqno;
 528         }
 529         return 0;
 530 }
 531
 532 static int __sip_autodestruct(void *data)
 533 {
 534         struct sip_pvt *p = data;
 535         p->autokillid = -1;
 536         ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
 537         if (p->owner) {
 538                 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
 539                 ast_queue_hangup(p->owner, 0);
 540         } else {
 541                 sip_destroy(p);
 542         }
 543         return 0;
 544 }
 545
 546 static int sip_scheddestroy(struct sip_pvt *p, int ms)
 547 {
 548         if (p->autokillid > -1)
 549                 ast_sched_del(sched, p->autokillid);
 550         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
 551         return 0;
 552 }
 553
 554 static int sip_cancel_destroy(struct sip_pvt *p)
 555 {
 556         if (p->autokillid > -1)
 557                 ast_sched_del(sched, p->autokillid);
 558         p->autokillid = -1;
 559         return 0;
 560 }
 561
 562 static int __sip_ack(struct sip_pvt *p, int seqno, int resp)
 563 {
 564         struct sip_pkt *cur, *prev = NULL;
 565         int res = -1;
 566         int resetinvite = 0;
 567         cur = p->packets;
 568         while(cur) {
 569                 if ((cur->seqno == seqno) && (cur->resp == resp)) {
 570                         if (!resp && (seqno == p->pendinginvite)) {
 571                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
 572                                 p->pendinginvite = 0;
 573                                 resetinvite = 1;
 574                         }
 575                         /* this is our baby */
 576                         if (prev)
 577                                 prev->next = cur->next;
 578                         else
 579                                 p->packets = cur->next;
 580                         if (cur->retransid > -1)
 581                                 ast_sched_del(sched, cur->retransid);
 582                         free(cur);
 583                         res = 0;
 584                         break;
 585                 }
 586                 prev = cur;
 587                 cur = cur->next;
 588         }
 589         ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
 590         return res;
 591 }
 592
 593 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp)
 594 {
 595         struct sip_pkt *cur;
 596         int res = -1;
 597         cur = p->packets;
 598         while(cur) {
 599                 if ((cur->seqno == seqno) && (cur->resp == resp)) {
 600                         /* this is our baby */
 601                         if (cur->retransid > -1)
 602                                 ast_sched_del(sched, cur->retransid);
 603                         cur->retransid = -1;
 604                         res = 0;
 605                         break;
 606                 }
 607                 cur = cur->next;
 608         }
 609         ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
 610         return res;
 611 }
 612
 613 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
 614 {
 615         int res;
 616         if (sipdebug) {
 617                 if (p->nat)
 618                         ast_verbose("%sTransmitting (NAT):\n%s\n to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
 619                 else
 620                         ast_verbose("%sTransmitting (no NAT):\n%s\n to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port));
 621         }
 622         if (reliable)
 623                 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len);
 624         else
 625                 res = __sip_xmit(p, req->data, req->len);
 626         if (res > 0)
 627                 res = 0;
 628         return res;
 629 }
 630
 631 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
 632 {
 633         int res;
 634         if (sipdebug) {
 635                 if (p->nat)
 636                         ast_verbose("%sTransmitting:\n%s (NAT) to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
 637                 else
 638                         ast_verbose("%sTransmitting:\n%s (no NAT) to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port));
 639         }
 640         if (reliable)
 641                 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len);
 642         else
 643                 res = __sip_xmit(p, req->data, req->len);
 644         return res;
 645 }
 646
 647 static char *ditch_braces(char *tmp)
 648 {
 649         char *c = tmp;
 650         char *n;
 651         if ((n = strchr(tmp, '<')) ) {
 652                 c = n + 1;
 653                 while(*c && *c != '>') c++;
 654                 if (*c != '>') {
 655                         ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
 656                 } else {
 657                         *c = '\0';
 658                 }
 659                 return n+1;
 660         }
 661         return c;
 662 }
 663
 664 static int sip_sendtext(struct ast_channel *ast, char *text)
 665 {
 666         struct sip_pvt *p = ast->pvt->pvt;
 667         if (sipdebug)
 668                 ast_verbose("Sending text %s on %s\n", text, ast->name);
 669         if (!p)
 670                 return -1;
 671         if (!text || !strlen(text))
 672                 return 0;
 673         if (sipdebug)
 674                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
 675         transmit_message_with_text(p, text);
 676         return 0;
 677 }
 678
 679 #ifdef MYSQL_FRIENDS
 680
 681 static void mysql_update_peer(char *peer, struct sockaddr_in *sin)
 682 {
 683         if (mysql && (strlen(peer) < 128)) {
 684                 char query[512];
 685                 char *name;
 686                 time_t nowtime;
 687                 name = alloca(strlen(peer) * 2 + 1);
 688                 time(&nowtime);
 689                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
 690                 snprintf(query, sizeof(query), "UPDATE sipfriends SET ipaddr=\"%s\", port=\"%d\", regseconds=\"%ld\" WHERE name=\"%s\"",
 691                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), nowtime, name);
 692                 ast_mutex_lock(&mysqllock);
 693                 if (mysql_real_query(mysql, query, strlen(query)))
 694                         ast_log(LOG_WARNING, "Unable to update database\n");
 695
 696                 ast_mutex_unlock(&mysqllock);
 697         }
 698 }
 699
 700 static struct sip_peer *mysql_peer(char *peer, struct sockaddr_in *sin)
 701 {
 702         struct sip_peer *p;
 703         int success = 0;
 704
 705         p = malloc(sizeof(struct sip_peer));
 706         memset(p, 0, sizeof(struct sip_peer));
 707         if (mysql && (!peer || (strlen(peer) < 128))) {
 708                 char query[512];
 709                 char *name = NULL;
 710                 int numfields, x;
 711                 int port;
 712                 time_t regseconds, nowtime;
 713                 MYSQL_RES *result;
 714                 MYSQL_FIELD *fields;
 715                 MYSQL_ROW rowval;
 716                 if (peer) {
 717                         name = alloca(strlen(peer) * 2 + 1);
 718                         mysql_real_escape_string(mysql, name, peer, strlen(peer));
 719                 }
 720                 if (sin)
 721                         snprintf(query, sizeof(query), "SELECT * FROM sipfriends WHERE ipaddr=\"%s\" AND port=\"%d\"", inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
 722                 else
 723                         snprintf(query, sizeof(query), "SELECT * FROM sipfriends WHERE name=\"%s\"", name);
 724                 ast_mutex_lock(&mysqllock);
 725                 mysql_query(mysql, query);
 726                 if ((result = mysql_store_result(mysql))) {
 727                         if ((rowval = mysql_fetch_row(result))) {
 728                                 numfields = mysql_num_fields(result);
 729                                 fields = mysql_fetch_fields(result);
 730                                 success = 1;
 731                                 for (x=0;x<numfields;x++) {
 732                                         if (rowval[x]) {
 733                                                 if (!strcasecmp(fields[x].name, "secret")) {
 734                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
 735                                                 } else if (!strcasecmp(fields[x].name, "name")) {
 736                                                         strncpy(p->name, rowval[x], sizeof(p->name) - 1);
 737                                                 } else if (!strcasecmp(fields[x].name, "context")) {
 738                                                         strncpy(p->context, rowval[x], sizeof(p->context) - 1);
 739                                                 } else if (!strcasecmp(fields[x].name, "ipaddr")) {
 740                                                         inet_aton(rowval[x], &p->addr.sin_addr);
 741                                                 } else if (!strcasecmp(fields[x].name, "port")) {
 742                                                         if (sscanf(rowval[x], "%i", &port) != 1)
 743                                                                 port = 0;
 744                                                         p->addr.sin_port = htons(port);
 745                                                 } else if (!strcasecmp(fields[x].name, "regseconds")) {
 746                                                         if (sscanf(rowval[x], "%li", &regseconds) != 1)
 747                                                                 regseconds = 0;
 748                                                 }
 749                                         }
 750                                 }
 751                                 time(&nowtime);
 752                                 if ((nowtime - regseconds) > default_expiry)
 753                                         memset(&p->addr, 0, sizeof(p->addr));
 754                         }
 755                 }
 756                 ast_mutex_unlock(&mysqllock);
 757         }
 758         if (!success) {
 759                 free(p);
 760                 p = NULL;
 761         } else {
 762                 p->dynamic = 1;
 763                 p->capability = capability;
 764                 p->nat = globalnat;
 765                 p->dtmfmode = globaldtmfmode;
 766                 p->insecure = 1;
 767                 p->expire = -1;
 768                 p->temponly = 1;
 769
 770         }
 771         return p;
 772 }
 773 #endif /* MYSQL_FRIENDS */
 774
 775 static int create_addr(struct sip_pvt *r, char *peer)
 776 {
 777         struct hostent *hp;
 778         struct sip_peer *p;
 779         int found=0;
 780         char *port;
 781         int portno;
 782         char host[256], *hostn;
 783
 784         r->sa.sin_family = AF_INET;
 785         ast_mutex_lock(&peerl.lock);
 786         p = peerl.peers;
 787         while(p) {
 788                 if (!strcasecmp(p->name, peer))
 789                         break;
 790                 p = p->next;
 791         }
 792 #ifdef MYSQL_FRIENDS
 793         if (!p)
 794                 p = mysql_peer(peer, NULL);
 795 #endif
 796
 797         if (p) {
 798                         found++;
 799                         r->capability = p->capability;
 800                         r->nat = p->nat;
 801                         if (r->rtp) {
 802                                 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", r->nat);
 803                                 ast_rtp_setnat(r->rtp, r->nat);
 804                         }
 805                         if (r->vrtp) {
 806                                 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", r->nat);
 807                                 ast_rtp_setnat(r->vrtp, r->nat);
 808                         }
 809                         strncpy(r->peername, p->username, sizeof(r->peername)-1);
 810                         strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
 811                         strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
 812                         strncpy(r->username, p->username, sizeof(r->username)-1);
 813                         strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
 814                         if (!strlen(r->tohost)) {
 815                                 if (p->addr.sin_addr.s_addr)
 816                                         snprintf(r->tohost, sizeof(r->tohost), inet_ntoa(p->addr.sin_addr));
 817                                 else
 818                                         snprintf(r->tohost, sizeof(r->tohost), inet_ntoa(p->defaddr.sin_addr));
 819                         }
 820                         if (strlen(p->fromdomain))
 821                                 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
 822                         if (strlen(p->fromuser))
 823                                 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
 824                         r->insecure = p->insecure;
 825                         r->canreinvite = p->canreinvite;
 826                         r->maxtime = p->maxms;
 827                         r->callgroup = p->callgroup;
 828                         r->pickupgroup = p->pickupgroup;
 829                         if (p->dtmfmode) {
 830                                 r->dtmfmode = p->dtmfmode;
 831                                 if (r->dtmfmode & SIP_DTMF_RFC2833)
 832                                         r->noncodeccapability |= AST_RTP_DTMF;
 833                                 else
 834                                         r->noncodeccapability &= ~AST_RTP_DTMF;
 835                         }
 836                         strncpy(r->context, p->context,sizeof(r->context)-1);
 837                         if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
 838                                 (!p->maxms || ((p->lastms > 0)  && (p->lastms <= p->maxms)))) {
 839                                 if (p->addr.sin_addr.s_addr) {
 840                                         r->sa.sin_addr = p->addr.sin_addr;
 841                                         r->sa.sin_port = p->addr.sin_port;
 842                                 } else {
 843                                         r->sa.sin_addr = p->defaddr.sin_addr;
 844                                         r->sa.sin_port = p->defaddr.sin_port;
 845                                 }
 846                                 memcpy(&r->recv, &r->sa, sizeof(r->recv));
 847                         } else
 848                                 p = NULL;
 849         }
 850         ast_mutex_unlock(&peerl.lock);
 851         if (!p && !found) {
 852                 if ((port=strchr(peer, ':'))) {
 853                         *port='\0';
 854                         port++;
 855                 }
 856                 hostn = peer;
 857                 if (port)
 858                         portno = atoi(port);
 859                 else
 860                         portno = DEFAULT_SIP_PORT;
 861                 if (srvlookup) {
 862                         char service[256];
 863                         int tportno;
 864                         int ret;
 865                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
 866                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
 867                         if (ret > 0) {
 868                                 hostn = host;
 869                                 portno = tportno;
 870                         }
 871                 }
 872                 hp = gethostbyname(hostn);
 873                 if (hp) {
 874                         strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
 875                         memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
 876                         r->sa.sin_port = htons(portno);
 877                         memcpy(&r->recv, &r->sa, sizeof(r->recv));
 878                         return 0;
 879                 } else {
 880                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
 881                         return -1;
 882                 }
 883         } else if (!p)
 884                 return -1;
 885         else {
 886                 if (p->temponly)
 887                         free(p);
 888                 return 0;
 889         }
 890 }
 891
 892 static int auto_congest(void *nothing)
 893 {
 894         struct sip_pvt *p = nothing;
 895         ast_mutex_lock(&p->lock);
 896         p->initid = -1;
 897         if (p->owner) {
 898                 if (!ast_mutex_trylock(&p->owner->lock)) {
 899                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
 900                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION, 0);
 901                         ast_mutex_unlock(&p->owner->lock);
 902                 }
 903         }
 904         ast_mutex_unlock(&p->lock);
 905         return 0;
 906 }
 907
 908 static void sip_prefs_free(void)
 909 {
 910         struct sip_codec_pref *cur, *next;
 911         cur = prefs;
 912         while(cur) {
 913                 next = cur->next;
 914                 free(cur);
 915                 cur = next;
 916         }
 917         prefs = NULL;
 918 }
 919
 920 static void sip_pref_remove(int format)
 921 {
 922         struct sip_codec_pref *cur, *prev=NULL;
 923         cur = prefs;
 924         while(cur) {
 925                 if (cur->codec == format) {
 926                         if (prev)
 927                                 prev->next = cur->next;
 928                         else
 929                                 prefs = cur->next;
 930                         free(cur);
 931                         return;
 932                 }
 933                 prev = cur;
 934                 cur = cur->next;
 935         }
 936 }
 937
 938 static int sip_pref_append(int format)
 939 {
 940         struct sip_codec_pref *cur, *tmp;
 941         sip_pref_remove(format);
 942         tmp = (struct sip_codec_pref *)malloc(sizeof(struct sip_codec_pref));
 943         if (!tmp)
 944                 return -1;
 945         memset(tmp, 0, sizeof(struct sip_codec_pref));
 946         tmp->codec = format;
 947         if (prefs) {
 948                 cur = prefs;
 949                 while(cur->next)
 950                         cur = cur->next;
 951                 cur->next = tmp;
 952         } else
 953                 prefs = tmp;
 954         return 0;
 955 }
 956
 957 static int sip_codec_choose(int formats)
 958 {
 959         struct sip_codec_pref *cur;
 960         formats &= (AST_FORMAT_MAX_AUDIO - 1);
 961         cur = prefs;
 962         while(cur) {
 963                 if (formats & cur->codec)
 964                         return cur->codec;
 965                 cur = cur->next;
 966         }
 967         return ast_best_codec(formats);
 968 }
 969
 970 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
 971 {
 972         int res;
 973         struct sip_pvt *p;
 974         char *vxml_url = NULL;
 975         char *distinctive_ring = NULL;
 976         struct varshead *headp;
 977         struct ast_var_t *current;
 978
 979         p = ast->pvt->pvt;
 980         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
 981                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
 982                 return -1;
 983         }
 984         /* Check whether there is vxml_url, distinctive ring variables */
 985
 986         headp=&ast->varshead;
 987         AST_LIST_TRAVERSE(headp,current,entries) {
 988                 /* Check whether there is a VXML_URL variable */
 989                 if (strcasecmp(ast_var_name(current),"VXML_URL")==0)
 990                 {
 991                         vxml_url = ast_var_value(current);
 992                         break;
 993                 }
 994                 /* Check whether there is a ALERT_INFO variable */
 995                 if (strcasecmp(ast_var_name(current),"ALERT_INFO")==0)
 996                 {
 997                         distinctive_ring = ast_var_value(current);
 998                         break;
 999                 }
1000         }
1001
1002         res = 0;
1003         p->outgoing = 1;
1004         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1005         res = find_user(p,INC_OUT_USE);
1006         if ( res != -1 ) {
1007                 p->restrictcid = ast->restrictcid;
1008                 p->jointcapability = p->capability;
1009                 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, 1);
1010                 if (p->maxtime) {
1011                         /* Initialize auto-congest time */
1012                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1013                 }
1014         }
1015         return res;
1016 }
1017
1018 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1019 {
1020         struct sip_pvt *cur, *prev = NULL;
1021         struct sip_pkt *cp;
1022         if (sipdebug)
1023                 ast_log(LOG_DEBUG, "Destorying call '%s'\n", p->callid);
1024         if (p->stateid > -1)
1025                 ast_extension_state_del(p->stateid, NULL);
1026         if (p->initid > -1)
1027                 ast_sched_del(sched, p->initid);
1028         if (p->autokillid > -1)
1029                 ast_sched_del(sched, p->autokillid);
1030
1031         if (p->rtp) {
1032                 ast_rtp_destroy(p->rtp);
1033         }
1034         if (p->vrtp) {
1035                 ast_rtp_destroy(p->vrtp);
1036         }
1037         if (p->route) {
1038                 free_old_route(p->route);
1039                 p->route = NULL;
1040         }
1041         if (p->registry) {
1042                 /* Carefully unlink from registry */
1043                 struct sip_registry *reg;
1044                 reg = registrations;
1045                 while(reg) {
1046                         if ((reg == p->registry) && (p->registry->call == p))
1047                                 p->registry->call=NULL;
1048                         reg = reg->next;
1049                 }
1050         }
1051         /* Unlink us from the owner if we have one */
1052         if (p->owner) {
1053                 if (lockowner)
1054                         ast_mutex_lock(&p->owner->lock);
1055                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1056                 p->owner->pvt->pvt = NULL;
1057                 if (lockowner)
1058                         ast_mutex_unlock(&p->owner->lock);
1059         }
1060         cur = iflist;
1061         while(cur) {
1062                 if (cur == p) {
1063                         if (prev)
1064                                 prev->next = cur->next;
1065                         else
1066                                 iflist = cur->next;
1067                         break;
1068                 }
1069                 prev = cur;
1070                 cur = cur->next;
1071         }
1072         if (!cur) {
1073                 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1074         } else {
1075                 if (p->initid > -1)
1076                         ast_sched_del(sched, p->initid);
1077                 while((cp = p->packets)) {
1078                         p->packets = p->packets->next;
1079                         if (cp->retransid > -1)
1080                                 ast_sched_del(sched, cp->retransid);
1081                         free(cp);
1082                 }
1083                 free(p);
1084         }
1085 }
1086
1087 static int find_user(struct sip_pvt *fup, int event)
1088 {
1089         char name[256] = "";
1090         struct sip_user *u;
1091         strncpy(name, fup->username, sizeof(name) - 1);
1092         ast_mutex_lock(&userl.lock);
1093         u = userl.users;
1094         while(u) {
1095                 if (!strcasecmp(u->name, name)) {
1096                         break;
1097                 }
1098                 u = u->next;
1099         }
1100         if (!u) {
1101                 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1102                 ast_mutex_unlock(&userl.lock);
1103                 return 0;
1104         }
1105         switch(event) {
1106                 /* incoming and outgoing affects the inUse counter */
1107                 case DEC_OUT_USE:
1108                 case DEC_IN_USE:
1109                         if ( u->inUse > 0 ) {
1110                                 u->inUse--;
1111                         } else {
1112                                 u->inUse = 0;
1113                         }
1114                         break;
1115                 case INC_IN_USE:
1116                 case INC_OUT_USE:
1117                         if (u->incominglimit > 0 ) {
1118                                 if (u->inUse >= u->incominglimit) {
1119                                         ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1120                                         ast_mutex_unlock(&userl.lock);
1121                                         /* inc inUse as well */
1122                                         if ( event == INC_OUT_USE ) {
1123                                                 u->inUse++;
1124                                         }
1125                                         return -1;
1126                                 }
1127                         }
1128                         u->inUse++;
1129                         ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1130                         break;
1131                 /* we don't use these anymore
1132                 case DEC_OUT_USE:
1133                         if ( u->outUse > 0 ) {
1134                                 u->outUse--;
1135                         } else {
1136                                 u->outUse = 0;
1137                         }
1138                         break;
1139                 case INC_OUT_USE:
1140                         if ( u->outgoinglimit > 0 ) {
1141                                 if ( u->outUse >= u->outgoinglimit ) {
1142                                         ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1143                                         ast_mutex_unlock(&userl.lock);
1144                                         return -1;
1145                                 }
1146                         }
1147                         u->outUse++;
1148                         break;
1149                 */
1150                 default:
1151                         ast_log(LOG_ERROR, "find_user(%s,%d) called with no event!\n",u->name,event);
1152         }
1153         ast_mutex_unlock(&userl.lock);
1154         return 0;
1155 }
1156
1157 static void sip_destroy(struct sip_pvt *p)
1158 {
1159         ast_mutex_lock(&iflock);
1160         __sip_destroy(p, 1);
1161         ast_mutex_unlock(&iflock);
1162 }
1163
1164 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req);
1165
1166 static int hangup_sip2cause(int cause)
1167 {
1168         switch(cause)
1169         {
1170                 case 486:
1171                         return AST_CAUSE_BUSY;
1172                 default:
1173                         return AST_CAUSE_NORMAL;
1174         }
1175         /* Never reached */
1176         return 0;
1177 }
1178
1179 static char *hangup_cause2sip(int cause)
1180 {
1181         switch(cause)
1182         {
1183                 case AST_CAUSE_BUSY:
1184                         return "486 Busy";
1185                 default:
1186                         return NULL;
1187         }
1188         /* Never reached */
1189         return 0;
1190 }
1191
1192 static int sip_hangup(struct ast_channel *ast)
1193 {
1194         struct sip_pvt *p = ast->pvt->pvt;
1195         int needcancel = 0;
1196         int needdestroy = 0;
1197         if (option_debug)
1198                 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1199         if (!ast->pvt->pvt) {
1200                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1201                 return 0;
1202         }
1203         ast_mutex_lock(&p->lock);
1204         if ( p->outgoing ) {
1205                 ast_log(LOG_DEBUG, "find_user(%s) - decrement outUse counter\n", p->username);
1206                 find_user(p, DEC_OUT_USE);
1207         } else {
1208                 ast_log(LOG_DEBUG, "find_user(%s) - decrement inUse counter\n", p->username);
1209                 find_user(p, DEC_IN_USE);
1210         }
1211         /* Determine how to disconnect */
1212         if (p->owner != ast) {
1213                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
1214                 ast_mutex_unlock(&p->lock);
1215                 return 0;
1216         }
1217         if (!ast || (ast->_state != AST_STATE_UP))
1218                 needcancel = 1;
1219         /* Disconnect */
1220         p = ast->pvt->pvt;
1221         if (p->vad) {
1222             ast_dsp_free(p->vad);
1223         }
1224         p->owner = NULL;
1225         ast->pvt->pvt = NULL;
1226
1227         ast_mutex_lock(&usecnt_lock);
1228         usecnt--;
1229         ast_mutex_unlock(&usecnt_lock);
1230         ast_update_use_count();
1231
1232         needdestroy = 1;
1233         /* Start the process if it's not already started */
1234         if (!p->alreadygone && strlen(p->initreq.data)) {
1235                 if (needcancel) {
1236                         if (p->outgoing) {
1237                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1);
1238                                 /* Actually don't destroy us yet, wait for the 487 on our original
1239                                    INVITE, but do set an autodestruct just in case. */
1240                                 needdestroy = 0;
1241                                 sip_scheddestroy(p, 15000);
1242                                 if ( p->initid != -1 ) {
1243                                         /* channel still up - reverse dec of inUse counter
1244                                            only if the channel is not auto-congested */
1245                                         if ( p->outgoing ) {
1246                                                 find_user(p, INC_OUT_USE);
1247                                         }
1248                                         else {
1249                                                 find_user(p, INC_IN_USE);
1250                                         }
1251                                 }
1252                         } else {
1253                                 char *res;
1254                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1255                                         transmit_response_reliable(p, res, &p->initreq);
1256                                 } else
1257                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq);
1258                         }
1259                 } else {
1260                         if (!p->pendinginvite) {
1261                                 /* Send a hangup */
1262                                 transmit_request_with_auth(p, "BYE", 0, 1);
1263                         } else {
1264                                 /* Note we will need a BYE when this all settles out
1265                                    but we can't send one while we have "INVITE" outstanding. */
1266                                 p->pendingbye = 1;
1267                         }
1268                 }
1269         }
1270         p->needdestroy = needdestroy;
1271         ast_mutex_unlock(&p->lock);
1272         return 0;
1273 }
1274
1275 static int sip_answer(struct ast_channel *ast)
1276 {
1277         int res = 0,fmt;
1278         char *codec;
1279         struct sip_pvt *p = ast->pvt->pvt;
1280
1281
1282         if (ast->_state != AST_STATE_UP) {
1283
1284
1285
1286                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1287                 if (codec) {
1288                         fmt=ast_getformatbyname(codec);
1289                         if (fmt) {
1290                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1291                                 p->jointcapability=fmt;
1292                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1293                 }
1294
1295                 ast_setstate(ast, AST_STATE_UP);
1296                 if (option_debug)
1297                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1298                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1299         }
1300         return res;
1301 }
1302
1303 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1304 {
1305         struct sip_pvt *p = ast->pvt->pvt;
1306         int res = 0;
1307         if (frame->frametype == AST_FRAME_VOICE) {
1308                 if (!(frame->subclass & ast->nativeformats)) {
1309                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1310                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1311                         return -1;
1312                 }
1313                 if (p) {
1314                         ast_mutex_lock(&p->lock);
1315                         if (p->rtp) {
1316                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1317                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1318                                         p->progress = 1;
1319                                 }
1320                                 res =  ast_rtp_write(p->rtp, frame);
1321                         }
1322                         ast_mutex_unlock(&p->lock);
1323                 }
1324         } else if (frame->frametype == AST_FRAME_VIDEO) {
1325                 if (p) {
1326                         ast_mutex_lock(&p->lock);
1327                         if (p->vrtp) {
1328                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1329                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1330                                         p->progress = 1;
1331                                 }
1332                                 res =  ast_rtp_write(p->vrtp, frame);
1333                         }
1334                         ast_mutex_unlock(&p->lock);
1335                 }
1336         } else if (frame->frametype == AST_FRAME_IMAGE) {
1337                 return 0;
1338         } else {
1339                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1340                 return 0;
1341         }
1342
1343         return res;
1344 }
1345
1346 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1347 {
1348         struct sip_pvt *p = newchan->pvt->pvt;
1349         ast_mutex_lock(&p->lock);
1350         if (p->owner != oldchan) {
1351                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1352                 ast_mutex_unlock(&p->lock);
1353                 return -1;
1354         }
1355         p->owner = newchan;
1356         ast_mutex_unlock(&p->lock);
1357         return 0;
1358 }
1359
1360 static int sip_senddigit(struct ast_channel *ast, char digit)
1361 {
1362         struct sip_pvt *p = ast->pvt->pvt;
1363         if (p && (p->dtmfmode & SIP_DTMF_INFO)) {
1364                 transmit_info_with_digit(p, digit);
1365         }
1366         if (p && p->rtp && (p->dtmfmode & SIP_DTMF_RFC2833)) {
1367                 ast_rtp_senddigit(p->rtp, digit);
1368         }
1369         /* If in-band DTMF is desired, send that */
1370         if (p->dtmfmode & SIP_DTMF_INBAND)
1371                 return -1;
1372         return 0;
1373 }
1374
1375 static int sip_transfer(struct ast_channel *ast, char *dest)
1376 {
1377         struct sip_pvt *p = ast->pvt->pvt;
1378         int res;
1379         res = transmit_refer(p, dest);
1380         return res;
1381 }
1382
1383 static int sip_indicate(struct ast_channel *ast, int condition)
1384 {
1385         struct sip_pvt *p = ast->pvt->pvt;
1386         switch(condition) {
1387         case AST_CONTROL_RINGING:
1388                 if (ast->_state == AST_STATE_RING) {
1389                         if (!p->progress && !p->ringing) {
1390                                 transmit_response(p, "180 Ringing", &p->initreq);
1391                                 p->ringing = 1;
1392                                 break;
1393                         } else {
1394                                 /* Oops, we've sent progress tones.  Let Asterisk do it instead */
1395                         }
1396                 }
1397                 return -1;
1398         case AST_CONTROL_BUSY:
1399                 if (ast->_state != AST_STATE_UP) {
1400                         transmit_response(p, "486 Busy Here", &p->initreq);
1401                         p->alreadygone = 1;
1402                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1403                         break;
1404                 }
1405                 return -1;
1406         case AST_CONTROL_CONGESTION:
1407                 if (ast->_state != AST_STATE_UP) {
1408                         transmit_response(p, "503 Service Unavailable", &p->initreq);
1409                         p->alreadygone = 1;
1410                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1411                         break;
1412                 }
1413                 return -1;
1414         case AST_CONTROL_PROGRESS:
1415                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1416                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1417                         p->progress = 1;
1418                         break;
1419                 }
1420                 return -1;
1421         case -1:
1422                 return -1;
1423         default:
1424                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1425                 return -1;
1426         }
1427         return 0;
1428 }
1429
1430
1431
1432 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1433 {
1434         struct ast_channel *tmp;
1435         int fmt;
1436         tmp = ast_channel_alloc(1);
1437         if (tmp) {
1438                 /* Select our native format based on codec preference until we receive
1439                    something from another device to the contrary. */
1440                 if (i->jointcapability)
1441                         tmp->nativeformats = sip_codec_choose(i->jointcapability);
1442                 else if (i->capability)
1443                         tmp->nativeformats = sip_codec_choose(i->capability);
1444                 else
1445                         tmp->nativeformats = sip_codec_choose(capability);
1446                 fmt = ast_best_codec(tmp->nativeformats);
1447                 if (title)
1448                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
1449                 else
1450                         if (strchr(i->fromdomain,':'))
1451                         {
1452                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(i));
1453                         }
1454                         else
1455                         {
1456                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(i));
1457                         }
1458                 tmp->type = type;
1459                 if (i->dtmfmode & SIP_DTMF_INBAND) {
1460                     i->vad = ast_dsp_new();
1461                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
1462                 }
1463                 tmp->fds[0] = ast_rtp_fd(i->rtp);
1464                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
1465                 if (i->vrtp) {
1466                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
1467                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
1468                 }
1469                 ast_setstate(tmp, state);
1470                 if (state == AST_STATE_RING)
1471                         tmp->rings = 1;
1472                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1473                 tmp->writeformat = fmt;
1474                 tmp->pvt->rawwriteformat = fmt;
1475                 tmp->readformat = fmt;
1476                 tmp->pvt->rawreadformat = fmt;
1477                 tmp->pvt->pvt = i;
1478                 tmp->pvt->send_text = sip_sendtext;
1479                 tmp->pvt->call = sip_call;
1480                 tmp->pvt->hangup = sip_hangup;
1481                 tmp->pvt->answer = sip_answer;
1482                 tmp->pvt->read = sip_read;
1483                 tmp->pvt->write = sip_write;
1484                 tmp->pvt->write_video = sip_write;
1485                 tmp->pvt->indicate = sip_indicate;
1486                 tmp->pvt->transfer = sip_transfer;
1487                 tmp->pvt->fixup = sip_fixup;
1488                 tmp->pvt->send_digit = sip_senddigit;
1489
1490                 tmp->pvt->bridge = ast_rtp_bridge;
1491
1492                 tmp->callgroup = i->callgroup;
1493                 tmp->pickupgroup = i->pickupgroup;
1494                 tmp->restrictcid = i->restrictcid;
1495                 if (strlen(i->accountcode))
1496                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
1497                 if (i->amaflags)
1498                         tmp->amaflags = i->amaflags;
1499                 if (strlen(i->language))
1500                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
1501                 i->owner = tmp;
1502                 ast_mutex_lock(&usecnt_lock);
1503                 usecnt++;
1504                 ast_mutex_unlock(&usecnt_lock);
1505                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
1506                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
1507                 if (strlen(i->callerid))
1508                         tmp->callerid = strdup(i->callerid);
1509                 if (strlen(i->rdnis))
1510                         tmp->rdnis = strdup(i->rdnis);
1511                 tmp->priority = 1;
1512                 if (strlen(i->domain)) {
1513                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
1514                 }
1515
1516                 if (state != AST_STATE_DOWN) {
1517                         if (ast_pbx_start(tmp)) {
1518                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1519                                 ast_hangup(tmp);
1520                                 tmp = NULL;
1521                         }
1522                 }
1523         } else
1524                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1525         return tmp;
1526 }
1527
1528 static struct cfalias {
1529         char *fullname;
1530         char *shortname;
1531 } aliases[] = {
1532         { "Content-Type", "c" },
1533         { "Content-Encoding", "e" },
1534         { "From", "f" },
1535         { "Call-ID", "i" },
1536         { "Contact", "m" },
1537         { "Content-Length", "l" },
1538         { "Subject", "s" },
1539         { "To", "t" },
1540         { "Via", "v" },
1541 };
1542
1543 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
1544   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
1545     char* r = line + nameLen + 1;
1546     while (*r && (*r < 33)) ++r;
1547     return r;
1548   }
1549
1550   return "";
1551 }
1552
1553 static char *get_sdp(struct sip_request *req, char *name) {
1554   int x;
1555   int len = strlen(name);
1556   char *r;
1557
1558   for (x=0; x<req->lines; x++) {
1559     r = get_sdp_by_line(req->line[x], name, len);
1560     if (r[0] != '\0') return r;
1561   }
1562   return "";
1563 }
1564
1565 static void sdpLineNum_iterator_init(int* iterator) {
1566   *iterator = 0;
1567 }
1568
1569 static char* get_sdp_iterate(int* iterator,
1570                              struct sip_request *req, char *name) {
1571   int len = strlen(name);
1572   char *r;
1573   while (*iterator < req->lines) {
1574     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
1575     if (r[0] != '\0') return r;
1576   }
1577   return "";
1578 }
1579
1580 static char *__get_header(struct sip_request *req, char *name, int *start)
1581 {
1582         int x;
1583         int len = strlen(name);
1584         char *r;
1585         for (x=*start;x<req->headers;x++) {
1586                 if (!strncasecmp(req->header[x], name, len) &&
1587                                 (req->header[x][len] == ':')) {
1588                                         r = req->header[x] + len + 1;
1589                                         while(*r && (*r < 33))
1590                                                         r++;
1591                                         *start = x+1;
1592                                         return r;
1593                 }
1594         }
1595         /* Try aliases */
1596         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
1597                 if (!strcasecmp(aliases[x].fullname, name))
1598                         return __get_header(req, aliases[x].shortname, start);
1599
1600         /* Don't return NULL, so get_header is always a valid pointer */
1601         return "";
1602 }
1603
1604 static char *get_header(struct sip_request *req, char *name)
1605 {
1606         int start = 0;
1607         return __get_header(req, name, &start);
1608 }
1609
1610 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
1611 {
1612         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
1613         struct ast_frame *f;
1614         static struct ast_frame null_frame = { AST_FRAME_NULL, };
1615         switch(ast->fdno) {
1616         case 0:
1617                 f = ast_rtp_read(p->rtp);
1618                 break;
1619         case 1:
1620                 f = ast_rtcp_read(p->rtp);
1621                 break;
1622         case 2:
1623                 f = ast_rtp_read(p->vrtp);
1624                 break;
1625         case 3:
1626                 f = ast_rtcp_read(p->vrtp);
1627                 break;
1628         default:
1629                 f = &null_frame;
1630         }
1631         /* Don't send RFC2833 if we're not supposed to */
1632         if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & SIP_DTMF_RFC2833))
1633                 return &null_frame;
1634         if (p->owner) {
1635                 /* We already hold the channel lock */
1636                 if (f->frametype == AST_FRAME_VOICE) {
1637                         if (f->subclass != p->owner->nativeformats) {
1638                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
1639                                 p->owner->nativeformats = f->subclass;
1640                                 ast_set_read_format(p->owner, p->owner->readformat);
1641                                 ast_set_write_format(p->owner, p->owner->writeformat);
1642                         }
1643             if (p->dtmfmode & SIP_DTMF_INBAND) {
1644                    f = ast_dsp_process(p->owner,p->vad,f,0);
1645             }
1646                 }
1647         }
1648         return f;
1649 }
1650
1651 static struct ast_frame *sip_read(struct ast_channel *ast)
1652 {
1653         struct ast_frame *fr;
1654         struct sip_pvt *p = ast->pvt->pvt;
1655         ast_mutex_lock(&p->lock);
1656         fr = sip_rtp_read(ast, p);
1657         ast_mutex_unlock(&p->lock);
1658         return fr;
1659 }
1660
1661 static void build_callid(char *callid, int len, struct in_addr ourip)
1662 {
1663         int res;
1664         int val;
1665         int x;
1666         for (x=0;x<4;x++) {
1667                 val = rand();
1668                 res = snprintf(callid, len, "%08x", val);
1669                 len -= res;
1670                 callid += res;
1671         }
1672         /* It's not important that we really use our right IP here... */
1673         snprintf(callid, len, "@%s", inet_ntoa(ourip));
1674 }
1675
1676 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobalnat)
1677 {
1678         struct sip_pvt *p;
1679
1680         p = malloc(sizeof(struct sip_pvt));
1681         if (!p)
1682                 return NULL;
1683         /* Keep track of stuff */
1684         memset(p, 0, sizeof(struct sip_pvt));
1685         p->initid = -1;
1686         p->autokillid = -1;
1687         p->stateid = -1;
1688         p->rtp = ast_rtp_new(sched, io, 1, 0);
1689         if (videosupport)
1690                 p->vrtp = ast_rtp_new(sched, io, 1, 0);
1691         p->branch = rand();
1692         p->tag = rand();
1693
1694         /* Start with 101 instead of 1 */
1695         p->ocseq = 101;
1696         if (!p->rtp) {
1697                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
1698                 free(p);
1699                 return NULL;
1700         }
1701         ast_rtp_settos(p->rtp, tos);
1702         if (p->vrtp)
1703                 ast_rtp_settos(p->vrtp, tos);
1704         if (useglobalnat && sin) {
1705                 /* Setup NAT structure according to global settings if we have an address */
1706                 p->nat = globalnat;
1707                 memcpy(&p->recv, sin, sizeof(p->recv));
1708                 ast_rtp_setnat(p->rtp, p->nat);
1709                 if (p->vrtp)
1710                         ast_rtp_setnat(p->vrtp, p->nat);
1711         }
1712         ast_mutex_init(&p->lock);
1713
1714         if (sin) {
1715                 memcpy(&p->sa, sin, sizeof(p->sa));
1716                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
1717                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
1718         } else {
1719                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
1720         }
1721         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1722         snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
1723         if (!callid)
1724                 build_callid(p->callid, sizeof(p->callid), p->ourip);
1725         else
1726                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
1727         /* Assume reinvite OK and via INVITE */
1728         p->canreinvite = globalcanreinvite;
1729         p->dtmfmode = globaldtmfmode;
1730         p->capability = capability;
1731         if (p->dtmfmode & SIP_DTMF_RFC2833)
1732                 p->noncodeccapability |= AST_RTP_DTMF;
1733         strncpy(p->context, context, sizeof(p->context) - 1);
1734         strncpy(p->fromdomain, fromdomain, sizeof(p->fromdomain) - 1);
1735         /* Add to list */
1736         ast_mutex_lock(&iflock);
1737         p->next = iflist;
1738         iflist = p;
1739         ast_mutex_unlock(&iflock);
1740         if (option_debug)
1741                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
1742         return p;
1743 }
1744
1745 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
1746 {
1747         struct sip_pvt *p;
1748         char *callid;
1749         char tmp[256] = "";
1750         char *cmd;
1751         char *tag = "", *c;
1752         int themisfrom;
1753         callid = get_header(req, "Call-ID");
1754
1755         if (pedanticsipchecking) {
1756                 /* In principle Call-ID's uniquely identify a call, however some vendors
1757                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
1758                    tags in order to simplify billing.  The RFC does state that we have to
1759                    compare tags in addition to the call-id, but this generate substantially
1760                    more overhead which is totally unnecessary for the vast majority of sane
1761                    SIP implementations, and thus Asterisk does not enable this behavior
1762                    by default. Short version: You'll need this option to support conferencing
1763                    on the pingtel */
1764                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
1765                 cmd = tmp;
1766                 c = strchr(tmp, ' ');
1767                 if (c)
1768                         *c = '\0';
1769                 if (!strcasecmp(cmd, "SIP/2.0")) {
1770                         themisfrom = 0;
1771                 } else {
1772                         themisfrom = 1;
1773                 }
1774                 if (themisfrom)
1775                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
1776                 else
1777                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
1778                 tag = strstr(tmp, "tag=");
1779                 if (tag) {
1780                         tag += 4;
1781                         c = strchr(tag, ';');
1782                         if (c)
1783                                 *c = '\0';
1784                 }
1785
1786         }
1787
1788         if (!strlen(callid)) {
1789                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", inet_ntoa(sin->sin_addr));
1790                 return NULL;
1791         }
1792         ast_mutex_lock(&iflock);
1793         p = iflist;
1794         while(p) {
1795                 if (!strcmp(p->callid, callid) &&
1796                         (!pedanticsipchecking || !tag || !strlen(p->theirtag) || !strcmp(p->theirtag, tag))) {
1797                         /* Found the call */
1798                         ast_mutex_lock(&p->lock);
1799                         ast_mutex_unlock(&iflock);
1800                         return p;
1801                 }
1802                 p = p->next;
1803         }
1804         ast_mutex_unlock(&iflock);
1805         p = sip_alloc(callid, sin, 1);
1806         if (p)
1807                 ast_mutex_lock(&p->lock);
1808         return p;
1809 }
1810
1811 static int sip_register(char *value, int lineno)
1812 {
1813         struct sip_registry *reg;
1814         char copy[256] = "";
1815         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
1816         char *porta=NULL;
1817         char *contact=NULL;
1818         char *stringp=NULL;
1819
1820         struct hostent *hp;
1821         if (!value)
1822                 return -1;
1823         strncpy(copy, value, sizeof(copy)-1);
1824         stringp=copy;
1825         username = stringp;
1826         hostname = strrchr(stringp, '@');
1827         if (hostname) {
1828                 *hostname = '\0';
1829                 hostname++;
1830         }
1831         if (!username || !strlen(username) || !hostname || !strlen(hostname)) {
1832                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
1833                 return -1;
1834         }
1835         stringp=username;
1836         username = strsep(&stringp, ":");
1837         if (username) {
1838                 secret = strsep(&stringp, ":");
1839                 if (secret)
1840                         authuser = strsep(&stringp, ":");
1841         }
1842         stringp = hostname;
1843         hostname = strsep(&stringp, "/");
1844         if (hostname)
1845                 contact = strsep(&stringp, "/");
1846         if (!contact || !strlen(contact))
1847                 contact = "s";
1848         stringp=hostname;
1849         hostname = strsep(&stringp, ":");
1850         porta = strsep(&stringp, ":");
1851
1852         if (porta && !atoi(porta)) {
1853                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
1854                 return -1;
1855         }
1856         hp = gethostbyname(hostname);
1857         if (!hp) {
1858                 ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
1859                 return -1;
1860         }
1861         reg = malloc(sizeof(struct sip_registry));
1862         if (reg) {
1863                 memset(reg, 0, sizeof(struct sip_registry));
1864                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
1865                 if (username)
1866                         strncpy(reg->username, username, sizeof(reg->username)-1);
1867                 if (hostname)
1868                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
1869                 if (authuser)
1870                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
1871                 if (secret)
1872                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
1873                 reg->expire = -1;
1874                 reg->timeout =  -1;
1875                 reg->refresh = default_expiry;
1876                 reg->addr.sin_family = AF_INET;
1877                 memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
1878                 reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(DEFAULT_SIP_PORT);
1879                 reg->next = registrations;
1880                 reg->callid_valid = 0;
1881                 reg->ocseq = 101;
1882                 registrations = reg;
1883         } else {
1884                 ast_log(LOG_ERROR, "Out of memory\n");
1885                 return -1;
1886         }
1887         return 0;
1888 }
1889
1890 static void parse(struct sip_request *req)
1891 {
1892         /* Divide fields by NULL's */
1893         char *c;
1894         int f = 0;
1895         c = req->data;
1896
1897         /* First header starts immediately */
1898         req->header[f] = c;
1899         while(*c) {
1900                 if (*c == '\n') {
1901                         /* We've got a new header */
1902                         *c = 0;
1903
1904 #if 0
1905                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
1906 #endif
1907                         if (!strlen(req->header[f])) {
1908                                 /* Line by itself means we're now in content */
1909                                 c++;
1910                                 break;
1911                         }
1912                         if (f >= SIP_MAX_HEADERS - 1) {
1913                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
1914                         } else
1915                                 f++;
1916                         req->header[f] = c + 1;
1917                 } else if (*c == '\r') {
1918                         /* Ignore but eliminate \r's */
1919                         *c = 0;
1920                 }
1921                 c++;
1922         }
1923         /* Check for last header */
1924         if (strlen(req->header[f]))
1925                 f++;
1926         req->headers = f;
1927         /* Now we process any mime content */
1928         f = 0;
1929         req->line[f] = c;
1930         while(*c) {
1931                 if (*c == '\n') {
1932                         /* We've got a new line */
1933                         *c = 0;
1934 #if 0
1935                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
1936 #endif
1937                         if (f >= SIP_MAX_LINES - 1) {
1938                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
1939                         } else
1940                                 f++;
1941                         req->line[f] = c + 1;
1942                 } else if (*c == '\r') {
1943                         /* Ignore and eliminate \r's */
1944                         *c = 0;
1945                 }
1946                 c++;
1947         }
1948         /* Check for last line */
1949         if (strlen(req->line[f]))
1950                 f++;
1951         req->lines = f;
1952         if (sipdebug)
1953                 ast_verbose("%d headers, %d lines\n", req->headers, req->lines);
1954         if (*c)
1955                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
1956 }
1957
1958 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
1959 {
1960         char *m;
1961         char *c;
1962         char *a;
1963         char host[258];
1964         int len = -1;
1965         int portno=0;
1966         int vportno=0;
1967         int peercapability, peernoncodeccapability;
1968         int vpeercapability=0, vpeernoncodeccapability=0;
1969         struct sockaddr_in sin;
1970         char *codecs;
1971         struct hostent *hp;
1972         int codec;
1973         int iterator;
1974         int sendonly = 0;
1975         int x;
1976
1977         /* Get codec and RTP info from SDP */
1978         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
1979                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
1980                 return -1;
1981         }
1982         m = get_sdp(req, "m");
1983         c = get_sdp(req, "c");
1984         if (!strlen(m) || !strlen(c)) {
1985                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
1986                 return -1;
1987         }
1988         if (sscanf(c, "IN IP4 %256s", host) != 1) {
1989                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
1990                 return -1;
1991         }
1992         /* XXX This could block for a long time, and block the main thread! XXX */
1993         hp = gethostbyname(host);
1994         if (!hp) {
1995                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
1996                 return -1;
1997         }
1998         sdpLineNum_iterator_init(&iterator);
1999         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2000                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
2001                         portno = x;
2002                         // Scan through the RTP payload types specified in a "m=" line:
2003                         ast_rtp_pt_clear(p->rtp);
2004                         codecs = m + len;
2005                         while(strlen(codecs)) {
2006                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2007                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2008                                         return -1;
2009                                 }
2010                                 if (sipdebug)
2011                                         ast_verbose("Found audio format %s\n", ast_getformatname(codec));
2012                                 ast_rtp_set_m_type(p->rtp, codec);
2013                                 codecs += len;
2014                                 /* Skip over any whitespace */
2015                                 while(*codecs && (*codecs < 33)) codecs++;
2016                         }
2017                 }
2018                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2019                         vportno = x;
2020                         // Scan through the RTP payload types specified in a "m=" line:
2021                         ast_rtp_pt_clear(p->vrtp);
2022                         codecs = m + len;
2023                         while(strlen(codecs)) {
2024                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2025                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2026                                         return -1;
2027                                 }
2028                                 if (sipdebug)
2029                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2030                                 ast_rtp_set_m_type(p->vrtp, codec);
2031                                 codecs += len;
2032                                 /* Skip over any whitespace */
2033                                 while(*codecs && (*codecs < 33)) codecs++;
2034                         }
2035                 }
2036         }
2037         sin.sin_family = AF_INET;
2038         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2039         /* Setup audio port number */
2040         sin.sin_port = htons(portno);
2041         if (p->rtp && sin.sin_port)
2042                 ast_rtp_set_peer(p->rtp, &sin);
2043         /* Setup video port number */
2044         sin.sin_port = htons(vportno);
2045         if (p->vrtp && sin.sin_port)
2046                 ast_rtp_set_peer(p->vrtp, &sin);
2047 #if 0
2048         printf("Peer RTP is at port %s:%d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2049 #endif
2050         // Next, scan through each "a=rtpmap:" line, noting each
2051         // specified RTP payload type (with corresponding MIME subtype):
2052         sdpLineNum_iterator_init(&iterator);
2053         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2054       char* mimeSubtype = ast_strdupa(a); // ensures we have enough space
2055           if (!strcasecmp(a, "sendonly")) {
2056                 sendonly=1;
2057                 continue;
2058           }
2059           if (!strcasecmp(a, "sendrecv")) {
2060                 sendonly=0;
2061           }
2062           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2063           if (sipdebug)
2064                 ast_verbose("Found description format %s\n", mimeSubtype);
2065           // Note: should really look at the 'freq' and '#chans' params too
2066           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2067           if (p->vrtp)
2068                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2069         }
2070
2071         // Now gather all of the codecs that were asked for:
2072         ast_rtp_get_current_formats(p->rtp,
2073                                 &peercapability, &peernoncodeccapability);
2074         if (p->vrtp)
2075                 ast_rtp_get_current_formats(p->vrtp,
2076                                 &vpeercapability, &vpeernoncodeccapability);
2077         p->jointcapability = p->capability & (peercapability | vpeercapability);
2078         p->noncodeccapability = noncodeccapability & (peernoncodeccapability | vpeernoncodeccapability);
2079
2080         if (sipdebug) {
2081                 ast_verbose("Capabilities: us - %d, them - %d/%d, combined - %d\n",
2082                             p->capability, peercapability, vpeercapability, p->jointcapability);
2083                 ast_verbose("Non-codec capabilities: us - %d, them - %d, combined - %d\n",
2084                             noncodeccapability, peernoncodeccapability,
2085                             p->noncodeccapability);
2086         }
2087         if (!p->jointcapability) {
2088                 ast_log(LOG_WARNING, "No compatible codecs!\n");
2089                 return -1;
2090         }
2091         if (p->owner) {
2092                 if (!(p->owner->nativeformats & p->jointcapability)) {
2093                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %d and not %d\n", p->jointcapability, p->owner->nativeformats);
2094                         p->owner->nativeformats = sip_codec_choose(p->jointcapability);
2095                         ast_set_read_format(p->owner, p->owner->readformat);
2096                         ast_set_write_format(p->owner, p->owner->writeformat);
2097                 }
2098                 if (p->owner->bridge) {
2099                         /* Turn on/off music on hold if we are holding/unholding */
2100                         if (sin.sin_addr.s_addr && !sendonly) {
2101                                 ast_moh_stop(p->owner->bridge);
2102                         } else {
2103                                 ast_moh_start(p->owner->bridge, NULL);
2104                         }
2105                 }
2106         }
2107         return 0;
2108
2109 }
2110
2111 static int add_header(struct sip_request *req, char *var, char *value)
2112 {
2113         if (req->len >= sizeof(req->data) - 4) {
2114                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2115                 return -1;
2116         }
2117         if (req->lines) {
2118                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2119                 return -1;
2120         }
2121         req->header[req->headers] = req->data + req->len;
2122         snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2123         req->len += strlen(req->header[req->headers]);
2124         if (req->headers < SIP_MAX_HEADERS)
2125                 req->headers++;
2126         else {
2127                 ast_log(LOG_WARNING, "Out of header space\n");
2128                 return -1;
2129         }
2130         return 0;
2131 }
2132
2133 static int add_blank_header(struct sip_request *req)
2134 {
2135         if (req->len >= sizeof(req->data) - 4) {
2136                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2137                 return -1;
2138         }
2139         if (req->lines) {
2140                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2141                 return -1;
2142         }
2143         req->header[req->headers] = req->data + req->len;
2144         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2145         req->len += strlen(req->header[req->headers]);
2146         if (req->headers < SIP_MAX_HEADERS)
2147                 req->headers++;
2148         else {
2149                 ast_log(LOG_WARNING, "Out of header space\n");
2150                 return -1;
2151         }
2152         return 0;
2153 }
2154
2155 static int add_line(struct sip_request *req, char *line)
2156 {
2157         if (req->len >= sizeof(req->data) - 4) {
2158                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2159                 return -1;
2160         }
2161         if (!req->lines) {
2162                 /* Add extra empty return */
2163                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2164                 req->len += strlen(req->data + req->len);
2165         }
2166         req->line[req->lines] = req->data + req->len;
2167         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2168         req->len += strlen(req->line[req->lines]);
2169         if (req->lines < SIP_MAX_LINES)
2170                 req->lines++;
2171         else {
2172                 ast_log(LOG_WARNING, "Out of line space\n");
2173                 return -1;
2174         }
2175         return 0;
2176 }
2177
2178 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2179 {
2180         char *tmp;
2181         tmp = get_header(orig, field);
2182         if (strlen(tmp)) {
2183                 /* Add what we're responding to */
2184                 return add_header(req, field, tmp);
2185         }
2186         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2187         return -1;
2188 }
2189
2190 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2191 {
2192         char *tmp;
2193         int start = 0;
2194         int copied = 0;
2195         for (;;) {
2196                 tmp = __get_header(orig, field, &start);
2197                 if (strlen(tmp)) {
2198                         /* Add what we're responding to */
2199                         add_header(req, field, tmp);
2200                         copied++;
2201                 } else
2202                         break;
2203         }
2204         return copied ? 0 : -1;
2205 }
2206
2207 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2208 {
2209         char *tmp;
2210         int start = 0;
2211         int copied = 0;
2212         char new[256];
2213         for (;;) {
2214                 tmp = __get_header(orig, field, &start);
2215                 if (strlen(tmp)) {
2216                         if (!copied && p->nat) {
2217 #ifdef THE_SIP_AUTHORS_CAN_SUCK_MY_GONADS
2218                                 /* SLD: FIXME: Nice try, but the received= should not have a port */
2219                                 /* SLD: FIXME: See RFC2543 BNF in Section 6.40.5 */
2220                                 /* MAS: Yup, RFC says you can't do it.  No way to indicate PAT...
2221                                    good job fellas. */
2222                                 if (ntohs(p->recv.sin_port) != DEFAULT_SIP_PORT)
2223                                         snprintf(new, sizeof(new), "%s;received=%s:%d", tmp, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
2224                                 else
2225 #endif
2226                                         snprintf(new, sizeof(new), "%s;received=%s", tmp, inet_ntoa(p->recv.sin_addr));
2227                                 add_header(req, field, new);
2228                         } else {
2229                                 /* Add what we're responding to */
2230                                 add_header(req, field, tmp);
2231                         }
2232                         copied++;
2233                 } else
2234                         break;
2235         }
2236         if (!copied) {
2237                 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2238                 return -1;
2239         }
2240         return 0;
2241 }
2242
2243 /* Add Route: header into request per learned route */
2244 static void add_route(struct sip_request *req, struct sip_route *route)
2245 {
2246         char r[256], *p;
2247         int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2248
2249         if (!route) return;
2250
2251         p = r;
2252         while (route) {
2253                 n = strlen(route->hop);
2254                 if ((n+3)>rem) break;
2255                 if (p != r) {
2256                         *p++ = ',';
2257                         --rem;
2258                 }
2259                 *p++ = '<';
2260                 strcpy(p, route->hop);  p += n;
2261                 *p++ = '>';
2262                 rem -= (n+2);
2263                 route = route->next;
2264         }
2265         *p = '\0';
2266         add_header(req, "Route", r);
2267 }
2268
2269 static void set_destination(struct sip_pvt *p, char *uri)
2270 {
2271         char *h, *maddr, hostname[256];
2272         int port, hn;
2273         struct hostent *hp;
2274
2275         /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2276         /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2277
2278         if (sipdebug)
2279                 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2280
2281         /* Find and parse hostname */
2282         h = strchr(uri, '@');
2283         if (h)
2284                 ++h;
2285         else {
2286                 h = uri;
2287                 if (strncmp(h, "sip:", 4) == 0)
2288                         h += 4;
2289                 else if (strncmp(h, "sips:", 5) == 0)
2290                         h += 5;
2291         }
2292         hn = strcspn(h, ":;>");
2293         if (hn>255) hn=255;
2294         strncpy(hostname, h, hn);  hostname[hn] = '\0';
2295         h+=hn;
2296
2297         /* Is "port" present? if not default to 5060 */
2298         if (*h == ':') {
2299                 /* Parse port */
2300                 ++h;
2301                 port = strtol(h, &h, 10);
2302         }
2303         else
2304                 port = 5060;
2305
2306         /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
2307         maddr = strstr(h, "maddr=");
2308         if (maddr) {
2309                 maddr += 6;
2310                 hn = strspn(maddr, "0123456789.");
2311                 if (hn>255) hn=255;
2312                 strncpy(hostname, maddr, hn);  hostname[hn] = '\0';
2313         }
2314
2315         hp = gethostbyname(hostname);
2316         if (hp == NULL)  {
2317                 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
2318                 return;
2319         }
2320         p->sa.sin_family = AF_INET;
2321         memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
2322         p->sa.sin_port = htons(port);
2323         if (sipdebug)
2324                 ast_verbose("set_destination: set destination to %s, port %d\n", inet_ntoa(p->sa.sin_addr), port);
2325 }
2326
2327 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
2328 {
2329         /* Initialize a response */
2330         if (req->headers || req->len) {
2331                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2332                 return -1;
2333         }
2334         req->header[req->headers] = req->data + req->len;
2335         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
2336         req->len += strlen(req->header[req->headers]);
2337         if (req->headers < SIP_MAX_HEADERS)
2338                 req->headers++;
2339         else
2340                 ast_log(LOG_WARNING, "Out of header space\n");
2341         return 0;
2342 }
2343
2344 static int init_req(struct sip_request *req, char *resp, char *recip)
2345 {
2346         /* Initialize a response */
2347         if (req->headers || req->len) {
2348                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2349                 return -1;
2350         }
2351         req->header[req->headers] = req->data + req->len;
2352         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
2353         req->len += strlen(req->header[req->headers]);
2354         if (req->headers < SIP_MAX_HEADERS)
2355                 req->headers++;
2356         else
2357                 ast_log(LOG_WARNING, "Out of header space\n");
2358         return 0;
2359 }
2360
2361 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
2362 {
2363         char newto[256] = "", *ot;
2364         memset(resp, 0, sizeof(*resp));
2365         init_resp(resp, msg, req);
2366         copy_via_headers(p, resp, req, "Via");
2367         if (msg[0] == '2') copy_all_header(resp, req, "Record-Route");
2368         copy_header(resp, req, "From");
2369         ot = get_header(req, "To");
2370         if (!strstr(ot, "tag=")) {
2371                 /* Add the proper tag if we don't have it already.  If they have specified
2372                    their tag, use it.  Otherwise, use our own tag */
2373                 if (strlen(p->theirtag) && p->outgoing)
2374                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
2375                 else if (p->tag && !p->outgoing)
2376                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
2377                 else
2378                         strncpy(newto, ot, sizeof(newto) - 1);
2379                 ot = newto;
2380         }
2381         add_header(resp, "To", ot);
2382         copy_header(resp, req, "Call-ID");
2383         copy_header(resp, req, "CSeq");
2384         add_header(resp, "User-Agent", "Asterisk PBX");
2385         add_header(resp, "Allow", ALLOWED_METHODS);
2386         if (p->expiry) {
2387                 /* For registration responses, we also need expiry and
2388                    contact info */
2389                 char contact[256];
2390                 char tmp[256];
2391                 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
2392                 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
2393                 add_header(resp, "Expires", tmp);
2394                 add_header(resp, "Contact", contact);
2395         } else {
2396                 add_header(resp, "Contact", p->our_contact);
2397         }
2398         return 0;
2399 }
2400
2401 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno)
2402 {
2403         struct sip_request *orig = &p->initreq;
2404         char stripped[80] ="";
2405         char tmp[80];
2406         char newto[256];
2407         char *c, *n;
2408         char *ot, *of;
2409
2410         memset(req, 0, sizeof(struct sip_request));
2411
2412         snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
2413
2414         if (!seqno) {
2415                 p->ocseq++;
2416                 seqno = p->ocseq;
2417         }
2418
2419         if (strlen(p->uri)) {
2420                 c = p->uri;
2421         } else {
2422                 if (p->outgoing)
2423                         strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
2424                 else
2425                         strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
2426
2427                 c = strchr(stripped, '<');
2428                 if (c)
2429                         c++;
2430                 else
2431                         c = stripped;
2432                 n = strchr(c, '>');
2433                 if (n)
2434                         *n = '\0';
2435                 n = strchr(c, ';');
2436                 if (n)
2437                         *n = '\0';
2438         }
2439         init_req(req, msg, c);
2440
2441         snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
2442
2443         add_header(req, "Via", p->via);
2444         if (p->route) {
2445                 set_destination(p, p->route->hop);
2446                 add_route(req, p->route->next);
2447         }
2448
2449         ot = get_header(orig, "To");
2450         of = get_header(orig, "From");
2451
2452         /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
2453            as our original request, including tag (or presumably lack thereof) */
2454         if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
2455                 /* Add the proper tag if we don't have it already.  If they have specified
2456                    their tag, use it.  Otherwise, use our own tag */
2457                 if (p->outgoing && strlen(p->theirtag))
2458                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
2459                 else if (!p->outgoing)
2460                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
2461                 else
2462                         snprintf(newto, sizeof(newto), "%s", ot);
2463                 ot = newto;
2464         }
2465
2466         if (p->outgoing) {
2467                 add_header(req, "From", of);
2468                 add_header(req, "To", ot);
2469         } else {
2470                 add_header(req, "From", ot);
2471                 add_header(req, "To", of);
2472         }
2473         add_header(req, "Contact", p->our_contact);
2474         copy_header(req, orig, "Call-ID");
2475         add_header(req, "CSeq", tmp);
2476
2477         add_header(req, "User-Agent", "Asterisk PBX");
2478         return 0;
2479 }
2480
2481 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
2482 {
2483         struct sip_request resp;
2484         int seqno = 0;
2485         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
2486                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
2487                 return -1;
2488         }
2489         respprep(&resp, p, msg, req);
2490         add_header(&resp, "Content-Length", "0");
2491         add_blank_header(&resp);
2492         return send_response(p, &resp, reliable, seqno);
2493 }
2494
2495 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req)
2496 {
2497         return __transmit_response(p, msg, req, 0);
2498 }
2499 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req)
2500 {
2501         return __transmit_response(p, msg, req, 1);
2502 }
2503
2504 static void append_date(struct sip_request *req)
2505 {
2506         char tmpdat[256];
2507         struct tm tm;
2508         time_t t;
2509         time(&t);
2510         gmtime_r(&t, &tm);
2511         strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
2512         add_header(req, "Date", tmpdat);
2513 }
2514
2515 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
2516 {
2517         struct sip_request resp;
2518         respprep(&resp, p, msg, req);
2519         append_date(&resp);
2520         add_header(&resp, "Content-Length", "0");
2521         add_blank_header(&resp);
2522         return send_response(p, &resp, 0, 0);
2523 }
2524
2525 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req)
2526 {
2527         struct sip_request resp;
2528         respprep(&resp, p, msg, req);
2529         add_header(&resp, "Accept", "application/sdp");
2530         add_header(&resp, "Content-Length", "0");
2531         add_blank_header(&resp);
2532         return send_response(p, &resp, 0, 0);
2533 }
2534
2535 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable)
2536 {
2537         struct sip_request resp;
2538         char tmp[256];
2539         int seqno = 0;
2540         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
2541                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
2542                 return -1;
2543         }
2544         snprintf(tmp, sizeof(tmp), "Digest realm=\"asterisk\", nonce=\"%s\"", randdata);
2545         respprep(&resp, p, msg, req);
2546         add_header(&resp, "Proxy-Authenticate", tmp);
2547         add_header(&resp, "Content-Length", "0");
2548         add_blank_header(&resp);
2549         return send_response(p, &resp, reliable, seqno);
2550 }
2551
2552 static int add_text(struct sip_request *req, char *text)
2553 {
2554         /* XXX Convert \n's to \r\n's XXX */
2555         int len = strlen(text);
2556         char clen[256];
2557         snprintf(clen, sizeof(clen), "%d", len);
2558         add_header(req, "Content-Type", "text/plain");
2559         add_header(req, "Content-Length", clen);
2560         add_line(req, text);
2561         return 0;
2562 }
2563
2564 static int add_digit(struct sip_request *req, char digit)
2565 {
2566         char tmp[256];
2567         int len;
2568         char clen[256];
2569         snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
2570         len = strlen(tmp);
2571         snprintf(clen, sizeof(clen), "%d", len);
2572         add_header(req, "Content-Type", "application/dtmf-relay");
2573         add_header(req, "Content-Length", clen);
2574         add_line(req, tmp);
2575         return 0;
2576 }
2577
2578 static int add_sdp(struct sip_request *resp, struct sip_pvt *p, struct ast_rtp *rtp, struct ast_rtp *vrtp)
2579 {
2580         int len;
2581         int codec;
2582         int alreadysent = 0;
2583         char costr[80];
2584         struct sockaddr_in sin;
2585         struct sockaddr_in vsin;
2586         struct sip_codec_pref *cur;
2587         char v[256];
2588         char s[256];
2589         char o[256];
2590         char c[256];
2591         char t[256];
2592         char m[256];
2593         char m2[256];
2594         char a[1024] = "";
2595         char a2[1024] = "";
2596         int x;
2597         struct sockaddr_in dest;
2598         struct sockaddr_in vdest;
2599         /* XXX We break with the "recommendation" and send our IP, in order that our
2600                peer doesn't have to gethostbyname() us XXX */
2601         len = 0;
2602         if (!p->rtp) {
2603                 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
2604                 return -1;
2605         }
2606         if (!p->sessionid) {
2607                 p->sessionid = getpid();
2608                 p->sessionversion = p->sessionid;
2609         } else
2610                 p->sessionversion++;
2611         ast_rtp_get_us(p->rtp, &sin);
2612         if (p->vrtp)
2613                 ast_rtp_get_us(p->vrtp, &vsin);
2614
2615         if (p->redirip.sin_addr.s_addr) {
2616                 dest.sin_port = p->redirip.sin_port;
2617                 dest.sin_addr = p->redirip.sin_addr;
2618         } else if (rtp) {
2619                 ast_rtp_get_peer(rtp, &dest);
2620         } else {
2621                 dest.sin_addr = p->ourip;
2622                 dest.sin_port = sin.sin_port;
2623         }
2624
2625         /* Determine video destination */
2626         if (p->vrtp) {
2627                 if (p->vredirip.sin_addr.s_addr) {
2628                         vdest.sin_port = p->vredirip.sin_port;
2629                         vdest.sin_addr = p->vredirip.sin_addr;
2630                 } else if (vrtp) {
2631                         ast_rtp_get_peer(vrtp, &vdest);
2632                 } else {
2633                         vdest.sin_addr = p->ourip;
2634                         vdest.sin_port = vsin.sin_port;
2635                 }
2636         }
2637         if (sipdebug)
2638                 ast_verbose("We're at %s port %d\n", inet_ntoa(p->ourip), ntohs(sin.sin_port));
2639         if (sipdebug && p->vrtp)
2640                 ast_verbose("Video is at %s port %d\n", inet_ntoa(p->ourip), ntohs(vsin.sin_port));
2641         snprintf(v, sizeof(v), "v=0\r\n");
2642         snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, inet_ntoa(dest.sin_addr));
2643         snprintf(s, sizeof(s), "s=session\r\n");
2644         snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", inet_ntoa(dest.sin_addr));
2645         snprintf(t, sizeof(t), "t=0 0\r\n");
2646         snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
2647         snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
2648         /* Start by sending our preferred codecs */
2649         cur = prefs;
2650         while(cur) {
2651                 if (p->jointcapability & cur->codec) {
2652                         if (sipdebug)
2653                                 ast_verbose("Answering with preferred capability %d\n", cur->codec);
2654                         codec = ast_rtp_lookup_code(p->rtp, 1, cur->codec);
2655                         if (codec > -1) {
2656                                 snprintf(costr, sizeof(costr), " %d", codec);
2657                                 if (cur->codec < AST_FORMAT_MAX_AUDIO) {
2658                                         strncat(m, costr, sizeof(m) - strlen(m));
2659                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
2660                                         strncat(a, costr, sizeof(a));
2661                                 } else {
2662                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
2663                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
2664                                         strncat(a2, costr, sizeof(a2));
2665                                 }
2666                         }
2667                 }
2668                 alreadysent |= cur->codec;
2669                 cur = cur->next;
2670         }
2671         /* Now send any other common codecs, and non-codec formats: */
2672         for (x = 1; x <= AST_FORMAT_MAX_AUDIO; x <<= 1) {
2673                 if ((p->jointcapability & x) && !(alreadysent & x)) {
2674                         if (sipdebug)
2675                                 ast_verbose("Answering with capability %d\n", x);
2676                         codec = ast_rtp_lookup_code(p->rtp, 1, x);
2677                         if (codec > -1) {
2678                                 snprintf(costr, sizeof(costr), " %d", codec);
2679                                 if (x < AST_FORMAT_MAX_AUDIO) {
2680                                         strncat(m, costr, sizeof(m) - strlen(m));
2681                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
2682                                         strncat(a, costr, sizeof(a) - strlen(a));
2683                                 } else {
2684                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
2685                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
2686                                         strncat(a2, costr, sizeof(a2) - strlen(a2));
2687                                 }
2688                         }
2689                 }
2690         }
2691         for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
2692                 if (p->noncodeccapability & x) {
2693                         if (sipdebug)
2694                                 ast_verbose("Answering with non-codec capability %d\n", x);
2695                         codec = ast_rtp_lookup_code(p->rtp, 0, x);
2696                         if (codec > -1) {
2697                                 snprintf(costr, sizeof(costr), " %d", codec);
2698                                 strncat(m, costr, sizeof(m) - strlen(m));
2699                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
2700                                 strncat(a, costr, sizeof(a) - strlen(a));
2701                                 if (x == AST_RTP_DTMF) {
2702                                   /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
2703                                   snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n",
2704                                            codec);
2705                                   strncat(a, costr, sizeof(a) - strlen(a));
2706                                 }
2707                         }
2708                 }
2709         }
2710         if (strlen(m) < sizeof(m) - 2)
2711                 strcat(m, "\r\n");
2712         if (strlen(m2) < sizeof(m2) - 2)
2713                 strcat(m2, "\r\n");
2714         if ((sizeof(m) <= strlen(m) - 2) || (sizeof(m2) <= strlen(m2) - 2) || (sizeof(a) == strlen(a)) || (sizeof(a2) == strlen(a2)))
2715                 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
2716         len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
2717         if (p->vrtp)
2718                 len += strlen(m2) + strlen(a2);
2719         snprintf(costr, sizeof(costr), "%d", len);
2720         add_header(resp, "Content-Type", "application/sdp");
2721         add_header(resp, "Content-Length", costr);
2722         add_line(resp, v);
2723         add_line(resp, o);
2724         add_line(resp, s);
2725         add_line(resp, c);
2726         add_line(resp, t);
2727         add_line(resp, m);
2728         add_line(resp, a);
2729         if (p->vrtp) {
2730                 add_line(resp, m2);
2731                 add_line(resp, a2);
2732         }
2733         return 0;
2734 }
2735
2736 static void copy_request(struct sip_request *dst,struct sip_request *src)
2737 {
2738         long offset;
2739         int x;
2740         offset = ((void *)dst) - ((void *)src);
2741         /* First copy stuff */
2742         memcpy(dst, src, sizeof(*dst));
2743         /* Now fix pointer arithmetic */
2744         for (x=0;x<src->headers;x++)
2745                 dst->header[x] += offset;
2746         for (x=0;x<src->lines;x++)
2747                 dst->line[x] += offset;
2748 }
2749
2750 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
2751 {
2752         struct sip_request resp;
2753         int seqno;
2754         if (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1) {
2755                 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
2756                 return -1;
2757         }
2758         respprep(&resp, p, msg, req);
2759         add_sdp(&resp, p, NULL, NULL);
2760         return send_response(p, &resp, retrans, seqno);
2761 }
2762
2763 static int determine_firstline_parts( struct sip_request *req ) {
2764
2765   char *e, *cmd;
2766   int len;
2767
2768   cmd= req->header[0];
2769   while(*cmd && (*cmd < 33)) {
2770     cmd++;
2771   }
2772   if (!*cmd) {
2773     return -1;
2774   }
2775   e= cmd;
2776   while(*e && (*e > 32)) {
2777     e++;
2778   }
2779   /* Get the command */
2780   if (*e) {
2781     *e = '\0';
2782     e++;
2783   }
2784   req->rlPart1= cmd;
2785   while( *e && ( *e < 33 ) ) {
2786     e++;
2787   }
2788   if( !*e ) {
2789     return -1;
2790   }
2791
2792   if ( !strcasecmp(cmd, "SIP/2.0") ) {
2793     /* We have a response */
2794     req->rlPart2= e;
2795     len= strlen( req->rlPart2 );
2796     if( len < 2 ) { return -1; }
2797     e+= len - 1;
2798     while( *e && *e<33 ) {
2799       e--;
2800     }
2801     *(++e)= '\0';
2802   } else {
2803     /* We have a request */
2804     if( *e == '<' ) {
2805       e++;
2806       if( !*e ) { return -1; }
2807     }
2808     req->rlPart2= e;
2809     if( ( e= strrchr( req->rlPart2, 'S' ) ) == NULL ) {
2810       return -1;
2811     }
2812     while( isspace( *(--e) ) ) {}
2813     if( *e == '>' ) {
2814       *e= '\0';
2815     } else {
2816       *(++e)= '\0';
2817     }
2818   }
2819   return 1;
2820 }
2821
2822 static int transmit_reinvite_with_sdp(struct sip_pvt *p, struct ast_rtp *rtp, struct ast_rtp *vrtp)
2823 {
2824         struct sip_request req;
2825         if (p->canreinvite == REINVITE_UPDATE)
2826                 reqprep(&req, p, "UPDATE", 0);
2827         else {
2828                 p->branch++;
2829                 snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
2830                 reqprep(&req, p, "INVITE", 0);
2831         }
2832         add_header(&req, "Allow", ALLOWED_METHODS);
2833         add_sdp(&req, p, rtp, vrtp);
2834         /* Use this as the basis */
2835         copy_request(&p->initreq, &req);
2836         parse(&p->initreq);
2837         determine_firstline_parts(&p->initreq);
2838         p->lastinvite = p->ocseq;
2839         p->outgoing = 1;
2840         return send_request(p, &req, 1, p->ocseq);
2841 }
2842
2843 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
2844 {
2845         char stripped[256]="";
2846         char *c, *n;
2847         strncpy(stripped, get_header(req, "Contact"), sizeof(stripped) - 1);
2848         c = strchr(stripped, '<');
2849         if (c)
2850                 c++;
2851         else
2852                 c = stripped;
2853         n = strchr(c, '>');
2854         if (n)
2855                 *n = '\0';
2856         n = strchr(c, ';');
2857         if (n)
2858                 *n = '\0';
2859         if (c && strlen(c))
2860                 strncpy(p->uri, c, sizeof(p->uri) - 1);
2861 }
2862
2863 static void build_contact(struct sip_pvt *p)
2864 {
2865         /* Construct Contact: header */
2866         if (ourport != 5060)
2867                 snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s@%s:%d>", p->exten, inet_ntoa(p->ourip), ourport);
2868         else
2869                 snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s@%s>", p->exten, inet_ntoa(p->ourip));
2870 }
2871
2872 static void initreqprep(struct sip_request *req, struct sip_pvt *p, char *cmd, char *vxml_url)
2873 {
2874         char invite[256];
2875         char from[256];
2876         char to[256];
2877         char tmp[80];
2878         char cid[256];
2879         char *l = callerid, *n=NULL;
2880
2881         snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", cmd);
2882
2883         if (p->owner && p->owner->callerid) {
2884                 strcpy(cid, p->owner->callerid);
2885                 ast_callerid_parse(cid, &n, &l);
2886                 if (l)
2887                         ast_shrink_phone_number(l);
2888                 if (!l || !ast_isphonenumber(l))
2889                                 l = callerid;
2890         }
2891         /* if user want's his callerid restricted */
2892         if (p->restrictcid)
2893                 l = CALLERID_UNKNOWN;
2894         if (!n || !strlen(n))
2895                 n = l;
2896         /* Allow user to be overridden */
2897         if (strlen(p->fromuser))
2898                 l = p->fromuser;
2899
2900         if ((ourport != 5060) && !strlen(p->fromdomain))
2901                 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s:%d>;tag=as%08x", n, l, strlen(p->fromdomain) ? p->fromdomain : inet_ntoa(p->ourip), ourport, p->tag);
2902         else
2903                 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s>;tag=as%08x", n, l, strlen(p->fromdomain) ? p->fromdomain : inet_ntoa(p->ourip), p->tag);
2904
2905         if (strlen(p->username)) {
2906                 if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) {
2907                         snprintf(invite, sizeof(invite), "sip:%s@%s:%d",p->username, p->tohost, ntohs(p->sa.sin_port));
2908                 } else {
2909                         snprintf(invite, sizeof(invite), "sip:%s@%s",p->username, p->tohost);
2910                 }
2911         } else if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) {
2912                 snprintf(invite, sizeof(invite), "sip:%s:%d", p->tohost, ntohs(p->sa.sin_port));
2913         } else {
2914                 snprintf(invite, sizeof(invite), "sip:%s", p->tohost);
2915         }
2916         strncpy(p->uri, invite, sizeof(p->uri) - 1);
2917         /* If there is a VXML URL append it to the SIP URL */
2918         if (vxml_url)
2919         {
2920                 snprintf(to, sizeof(to), "<%s>;%s", invite, vxml_url);
2921         }
2922         else
2923         {
2924                 snprintf(to, sizeof(to), "<%s>", invite );
2925         }
2926         memset(req, 0, sizeof(struct sip_request));
2927         init_req(req, cmd, invite);
2928         snprintf(tmp, sizeof(tmp), "%d %s", ++p->ocseq, cmd);
2929
2930         add_header(req, "Via", p->via);
2931         /* SLD: FIXME?: do Route: here too?  I think not cos this is the first request.
2932          * OTOH, then we won't have anything in p->route anyway */
2933         add_header(req, "From", from);
2934         strncpy(p->exten, l, sizeof(p->exten) - 1);
2935         build_contact(p);
2936         add_header(req, "To", to);
2937         add_header(req, "Contact", p->our_contact);
2938         add_header(req, "Call-ID", p->callid);
2939         add_header(req, "CSeq", tmp);
2940         add_header(req, "User-Agent", "Asterisk PBX");
2941 }
2942
2943 static int transmit_invite(struct sip_pvt *p, char *cmd, int sdp, char *auth, char *authheader, char *vxml_url, char *distinctive_ring, int init)
2944 {
2945         struct sip_request req;
2946
2947         if (init)
2948                 initreqprep(&req, p, cmd, vxml_url);
2949         else
2950                 reqprep(&req, p, cmd, 0);
2951
2952         if (auth)
2953                 add_header(&req, authheader, auth);
2954         append_date(&req);
2955         if (!strcasecmp(cmd, "REFER")) {
2956                 if (strlen(p->refer_to))
2957                         add_header(&req, "Refer-To", p->refer_to);
2958                 if (strlen(p->referred_by))
2959                         add_header(&req, "Referred-By", p->referred_by);
2960         }
2961
2962         if (distinctive_ring)
2963         {
2964                 add_header(&req, "Alert-info",distinctive_ring);
2965         }
2966         add_header(&req, "Allow", ALLOWED_METHODS);
2967         if (sdp) {
2968                 add_sdp(&req, p, NULL, NULL);
2969         } else {
2970                 add_header(&req, "Content-Length", "0");
2971                 add_blank_header(&req);
2972         }
2973
2974         if (!p->initreq.headers) {
2975                 /* Use this as the basis */
2976                 copy_request(&p->initreq, &req);
2977                 parse(&p->initreq);
2978                 determine_firstline_parts(&p->initreq);
2979         }
2980         p->lastinvite = p->ocseq;
2981         return send_request(p, &req, 1, p->ocseq);
2982 }
2983
2984 static int transmit_state_notify(struct sip_pvt *p, int state, int full)
2985 {
2986         char tmp[2000];
2987         char from[256], to[256];
2988         char *t, *c, *a;
2989         char *mfrom, *mto;
2990         struct sip_request req;
2991         char clen[20];
2992
2993         strncpy(from, get_header(&p->initreq, "From"), sizeof(from)-1);
2994
2995         c = ditch_braces(from);
2996         if (strncmp(c, "sip:", 4)) {
2997                 ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
2998                 return -1;
2999         }
3000         if ((a = strchr(c, ';'))) {
3001                 *a = '\0';
3002         }
3003         mfrom = c;
3004
3005         reqprep(&req, p, "NOTIFY", 0);
3006
3007         if (p->subscribed == 1) {
3008             strncpy(to, get_header(&p->initreq, "To"), sizeof(to)-1);
3009
3010             c = ditch_braces(to);
3011             if (strncmp(c, "sip:", 4)) {
3012                 ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
3013                 return -1;
3014             }
3015             if ((a = strchr(c, ';'))) {
3016                 *a = '\0';
3017             }
3018             mto = c;
3019
3020             add_header(&req, "Content-Type", "application/xpidf+xml");
3021
3022             if ((state==AST_EXTENSION_UNAVAILABLE) || (state==AST_EXTENSION_BUSY))
3023                 state = 2;
3024             else if (state==AST_EXTENSION_INUSE)
3025                 state = 1;
3026             else
3027                 state = 0;
3028
3029             t = tmp;
3030             sprintf(t, "<?xml version=\"1.0\"?>\n");
3031             t = tmp + strlen(tmp);
3032             sprintf(t, "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n");
3033             t = tmp + strlen(tmp);
3034             sprintf(t, "<presence>\n");
3035             t = tmp + strlen(tmp);
3036             sprintf(t, "<presentity uri=\"%s;method=SUBSCRIBE\" />\n", mfrom);
3037             t = tmp + strlen(tmp);
3038             sprintf(t, "<atom id=\"%s\">\n", p->exten);
3039             t = tmp + strlen(tmp);
3040             sprintf(t, "<address uri=\"%s;user=ip\" priority=\"0,800000\">\n", mto);
3041             t = tmp + strlen(tmp);
3042             sprintf(t, "<status status=\"%s\" />\n", !state ? "open" : (state==1) ? "inuse" : "closed");
3043             t = tmp + strlen(tmp);
3044             sprintf(t, "<msnsubstatus substatus=\"%s\" />\n", !state ? "online" : (state==1) ? "onthephone" : "offline");
3045             t = tmp + strlen(tmp);
3046             sprintf(t, "</address>\n</atom>\n</presence>\n");
3047         } else {
3048             add_header(&req, "Event", "dialog");
3049             add_header(&req, "Content-Type", "application/dialog-info+xml");
3050
3051             t = tmp;
3052             sprintf(t, "<?xml version=\"1.0\"?>\n");
3053             t = tmp + strlen(tmp);
3054             sprintf(t, "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" version=\"%d\" state=\"%s\" entity=\"%s\">\n", p->dialogver++, full ? "full":"partial", mfrom);
3055             t = tmp + strlen(tmp);
3056             sprintf(t, "<dialog id=\"%s\">\n", p->exten);
3057             t = tmp + strlen(tmp);
3058             sprintf(t, "<state>%s</state>\n", state ? "confirmed" : "terminated");
3059             t = tmp + strlen(tmp);
3060             sprintf(t, "</dialog>\n</dialog-info>\n");
3061         }
3062         if (t > tmp + sizeof(tmp))
3063                 ast_log(LOG_WARNING, "Buffer overflow detected!!  (Please file a bug report)\n");
3064
3065         snprintf(clen, sizeof(clen), "%d", strlen(tmp));
3066         add_header(&req, "Content-Length", clen);
3067         add_line(&req, tmp);
3068
3069         return send_request(p, &req, 1, p->ocseq);
3070 }