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