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         ast_mutex_lock(&usecnt_lock);
1036         usecnt--;
1037         ast_mutex_unlock(&usecnt_lock);
1038         ast_update_use_count();
1039
1040         needdestroy = 1;
1041         /* Start the process if it's not already started */
1042         if (!p->alreadygone && strlen(p->initreq.data)) {
1043                 if (needcancel) {
1044                         if (p->outgoing) {
1045                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1);
1046                                 /* Actually don't destroy us yet, wait for the 487 on our original
1047                                    INVITE, but do set an autodestruct just in case. */
1048                                 needdestroy = 0;
1049                                 sip_scheddestroy(p, 15000);
1050                         } else
1051                                 transmit_response_reliable(p, "403 Forbidden", &p->initreq);
1052                 } else {
1053                         if (!p->pendinginvite) {
1054                                 /* Send a hangup */
1055                                 transmit_request_with_auth(p, "BYE", 0, 1);
1056                         } else {
1057                                 /* Note we will need a BYE when this all settles out
1058                                    but we can't send one while we have "INVITE" outstanding. */
1059                                 p->pendingbye = 1;
1060                         }
1061                 }
1062         }
1063         p->needdestroy = needdestroy;
1064         ast_mutex_unlock(&p->lock);
1065         return 0;
1066 }
1067
1068 static int sip_answer(struct ast_channel *ast)
1069 {
1070         int res = 0,fmt;
1071         char *codec;
1072         struct sip_pvt *p = ast->pvt->pvt;
1073
1074
1075         if (ast->_state != AST_STATE_UP) {
1076
1077
1078
1079                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1080                 if (codec) {
1081                         ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1082                         fmt=ast_getformatbyname(codec);
1083                         if (fmt) {
1084                                 p->capability=fmt;
1085                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized codec: %s\n",codec);
1086                 }
1087
1088                 ast_setstate(ast, AST_STATE_UP);
1089                 if (option_debug)
1090                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1091                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1092         }
1093         return res;
1094 }
1095
1096 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1097 {
1098         struct sip_pvt *p = ast->pvt->pvt;
1099         int res = 0;
1100         if (frame->frametype == AST_FRAME_VOICE) {
1101                 if (!(frame->subclass & ast->nativeformats)) {
1102                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1103                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1104                         return -1;
1105                 }
1106                 if (p) {
1107                         ast_mutex_lock(&p->lock);
1108                         if (p->rtp) {
1109                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1110                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1111                                         p->progress = 1;
1112                                 }
1113                                 res =  ast_rtp_write(p->rtp, frame);
1114                         }
1115                         ast_mutex_unlock(&p->lock);
1116                 }
1117         } else if (frame->frametype == AST_FRAME_VIDEO) {
1118                 if (p) {
1119                         ast_mutex_lock(&p->lock);
1120                         if (p->vrtp) {
1121                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1122                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1123                                         p->progress = 1;
1124                                 }
1125                                 res =  ast_rtp_write(p->vrtp, frame);
1126                         }
1127                         ast_mutex_unlock(&p->lock);
1128                 }
1129         } else if (frame->frametype == AST_FRAME_IMAGE) {
1130                 return 0;
1131         } else {
1132                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1133                 return 0;
1134         }
1135
1136         return res;
1137 }
1138
1139 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1140 {
1141         struct sip_pvt *p = newchan->pvt->pvt;
1142         ast_mutex_lock(&p->lock);
1143         if (p->owner != oldchan) {
1144                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1145                 ast_mutex_unlock(&p->lock);
1146                 return -1;
1147         }
1148         p->owner = newchan;
1149         ast_mutex_unlock(&p->lock);
1150         return 0;
1151 }
1152
1153 static int sip_senddigit(struct ast_channel *ast, char digit)
1154 {
1155         struct sip_pvt *p = ast->pvt->pvt;
1156         if (p && (p->dtmfmode & SIP_DTMF_INFO)) {
1157                 transmit_info_with_digit(p, digit);
1158         }
1159         if (p && p->rtp && (p->dtmfmode & SIP_DTMF_RFC2833)) {
1160                 ast_rtp_senddigit(p->rtp, digit);
1161         }
1162         /* If in-band DTMF is desired, send that */
1163         if (p->dtmfmode & SIP_DTMF_INBAND)
1164                 return -1;
1165         return 0;
1166 }
1167
1168 static int sip_transfer(struct ast_channel *ast, char *dest)
1169 {
1170         struct sip_pvt *p = ast->pvt->pvt;
1171         int res;
1172         res = transmit_refer(p, dest);
1173         return res;
1174 }
1175
1176 static int sip_indicate(struct ast_channel *ast, int condition)
1177 {
1178         struct sip_pvt *p = ast->pvt->pvt;
1179         switch(condition) {
1180         case AST_CONTROL_RINGING:
1181                 if (ast->_state == AST_STATE_RING) {
1182                         if (!p->progress && !p->ringing) {
1183                                 transmit_response(p, "180 Ringing", &p->initreq);
1184                                 p->ringing = 1;
1185                                 break;
1186                         } else {
1187                                 /* Oops, we've sent progress tones.  Let Asterisk do it instead */
1188                         }
1189                 }
1190                 return -1;
1191         case AST_CONTROL_BUSY:
1192                 if (ast->_state != AST_STATE_UP) {
1193                         transmit_response(p, "486 Busy Here", &p->initreq);
1194                         p->alreadygone = 1;
1195                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1196                         break;
1197                 }
1198                 return -1;
1199         case AST_CONTROL_CONGESTION:
1200                 if (ast->_state != AST_STATE_UP) {
1201                         transmit_response(p, "503 Service Unavailable", &p->initreq);
1202                         p->alreadygone = 1;
1203                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1204                         break;
1205                 }
1206                 return -1;
1207         case AST_CONTROL_PROGRESS:
1208                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1209                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1210                         p->progress = 1;
1211                         break;
1212                 }
1213                 return -1;
1214         case -1:
1215                 return -1;
1216         default:
1217                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1218                 return -1;
1219         }
1220         return 0;
1221 }
1222
1223
1224
1225 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1226 {
1227         struct ast_channel *tmp;
1228         int fmt;
1229         tmp = ast_channel_alloc(1);
1230         if (tmp) {
1231                 /* Select our native format based on codec preference until we receive
1232                    something from another device to the contrary. */
1233                 if (i->jointcapability)
1234                         tmp->nativeformats = sip_codec_choose(i->jointcapability);
1235                 else if (i->capability)
1236                         tmp->nativeformats = sip_codec_choose(i->capability);
1237                 else
1238                         tmp->nativeformats = sip_codec_choose(capability);
1239                 fmt = ast_best_codec(tmp->nativeformats);
1240                 if (title)
1241                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
1242                 else
1243                         if (strchr(i->fromdomain,':'))
1244                         {
1245                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(i));
1246                         }
1247                         else
1248                         {
1249                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(i));
1250                         }
1251                 tmp->type = type;
1252                 if (i->dtmfmode & SIP_DTMF_INBAND) {
1253                     i->vad = ast_dsp_new();
1254                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
1255                 }
1256                 tmp->fds[0] = ast_rtp_fd(i->rtp);
1257                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
1258                 if (i->vrtp) {
1259                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
1260                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
1261                 }
1262                 ast_setstate(tmp, state);
1263                 if (state == AST_STATE_RING)
1264                         tmp->rings = 1;
1265                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1266                 tmp->writeformat = fmt;
1267                 tmp->pvt->rawwriteformat = fmt;
1268                 tmp->readformat = fmt;
1269                 tmp->pvt->rawreadformat = fmt;
1270                 tmp->pvt->pvt = i;
1271                 tmp->pvt->send_text = sip_sendtext;
1272                 tmp->pvt->call = sip_call;
1273                 tmp->pvt->hangup = sip_hangup;
1274                 tmp->pvt->answer = sip_answer;
1275                 tmp->pvt->read = sip_read;
1276                 tmp->pvt->write = sip_write;
1277                 tmp->pvt->write_video = sip_write;
1278                 tmp->pvt->indicate = sip_indicate;
1279                 tmp->pvt->transfer = sip_transfer;
1280                 tmp->pvt->fixup = sip_fixup;
1281                 tmp->pvt->send_digit = sip_senddigit;
1282
1283                 tmp->pvt->bridge = ast_rtp_bridge;
1284
1285                 tmp->callgroup = i->callgroup;
1286                 tmp->pickupgroup = i->pickupgroup;
1287                 tmp->restrictcid = i->restrictcid;
1288                 if (strlen(i->accountcode))
1289                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
1290                 if (i->amaflags)
1291                         tmp->amaflags = i->amaflags;
1292                 if (strlen(i->language))
1293                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
1294                 i->owner = tmp;
1295                 ast_mutex_lock(&usecnt_lock);
1296                 usecnt++;
1297                 ast_mutex_unlock(&usecnt_lock);
1298                 ast_update_use_count();
1299                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
1300                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
1301                 if (strlen(i->callerid))
1302                         tmp->callerid = strdup(i->callerid);
1303                 if (strlen(i->rdnis))
1304                         tmp->rdnis = strdup(i->rdnis);
1305                 tmp->priority = 1;
1306                 if (state != AST_STATE_DOWN) {
1307                         if (ast_pbx_start(tmp)) {
1308                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1309                                 ast_hangup(tmp);
1310                                 tmp = NULL;
1311                         }
1312                 }
1313         } else
1314                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1315         return tmp;
1316 }
1317
1318 static struct cfalias {
1319         char *fullname;
1320         char *shortname;
1321 } aliases[] = {
1322         { "Content-Type", "c" },
1323         { "Content-Encoding", "e" },
1324         { "From", "f" },
1325         { "Call-ID", "i" },
1326         { "Contact", "m" },
1327         { "Content-Length", "l" },
1328         { "Subject", "s" },
1329         { "To", "t" },
1330         { "Via", "v" },
1331 };
1332
1333 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
1334   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
1335     char* r = line + nameLen + 1;
1336     while (*r && (*r < 33)) ++r;
1337     return r;
1338   }
1339
1340   return "";
1341 }
1342
1343 static char *get_sdp(struct sip_request *req, char *name) {
1344   int x;
1345   int len = strlen(name);
1346   char *r;
1347
1348   for (x=0; x<req->lines; x++) {
1349     r = get_sdp_by_line(req->line[x], name, len);
1350     if (r[0] != '\0') return r;
1351   }
1352   return "";
1353 }
1354
1355 static void sdpLineNum_iterator_init(int* iterator) {
1356   *iterator = 0;
1357 }
1358
1359 static char* get_sdp_iterate(int* iterator,
1360                              struct sip_request *req, char *name) {
1361   int len = strlen(name);
1362   char *r;
1363   while (*iterator < req->lines) {
1364     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
1365     if (r[0] != '\0') return r;
1366   }
1367   return "";
1368 }
1369
1370 static char *__get_header(struct sip_request *req, char *name, int *start)
1371 {
1372         int x;
1373         int len = strlen(name);
1374         char *r;
1375         for (x=*start;x<req->headers;x++) {
1376                 if (!strncasecmp(req->header[x], name, len) &&
1377                                 (req->header[x][len] == ':')) {
1378                                         r = req->header[x] + len + 1;
1379                                         while(*r && (*r < 33))
1380                                                         r++;
1381                                         *start = x+1;
1382                                         return r;
1383                 }
1384         }
1385         /* Try aliases */
1386         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
1387                 if (!strcasecmp(aliases[x].fullname, name))
1388                         return __get_header(req, aliases[x].shortname, start);
1389
1390         /* Don't return NULL, so get_header is always a valid pointer */
1391         return "";
1392 }
1393
1394 static char *get_header(struct sip_request *req, char *name)
1395 {
1396         int start = 0;
1397         return __get_header(req, name, &start);
1398 }
1399
1400 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
1401 {
1402         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
1403         struct ast_frame *f;
1404         static struct ast_frame null_frame = { AST_FRAME_NULL, };
1405         switch(ast->fdno) {
1406         case 0:
1407                 f = ast_rtp_read(p->rtp);
1408                 break;
1409         case 1:
1410                 f = ast_rtcp_read(p->rtp);
1411                 break;
1412         case 2:
1413                 f = ast_rtp_read(p->vrtp);
1414                 break;
1415         case 3:
1416                 f = ast_rtcp_read(p->vrtp);
1417                 break;
1418         default:
1419                 f = &null_frame;
1420         }
1421         /* Don't send RFC2833 if we're not supposed to */
1422         if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & SIP_DTMF_RFC2833))
1423                 return &null_frame;
1424         if (p->owner) {
1425                 /* We already hold the channel lock */
1426                 if (f->frametype == AST_FRAME_VOICE) {
1427                         if (f->subclass != p->owner->nativeformats) {
1428                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
1429                                 p->owner->nativeformats = f->subclass;
1430                                 ast_set_read_format(p->owner, p->owner->readformat);
1431                                 ast_set_write_format(p->owner, p->owner->writeformat);
1432                         }
1433             if (p->dtmfmode & SIP_DTMF_INBAND) {
1434                    f = ast_dsp_process(p->owner,p->vad,f,0);
1435             }
1436                 }
1437         }
1438         return f;
1439 }
1440
1441 static struct ast_frame *sip_read(struct ast_channel *ast)
1442 {
1443         struct ast_frame *fr;
1444         struct sip_pvt *p = ast->pvt->pvt;
1445         ast_mutex_lock(&p->lock);
1446         fr = sip_rtp_read(ast, p);
1447         ast_mutex_unlock(&p->lock);
1448         return fr;
1449 }
1450
1451 static void build_callid(char *callid, int len, struct in_addr ourip)
1452 {
1453         int res;
1454         int val;
1455         int x;
1456         for (x=0;x<4;x++) {
1457                 val = rand();
1458                 res = snprintf(callid, len, "%08x", val);
1459                 len -= res;
1460                 callid += res;
1461         }
1462         /* It's not important that we really use our right IP here... */
1463         snprintf(callid, len, "@%s", inet_ntoa(ourip));
1464 }
1465
1466 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobalnat)
1467 {
1468         struct sip_pvt *p;
1469
1470         p = malloc(sizeof(struct sip_pvt));
1471         if (!p)
1472                 return NULL;
1473         /* Keep track of stuff */
1474         memset(p, 0, sizeof(struct sip_pvt));
1475         p->initid = -1;
1476         p->autokillid = -1;
1477         p->stateid = -1;
1478         p->rtp = ast_rtp_new(sched, io, 1, 0);
1479         if (videosupport)
1480                 p->vrtp = ast_rtp_new(sched, io, 1, 0);
1481         p->branch = rand();
1482         p->tag = rand();
1483
1484         /* Start with 101 instead of 1 */
1485         p->ocseq = 101;
1486         if (!p->rtp) {
1487                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
1488                 free(p);
1489                 return NULL;
1490         }
1491         ast_rtp_settos(p->rtp, tos);
1492         if (p->vrtp)
1493                 ast_rtp_settos(p->vrtp, tos);
1494         if (useglobalnat && sin) {
1495                 /* Setup NAT structure according to global settings if we have an address */
1496                 p->nat = globalnat;
1497                 memcpy(&p->recv, sin, sizeof(p->recv));
1498                 ast_rtp_setnat(p->rtp, p->nat);
1499                 if (p->vrtp)
1500                         ast_rtp_setnat(p->vrtp, p->nat);
1501         }
1502         ast_mutex_init(&p->lock);
1503
1504         if (sin) {
1505                 memcpy(&p->sa, sin, sizeof(p->sa));
1506                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
1507                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
1508         } else {
1509                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
1510         }
1511         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1512         snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
1513         if (!callid)
1514                 build_callid(p->callid, sizeof(p->callid), p->ourip);
1515         else
1516                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
1517         /* Assume reinvite OK and via INVITE */
1518         p->canreinvite = globalcanreinvite;
1519         p->dtmfmode = globaldtmfmode;
1520         p->capability = capability;
1521         if (p->dtmfmode & SIP_DTMF_RFC2833)
1522                 p->noncodeccapability |= AST_RTP_DTMF;
1523         strncpy(p->context, context, sizeof(p->context) - 1);
1524         strncpy(p->fromdomain, fromdomain, sizeof(p->fromdomain) - 1);
1525         /* Add to list */
1526         ast_mutex_lock(&iflock);
1527         p->next = iflist;
1528         iflist = p;
1529         ast_mutex_unlock(&iflock);
1530         if (option_debug)
1531                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
1532         return p;
1533 }
1534
1535 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
1536 {
1537         struct sip_pvt *p;
1538         char *callid;
1539         char tmp[256] = "";
1540         char *cmd;
1541         char *tag = "", *c;
1542         int themisfrom;
1543         callid = get_header(req, "Call-ID");
1544
1545         if (pedanticsipchecking) {
1546                 /* In principle Call-ID's uniquely identify a call, however some vendors
1547                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
1548                    tags in order to simplify billing.  The RFC does state that we have to
1549                    compare tags in addition to the call-id, but this generate substantially
1550                    more overhead which is totally unnecessary for the vast majority of sane
1551                    SIP implementations, and thus Asterisk does not enable this behavior
1552                    by default. Short version: You'll need this option to support conferencing
1553                    on the pingtel */
1554                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
1555                 cmd = tmp;
1556                 c = strchr(tmp, ' ');
1557                 if (c)
1558                         *c = '\0';
1559                 if (!strcasecmp(cmd, "SIP/2.0")) {
1560                         themisfrom = 0;
1561                 } else {
1562                         themisfrom = 1;
1563                 }
1564                 if (themisfrom)
1565                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
1566                 else
1567                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
1568                 tag = strstr(tmp, "tag=");
1569                 if (tag) {
1570                         tag += 4;
1571                         c = strchr(tag, ';');
1572                         if (c)
1573                                 *c = '\0';
1574                 }
1575
1576         }
1577
1578         if (!strlen(callid)) {
1579                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", inet_ntoa(sin->sin_addr));
1580                 return NULL;
1581         }
1582         ast_mutex_lock(&iflock);
1583         p = iflist;
1584         while(p) {
1585                 if (!strcmp(p->callid, callid) &&
1586                         (!pedanticsipchecking || !strlen(p->theirtag) || !strcmp(p->theirtag, tag))) {
1587                         /* Found the call */
1588                         ast_mutex_lock(&p->lock);
1589                         ast_mutex_unlock(&iflock);
1590                         return p;
1591                 }
1592                 p = p->next;
1593         }
1594         ast_mutex_unlock(&iflock);
1595         p = sip_alloc(callid, sin, 1);
1596         if (p)
1597                 ast_mutex_lock(&p->lock);
1598         return p;
1599 }
1600
1601 static int sip_register(char *value, int lineno)
1602 {
1603         struct sip_registry *reg;
1604         char copy[256] = "";
1605         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
1606         char *porta=NULL;
1607         char *contact=NULL;
1608         char *stringp=NULL;
1609
1610         struct hostent *hp;
1611         if (!value)
1612                 return -1;
1613         strncpy(copy, value, sizeof(copy)-1);
1614         stringp=copy;
1615         username = stringp;
1616         hostname = strrchr(stringp, '@');
1617         if (hostname) {
1618                 *hostname = '\0';
1619                 hostname++;
1620         }
1621         if (!username || !strlen(username) || !hostname || !strlen(hostname)) {
1622                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
1623                 return -1;
1624         }
1625         stringp=username;
1626         username = strsep(&stringp, ":");
1627         if (username) {
1628                 secret = strsep(&stringp, ":");
1629                 if (secret)
1630                         authuser = strsep(&stringp, ":");
1631         }
1632         stringp = hostname;
1633         hostname = strsep(&stringp, "/");
1634         if (hostname)
1635                 contact = strsep(&stringp, "/");
1636         if (!contact || !strlen(contact))
1637                 contact = "s";
1638         stringp=hostname;
1639         hostname = strsep(&stringp, ":");
1640         porta = strsep(&stringp, ":");
1641
1642         if (porta && !atoi(porta)) {
1643                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
1644                 return -1;
1645         }
1646         hp = gethostbyname(hostname);
1647         if (!hp) {
1648                 ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
1649                 return -1;
1650         }
1651         reg = malloc(sizeof(struct sip_registry));
1652         if (reg) {
1653                 memset(reg, 0, sizeof(struct sip_registry));
1654                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
1655                 if (username)
1656                         strncpy(reg->username, username, sizeof(reg->username)-1);
1657                 if (hostname)
1658                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
1659                 if (authuser)
1660                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
1661                 if (secret)
1662                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
1663                 reg->expire = -1;
1664                 reg->timeout =  -1;
1665                 reg->refresh = default_expiry;
1666                 reg->addr.sin_family = AF_INET;
1667                 memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
1668                 reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(DEFAULT_SIP_PORT);
1669                 reg->next = registrations;
1670                 reg->callid_valid = 0;
1671                 reg->ocseq = 101;
1672                 registrations = reg;
1673         } else {
1674                 ast_log(LOG_ERROR, "Out of memory\n");
1675                 return -1;
1676         }
1677         return 0;
1678 }
1679
1680 static void parse(struct sip_request *req)
1681 {
1682         /* Divide fields by NULL's */
1683         char *c;
1684         int f = 0;
1685         c = req->data;
1686
1687         /* First header starts immediately */
1688         req->header[f] = c;
1689         while(*c) {
1690                 if (*c == '\n') {
1691                         /* We've got a new header */
1692                         *c = 0;
1693
1694 #if 0
1695                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
1696 #endif
1697                         if (!strlen(req->header[f])) {
1698                                 /* Line by itself means we're now in content */
1699                                 c++;
1700                                 break;
1701                         }
1702                         if (f >= SIP_MAX_HEADERS - 1) {
1703                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
1704                         } else
1705                                 f++;
1706                         req->header[f] = c + 1;
1707                 } else if (*c == '\r') {
1708                         /* Ignore but eliminate \r's */
1709                         *c = 0;
1710                 }
1711                 c++;
1712         }
1713         /* Check for last header */
1714         if (strlen(req->header[f]))
1715                 f++;
1716         req->headers = f;
1717         /* Now we process any mime content */
1718         f = 0;
1719         req->line[f] = c;
1720         while(*c) {
1721                 if (*c == '\n') {
1722                         /* We've got a new line */
1723                         *c = 0;
1724 #if 0
1725                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
1726 #endif
1727                         if (f >= SIP_MAX_LINES - 1) {
1728                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
1729                         } else
1730                                 f++;
1731                         req->line[f] = c + 1;
1732                 } else if (*c == '\r') {
1733                         /* Ignore and eliminate \r's */
1734                         *c = 0;
1735                 }
1736                 c++;
1737         }
1738         /* Check for last line */
1739         if (strlen(req->line[f]))
1740                 f++;
1741         req->lines = f;
1742         if (sipdebug)
1743                 ast_verbose("%d headers, %d lines\n", req->headers, req->lines);
1744         if (*c)
1745                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
1746 }
1747
1748 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
1749 {
1750         char *m;
1751         char *c;
1752         char *a;
1753         char host[258];
1754         int len = -1;
1755         int portno=0;
1756         int vportno=0;
1757         int peercapability, peernoncodeccapability;
1758         int vpeercapability=0, vpeernoncodeccapability=0;
1759         struct sockaddr_in sin;
1760         char *codecs;
1761         struct hostent *hp;
1762         int codec;
1763         int iterator;
1764         int x;
1765
1766         /* Get codec and RTP info from SDP */
1767         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
1768                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
1769                 return -1;
1770         }
1771         m = get_sdp(req, "m");
1772         c = get_sdp(req, "c");
1773         if (!strlen(m) || !strlen(c)) {
1774                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
1775                 return -1;
1776         }
1777         if (sscanf(c, "IN IP4 %256s", host) != 1) {
1778                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
1779                 return -1;
1780         }
1781         /* XXX This could block for a long time, and block the main thread! XXX */
1782         hp = gethostbyname(host);
1783         if (!hp) {
1784                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
1785                 return -1;
1786         }
1787         sdpLineNum_iterator_init(&iterator);
1788         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
1789                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
1790                         portno = x;
1791                         // Scan through the RTP payload types specified in a "m=" line:
1792                         ast_rtp_pt_clear(p->rtp);
1793                         codecs = m + len;
1794                         while(strlen(codecs)) {
1795                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
1796                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
1797                                         return -1;
1798                                 }
1799                                 if (sipdebug)
1800                                         ast_verbose("Found audio format %s\n", ast_getformatname(codec));
1801                                 ast_rtp_set_m_type(p->rtp, codec);
1802                                 codecs += len;
1803                                 /* Skip over any whitespace */
1804                                 while(*codecs && (*codecs < 33)) codecs++;
1805                         }
1806                 }
1807                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
1808                         vportno = x;
1809                         // Scan through the RTP payload types specified in a "m=" line:
1810                         ast_rtp_pt_clear(p->vrtp);
1811                         codecs = m + len;
1812                         while(strlen(codecs)) {
1813                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
1814                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
1815                                         return -1;
1816                                 }
1817                                 if (sipdebug)
1818                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
1819                                 ast_rtp_set_m_type(p->vrtp, codec);
1820                                 codecs += len;
1821                                 /* Skip over any whitespace */
1822                                 while(*codecs && (*codecs < 33)) codecs++;
1823                         }
1824                 }
1825         }
1826         sin.sin_family = AF_INET;
1827         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
1828         /* Setup audio port number */
1829         sin.sin_port = htons(portno);
1830         if (p->rtp && sin.sin_port)
1831                 ast_rtp_set_peer(p->rtp, &sin);
1832         /* Setup video port number */
1833         sin.sin_port = htons(vportno);
1834         if (p->vrtp && sin.sin_port)
1835                 ast_rtp_set_peer(p->vrtp, &sin);
1836 #if 0
1837         printf("Peer RTP is at port %s:%d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
1838 #endif
1839         // Next, scan through each "a=rtpmap:" line, noting each
1840         // specified RTP payload type (with corresponding MIME subtype):
1841         sdpLineNum_iterator_init(&iterator);
1842         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
1843       char* mimeSubtype = ast_strdupa(a); // ensures we have enough space
1844           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
1845           if (sipdebug)
1846                 ast_verbose("Found description format %s\n", mimeSubtype);
1847           // Note: should really look at the 'freq' and '#chans' params too
1848           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
1849           if (p->vrtp)
1850                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
1851         }
1852
1853         // Now gather all of the codecs that were asked for:
1854         ast_rtp_get_current_formats(p->rtp,
1855                                 &peercapability, &peernoncodeccapability);
1856         if (p->vrtp)
1857                 ast_rtp_get_current_formats(p->vrtp,
1858                                 &vpeercapability, &vpeernoncodeccapability);
1859         p->jointcapability = p->capability & (peercapability | vpeercapability);
1860         p->noncodeccapability = noncodeccapability & (peernoncodeccapability | vpeernoncodeccapability);
1861
1862         if (sipdebug) {
1863                 ast_verbose("Capabilities: us - %d, them - %d/%d, combined - %d\n",
1864                             p->capability, peercapability, vpeercapability, p->jointcapability);
1865                 ast_verbose("Non-codec capabilities: us - %d, them - %d, combined - %d\n",
1866                             noncodeccapability, peernoncodeccapability,
1867                             p->noncodeccapability);
1868         }
1869         if (!p->jointcapability) {
1870                 ast_log(LOG_WARNING, "No compatible codecs!\n");
1871                 return -1;
1872         }
1873         if (p->owner) {
1874                 if (!(p->owner->nativeformats & p->jointcapability)) {
1875                         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);
1876                         p->owner->nativeformats = sip_codec_choose(p->jointcapability);
1877                         ast_set_read_format(p->owner, p->owner->readformat);
1878                         ast_set_write_format(p->owner, p->owner->writeformat);
1879                 }
1880                 if (p->owner->bridge) {
1881                         /* Turn on/off music on hold if we are holding/unholding */
1882                         if (sin.sin_addr.s_addr) {
1883                                 ast_moh_stop(p->owner->bridge);
1884                         } else {
1885                                 ast_moh_start(p->owner->bridge, NULL);
1886                         }
1887                 }
1888         }
1889         return 0;
1890
1891 }
1892
1893 static int add_header(struct sip_request *req, char *var, char *value)
1894 {
1895         if (req->len >= sizeof(req->data) - 4) {
1896                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
1897                 return -1;
1898         }
1899         if (req->lines) {
1900                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
1901                 return -1;
1902         }
1903         req->header[req->headers] = req->data + req->len;
1904         snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
1905         req->len += strlen(req->header[req->headers]);
1906         if (req->headers < SIP_MAX_HEADERS)
1907                 req->headers++;
1908         else {
1909                 ast_log(LOG_WARNING, "Out of header space\n");
1910                 return -1;
1911         }
1912         return 0;
1913 }
1914
1915 static int add_blank_header(struct sip_request *req)
1916 {
1917         if (req->len >= sizeof(req->data) - 4) {
1918                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
1919                 return -1;
1920         }
1921         if (req->lines) {
1922                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
1923                 return -1;
1924         }
1925         req->header[req->headers] = req->data + req->len;
1926         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
1927         req->len += strlen(req->header[req->headers]);
1928         if (req->headers < SIP_MAX_HEADERS)
1929                 req->headers++;
1930         else {
1931                 ast_log(LOG_WARNING, "Out of header space\n");
1932                 return -1;
1933         }
1934         return 0;
1935 }
1936
1937 static int add_line(struct sip_request *req, char *line)
1938 {
1939         if (req->len >= sizeof(req->data) - 4) {
1940                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
1941                 return -1;
1942         }
1943         if (!req->lines) {
1944                 /* Add extra empty return */
1945                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
1946                 req->len += strlen(req->data + req->len);
1947         }
1948         req->line[req->lines] = req->data + req->len;
1949         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
1950         req->len += strlen(req->line[req->lines]);
1951         if (req->lines < SIP_MAX_LINES)
1952                 req->lines++;
1953         else {
1954                 ast_log(LOG_WARNING, "Out of line space\n");
1955                 return -1;
1956         }
1957         return 0;
1958 }
1959
1960 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
1961 {
1962         char *tmp;
1963         tmp = get_header(orig, field);
1964         if (strlen(tmp)) {
1965                 /* Add what we're responding to */
1966                 return add_header(req, field, tmp);
1967         }
1968         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
1969         return -1;
1970 }
1971
1972 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
1973 {
1974         char *tmp;
1975         int start = 0;
1976         int copied = 0;
1977         for (;;) {
1978                 tmp = __get_header(orig, field, &start);
1979                 if (strlen(tmp)) {
1980                         /* Add what we're responding to */
1981                         add_header(req, field, tmp);
1982                         copied++;
1983                 } else
1984                         break;
1985         }
1986         return copied ? 0 : -1;
1987 }
1988
1989 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
1990 {
1991         char *tmp;
1992         int start = 0;
1993         int copied = 0;
1994         char new[256];
1995         for (;;) {
1996                 tmp = __get_header(orig, field, &start);
1997                 if (strlen(tmp)) {
1998                         if (!copied && p->nat) {
1999 #ifdef THE_SIP_AUTHORS_CAN_SUCK_MY_GONADS
2000                                 /* SLD: FIXME: Nice try, but the received= should not have a port */
2001                                 /* SLD: FIXME: See RFC2543 BNF in Section 6.40.5 */
2002                                 /* MAS: Yup, RFC says you can't do it.  No way to indicate PAT...
2003                                    good job fellas. */
2004                                 if (ntohs(p->recv.sin_port) != DEFAULT_SIP_PORT)
2005                                         snprintf(new, sizeof(new), "%s;received=%s:%d", tmp, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
2006                                 else
2007 #endif
2008                                         snprintf(new, sizeof(new), "%s;received=%s", tmp, inet_ntoa(p->recv.sin_addr));
2009                                 add_header(req, field, new);
2010                         } else {
2011                                 /* Add what we're responding to */
2012                                 add_header(req, field, tmp);
2013                         }
2014                         copied++;
2015                 } else
2016                         break;
2017         }
2018         if (!copied) {
2019                 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2020                 return -1;
2021         }
2022         return 0;
2023 }
2024
2025 /* Add Route: header into request per learned route */
2026 static void add_route(struct sip_request *req, struct sip_route *route)
2027 {
2028         char r[256], *p;
2029         int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2030
2031         if (!route) return;
2032
2033         p = r;
2034         while (route) {
2035                 n = strlen(route->hop);
2036                 if ((n+3)>rem) break;
2037                 if (p != r) {
2038                         *p++ = ',';
2039                         --rem;
2040                 }
2041                 *p++ = '<';
2042                 strcpy(p, route->hop);  p += n;
2043                 *p++ = '>';
2044                 rem -= (n+2);
2045                 route = route->next;
2046         }
2047         *p = '\0';
2048         add_header(req, "Route", r);
2049 }
2050
2051 static void set_destination(struct sip_pvt *p, char *uri)
2052 {
2053         char *h, *maddr, hostname[256];
2054         int port, hn;
2055         struct hostent *hp;
2056
2057         /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2058         /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2059
2060         if (sipdebug)
2061                 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2062
2063         /* Find and parse hostname */
2064         h = strchr(uri, '@');
2065         if (h)
2066                 ++h;
2067         else {
2068                 h = uri;
2069                 if (strncmp(h, "sip:", 4) == 0)
2070                         h += 4;
2071                 else if (strncmp(h, "sips:", 5) == 0)
2072                         h += 5;
2073         }
2074         hn = strcspn(h, ":;>");
2075         if (hn>255) hn=255;
2076         strncpy(hostname, h, hn);  hostname[hn] = '\0';
2077         h+=hn;
2078
2079         /* Is "port" present? if not default to 5060 */
2080         if (*h == ':') {
2081                 /* Parse port */
2082                 ++h;
2083                 port = strtol(h, &h, 10);
2084         }
2085         else
2086                 port = 5060;
2087
2088         /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
2089         maddr = strstr(h, "maddr=");
2090         if (maddr) {
2091                 maddr += 6;
2092                 hn = strspn(maddr, "0123456789.");
2093                 if (hn>255) hn=255;
2094                 strncpy(hostname, maddr, hn);  hostname[hn] = '\0';
2095         }
2096
2097         hp = gethostbyname(hostname);
2098         if (hp == NULL)  {
2099                 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
2100                 return;
2101         }
2102         p->sa.sin_family = AF_INET;
2103         memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
2104         p->sa.sin_port = htons(port);
2105         if (sipdebug)
2106                 ast_verbose("set_destination: set destination to %s, port %d\n", inet_ntoa(p->sa.sin_addr), port);
2107 }
2108
2109 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
2110 {
2111         /* Initialize a response */
2112         if (req->headers || req->len) {
2113                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2114                 return -1;
2115         }
2116         req->header[req->headers] = req->data + req->len;
2117         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
2118         req->len += strlen(req->header[req->headers]);
2119         if (req->headers < SIP_MAX_HEADERS)
2120                 req->headers++;
2121         else
2122                 ast_log(LOG_WARNING, "Out of header space\n");
2123         return 0;
2124 }
2125
2126 static int init_req(struct sip_request *req, char *resp, char *recip)
2127 {
2128         /* Initialize a response */
2129         if (req->headers || req->len) {
2130                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2131                 return -1;
2132         }
2133         req->header[req->headers] = req->data + req->len;
2134         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
2135         req->len += strlen(req->header[req->headers]);
2136         if (req->headers < SIP_MAX_HEADERS)
2137                 req->headers++;
2138         else
2139                 ast_log(LOG_WARNING, "Out of header space\n");
2140         return 0;
2141 }
2142
2143 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
2144 {
2145         char newto[256] = "", *ot;
2146         memset(resp, 0, sizeof(*resp));
2147         init_resp(resp, msg, req);
2148         copy_via_headers(p, resp, req, "Via");
2149         if (msg[0] == '2') copy_all_header(resp, req, "Record-Route");
2150         copy_header(resp, req, "From");
2151         ot = get_header(req, "To");
2152         if (!strstr(ot, "tag=")) {
2153                 /* Add the proper tag if we don't have it already.  If they have specified
2154                    their tag, use it.  Otherwise, use our own tag */
2155                 if (strlen(p->theirtag) && p->outgoing)
2156                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
2157                 else if (p->tag && !p->outgoing)
2158                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
2159                 else
2160                         strncpy(newto, ot, sizeof(newto) - 1);
2161                 ot = newto;
2162         }
2163         add_header(resp, "To", ot);
2164         copy_header(resp, req, "Call-ID");
2165         copy_header(resp, req, "CSeq");
2166         add_header(resp, "User-Agent", "Asterisk PBX");
2167         add_header(resp, "Allow", ALLOWED_METHODS);
2168         if (p->expiry) {
2169                 /* For registration responses, we also need expiry and
2170                    contact info */
2171                 char contact[256];
2172                 char tmp[256];
2173                 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
2174                 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
2175                 add_header(resp, "Expires", tmp);
2176                 add_header(resp, "Contact", contact);
2177         } else {
2178                 add_header(resp, "Contact", p->our_contact);
2179         }
2180         return 0;
2181 }
2182
2183 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno)
2184 {
2185         struct sip_request *orig = &p->initreq;
2186         char stripped[80] ="";
2187         char tmp[80];
2188         char newto[256];
2189         char *c, *n;
2190         char *ot, *of;
2191
2192         memset(req, 0, sizeof(struct sip_request));
2193
2194         if (!seqno) {
2195                 p->ocseq++;
2196                 seqno = p->ocseq;
2197         }
2198
2199         if (strlen(p->uri)) {
2200                 c = p->uri;
2201         } else {
2202                 if (p->outgoing)
2203                         strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
2204                 else
2205                         strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
2206
2207                 c = strchr(stripped, '<');
2208                 if (c)
2209                         c++;
2210                 else
2211                         c = stripped;
2212                 n = strchr(c, '>');
2213                 if (n)
2214                         *n = '\0';
2215                 n = strchr(c, ';');
2216                 if (n)
2217                         *n = '\0';
2218         }
2219         init_req(req, msg, c);
2220
2221         snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
2222
2223         add_header(req, "Via", p->via);
2224         if (p->route) {
2225                 set_destination(p, p->route->hop);
2226                 add_route(req, p->route->next);
2227         }
2228
2229         ot = get_header(orig, "To");
2230         of = get_header(orig, "From");
2231
2232         /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
2233            as our original request, including tag (or presumably lack thereof) */
2234         if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
2235                 /* Add the proper tag if we don't have it already.  If they have specified
2236                    their tag, use it.  Otherwise, use our own tag */
2237                 if (p->outgoing && strlen(p->theirtag))
2238                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
2239                 else if (!p->outgoing)
2240                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
2241                 else
2242                         snprintf(newto, sizeof(newto), "%s", ot);
2243                 ot = newto;
2244         }
2245
2246         if (p->outgoing) {
2247                 add_header(req, "From", of);
2248                 add_header(req, "To", ot);
2249         } else {
2250                 add_header(req, "From", ot);
2251                 add_header(req, "To", of);
2252         }
2253         add_header(req, "Contact", p->our_contact);
2254         copy_header(req, orig, "Call-ID");
2255         add_header(req, "CSeq", tmp);
2256
2257         add_header(req, "User-Agent", "Asterisk PBX");
2258         return 0;
2259 }
2260
2261 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
2262 {
2263         struct sip_request resp;
2264         int seqno = 0;
2265         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
2266                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
2267                 return -1;
2268         }
2269         respprep(&resp, p, msg, req);
2270         add_header(&resp, "Content-Length", "0");
2271         add_blank_header(&resp);
2272         return send_response(p, &resp, reliable, seqno);
2273 }
2274
2275 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req)
2276 {
2277         return __transmit_response(p, msg, req, 0);
2278 }
2279 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req)
2280 {
2281         return __transmit_response(p, msg, req, 1);
2282 }
2283
2284 static void append_date(struct sip_request *req)
2285 {
2286         char tmpdat[256];
2287         struct tm tm;
2288         time_t t;
2289         time(&t);
2290         gmtime_r(&t, &tm);
2291         strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
2292         add_header(req, "Date", tmpdat);
2293 }
2294
2295 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
2296 {
2297         struct sip_request resp;
2298         respprep(&resp, p, msg, req);
2299         append_date(&resp);
2300         add_header(&resp, "Content-Length", "0");
2301         add_blank_header(&resp);
2302         return send_response(p, &resp, 0, 0);
2303 }
2304
2305 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req)
2306 {
2307         struct sip_request resp;
2308         respprep(&resp, p, msg, req);
2309         add_header(&resp, "Accept", "application/sdp");
2310         add_header(&resp, "Content-Length", "0");
2311         add_blank_header(&resp);
2312         return send_response(p, &resp, 0, 0);
2313 }
2314
2315 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable)
2316 {
2317         struct sip_request resp;
2318         char tmp[256];
2319         int seqno = 0;
2320         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
2321                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
2322                 return -1;
2323         }
2324         snprintf(tmp, sizeof(tmp), "Digest realm=\"asterisk\", nonce=\"%s\"", randdata);
2325         respprep(&resp, p, msg, req);
2326         add_header(&resp, "Proxy-Authenticate", tmp);
2327         add_header(&resp, "Content-Length", "0");
2328         add_blank_header(&resp);
2329         return send_response(p, &resp, reliable, seqno);
2330 }
2331
2332 static int add_text(struct sip_request *req, char *text)
2333 {
2334         /* XXX Convert \n's to \r\n's XXX */
2335         int len = strlen(text);
2336         char clen[256];
2337         snprintf(clen, sizeof(clen), "%d", len);
2338         add_header(req, "Content-Type", "text/plain");
2339         add_header(req, "Content-Length", clen);
2340         add_line(req, text);
2341         return 0;
2342 }
2343
2344 static int add_digit(struct sip_request *req, char digit)
2345 {
2346         char tmp[256];
2347         int len;
2348         char clen[256];
2349         snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
2350         len = strlen(tmp);
2351         snprintf(clen, sizeof(clen), "%d", len);
2352         add_header(req, "Content-Type", "application/dtmf-relay");
2353         add_header(req, "Content-Length", clen);
2354         add_line(req, tmp);
2355         return 0;
2356 }
2357
2358 static int add_sdp(struct sip_request *resp, struct sip_pvt *p, struct ast_rtp *rtp, struct ast_rtp *vrtp)
2359 {
2360         int len;
2361         int codec;
2362         int alreadysent = 0;
2363         char costr[80];
2364         struct sockaddr_in sin;
2365         struct sockaddr_in vsin;
2366         struct sip_codec_pref *cur;
2367         char v[256];
2368         char s[256];
2369         char o[256];
2370         char c[256];
2371         char t[256];
2372         char m[256];
2373         char m2[256];
2374         char a[1024] = "";
2375         char a2[1024] = "";
2376         int x;
2377         struct sockaddr_in dest;
2378         struct sockaddr_in vdest;
2379         /* XXX We break with the "recommendation" and send our IP, in order that our
2380                peer doesn't have to gethostbyname() us XXX */
2381         len = 0;
2382         if (!p->rtp) {
2383                 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
2384                 return -1;
2385         }
2386         ast_rtp_get_us(p->rtp, &sin);
2387         if (p->vrtp)
2388                 ast_rtp_get_us(p->vrtp, &vsin);
2389
2390         if (p->redirip.sin_addr.s_addr) {
2391                 dest.sin_port = p->redirip.sin_port;
2392                 dest.sin_addr = p->redirip.sin_addr;
2393         } else if (rtp) {
2394                 ast_rtp_get_peer(rtp, &dest);
2395         } else {
2396                 dest.sin_addr = p->ourip;
2397                 dest.sin_port = sin.sin_port;
2398         }
2399
2400         /* Determine video destination */
2401         if (p->vrtp) {
2402                 if (p->vredirip.sin_addr.s_addr) {
2403                         vdest.sin_port = p->vredirip.sin_port;
2404                         vdest.sin_addr = p->vredirip.sin_addr;
2405                 } else if (vrtp) {
2406                         ast_rtp_get_peer(vrtp, &vdest);
2407                 } else {
2408                         vdest.sin_addr = p->ourip;
2409                         vdest.sin_port = vsin.sin_port;
2410                 }
2411         }
2412         if (sipdebug)
2413                 ast_verbose("We're at %s port %d\n", inet_ntoa(p->ourip), ntohs(sin.sin_port));
2414         if (sipdebug && p->vrtp)
2415                 ast_verbose("Video is at %s port %d\n", inet_ntoa(p->ourip), ntohs(vsin.sin_port));
2416         snprintf(v, sizeof(v), "v=0\r\n");
2417         snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", getpid(), getpid(), inet_ntoa(dest.sin_addr));
2418         snprintf(s, sizeof(s), "s=session\r\n");
2419         snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", inet_ntoa(dest.sin_addr));
2420         snprintf(t, sizeof(t), "t=0 0\r\n");
2421         snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
2422         snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
2423         /* Start by sending our preferred codecs */
2424         cur = prefs;
2425         while(cur) {
2426                 if (p->capability & cur->codec) {
2427                         if (sipdebug)
2428                                 ast_verbose("Answering with preferred capability %d\n", cur->codec);
2429                         codec = ast_rtp_lookup_code(p->rtp, 1, cur->codec);
2430                         if (codec > -1) {
2431                                 snprintf(costr, sizeof(costr), " %d", codec);
2432                                 if (cur->codec < AST_FORMAT_MAX_AUDIO) {
2433                                         strcat(m, costr);
2434                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
2435                                         strcat(a, costr);
2436                                 } else {
2437                                         strcat(m2, costr);
2438                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
2439                                         strcat(a2, costr);
2440                                 }
2441                         }
2442                 }
2443                 alreadysent |= cur->codec;
2444                 cur = cur->next;
2445         }
2446         /* Now send any other common codecs, and non-codec formats: */
2447         for (x = 1; x <= AST_FORMAT_MAX_AUDIO; x <<= 1) {
2448                 if ((p->capability & x) && !(alreadysent & x)) {
2449                         if (sipdebug)
2450                                 ast_verbose("Answering with capability %d\n", x);
2451                         codec = ast_rtp_lookup_code(p->rtp, 1, x);
2452                         if (codec > -1) {
2453                                 snprintf(costr, sizeof(costr), " %d", codec);
2454                                 if (x < AST_FORMAT_MAX_AUDIO) {
2455                                         strcat(m, costr);
2456                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
2457                                         strcat(a, costr);
2458                                 } else {
2459                                         strcat(m2, costr);
2460                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
2461                                         strcat(a2, costr);
2462                                 }
2463                         }
2464                 }
2465         }
2466         for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
2467                 if (p->noncodeccapability & x) {
2468                         if (sipdebug)
2469                                 ast_verbose("Answering with non-codec capability %d\n", x);
2470                         codec = ast_rtp_lookup_code(p->rtp, 0, x);
2471                         if (codec > -1) {
2472                                 snprintf(costr, sizeof(costr), " %d", codec);
2473                                 strcat(m, costr);
2474                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
2475                                 strcat(a, costr);
2476                                 if (x == AST_RTP_DTMF) {
2477                                   /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
2478                                   snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n",
2479                                            codec);
2480                                   strcat(a, costr);
2481                                 }
2482                         }
2483                 }
2484         }
2485         strcat(m, "\r\n");
2486         strcat(m2, "\r\n");
2487         len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
2488         if (p->vrtp)
2489                 len += strlen(m2) + strlen(a2);
2490         snprintf(costr, sizeof(costr), "%d", len);
2491         add_header(resp, "Content-Type", "application/sdp");
2492         add_header(resp, "Content-Length", costr);
2493         add_line(resp, v);
2494         add_line(resp, o);
2495         add_line(resp, s);
2496         add_line(resp, c);
2497         add_line(resp, t);
2498         add_line(resp, m);
2499         add_line(resp, a);
2500         if (p->vrtp) {
2501                 add_line(resp, m2);
2502                 add_line(resp, a2);
2503         }
2504         return 0;
2505 }
2506
2507 static void copy_request(struct sip_request *dst,struct sip_request *src)
2508 {
2509         long offset;
2510         int x;
2511         offset = ((void *)dst) - ((void *)src);
2512         /* First copy stuff */
2513         memcpy(dst, src, sizeof(*dst));
2514         /* Now fix pointer arithmetic */
2515         for (x=0;x<src->headers;x++)
2516                 dst->header[x] += offset;
2517         for (x=0;x<src->lines;x++)
2518                 dst->line[x] += offset;
2519 }
2520
2521 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
2522 {
2523         struct sip_request resp;
2524         int seqno;
2525         if (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1) {
2526                 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
2527                 return -1;
2528         }
2529         respprep(&resp, p, msg, req);
2530         add_sdp(&resp, p, NULL, NULL);
2531         return send_response(p, &resp, retrans, seqno);
2532 }
2533
2534 static int determine_firstline_parts( struct sip_request *req ) {
2535
2536   char *e, *cmd;
2537   int len;
2538
2539   cmd= req->header[0];
2540   while(*cmd && (*cmd < 33)) {
2541     cmd++;
2542   }
2543   if (!*cmd) {
2544     return -1;
2545   }
2546   e= cmd;
2547   while(*e && (*e > 32)) {
2548     e++;
2549   }
2550   /* Get the command */
2551   if (*e) {
2552     *e = '\0';
2553     e++;
2554   }
2555   req->rlPart1= cmd;
2556   while( *e && ( *e < 33 ) ) {
2557     e++;
2558   }
2559   if( !*e ) {
2560     return -1;
2561   }
2562
2563   if ( !strcasecmp(cmd, "SIP/2.0") ) {
2564     /* We have a response */
2565     req->rlPart2= e;
2566     len= strlen( req->rlPart2 );
2567     if( len < 2 ) { return -1; }
2568     e+= len - 1;
2569     while( *e && *e<33 ) {
2570       e--;
2571     }
2572     *(++e)= '\0';
2573   } else {
2574     /* We have a request */
2575     if( *e == '<' ) {
2576       e++;
2577       if( !*e ) { return -1; }
2578     }
2579     req->rlPart2= e;
2580     if( ( e= strrchr( req->rlPart2, 'S' ) ) == NULL ) {
2581       return -1;
2582     }
2583     while( isspace( *(--e) ) ) {}
2584     if( *e == '>' ) {
2585       *e= '\0';
2586     } else {
2587       *(++e)= '\0';
2588     }
2589   }
2590   return 1;
2591 }
2592
2593 static int transmit_reinvite_with_sdp(struct sip_pvt *p, struct ast_rtp *rtp, struct ast_rtp *vrtp)
2594 {
2595         struct sip_request req;
2596         if (p->canreinvite == REINVITE_UPDATE)
2597                 reqprep(&req, p, "UPDATE", 0);
2598         else
2599                 reqprep(&req, p, "INVITE", 0);
2600         add_header(&req, "Allow", ALLOWED_METHODS);
2601         add_sdp(&req, p, rtp, vrtp);
2602         /* Use this as the basis */
2603         copy_request(&p->initreq, &req);
2604         parse(&p->initreq);
2605         determine_firstline_parts(&p->initreq);
2606         p->lastinvite = p->ocseq;
2607         p->outgoing = 1;
2608         return send_request(p, &req, 1, p->ocseq);
2609 }
2610
2611 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
2612 {
2613         char stripped[256]="";
2614         char *c, *n;
2615         strncpy(stripped, get_header(req, "Contact"), sizeof(stripped) - 1);
2616         c = strchr(stripped, '<');
2617         if (c)
2618                 c++;
2619         else
2620                 c = stripped;
2621         n = strchr(c, '>');
2622         if (n)
2623                 *n = '\0';
2624         n = strchr(c, ';');
2625         if (n)
2626                 *n = '\0';
2627         if (c && strlen(c))
2628                 strncpy(p->uri, c, sizeof(p->uri) - 1);
2629 }
2630
2631 static void build_contact(struct sip_pvt *p)
2632 {
2633         /* Construct Contact: header */
2634         if (ourport != 5060)
2635                 snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s@%s:%d>", p->exten, inet_ntoa(p->ourip), ourport);
2636         else
2637                 snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s@%s>", p->exten, inet_ntoa(p->ourip));
2638 }
2639
2640 static void initreqprep(struct sip_request *req, struct sip_pvt *p, char *cmd, char *vxml_url)
2641 {
2642         char invite[256];
2643         char from[256];
2644         char to[256];
2645         char tmp[80];
2646         char cid[256];
2647         char *l = callerid, *n=NULL;
2648         if (p->owner && p->owner->callerid) {
2649                 strcpy(cid, p->owner->callerid);
2650                 ast_callerid_parse(cid, &n, &l);
2651                 if (l)
2652                         ast_shrink_phone_number(l);
2653                 if (!l || !ast_isphonenumber(l))
2654                                 l = callerid;
2655         }
2656         /* if user want's his callerid restricted */
2657         if (p->restrictcid)
2658                 l = CALLERID_UNKNOWN;
2659         if (!n || !strlen(n))
2660                 n = l;
2661         /* Allow user to be overridden */
2662         if (strlen(p->fromuser))
2663                 l = p->fromuser;
2664
2665         if ((ourport != 5060) && !strlen(p->fromdomain))
2666                 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);
2667         else
2668                 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s>;tag=as%08x", n, l, strlen(p->fromdomain) ? p->fromdomain : inet_ntoa(p->ourip), p->tag);
2669
2670         if (strlen(p->username)) {
2671                 if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) {
2672                         snprintf(invite, sizeof(invite), "sip:%s@%s:%d",p->username, p->tohost, ntohs(p->sa.sin_port));
2673                 } else {
2674                         snprintf(invite, sizeof(invite), "sip:%s@%s",p->username, p->tohost);
2675                 }
2676         } else if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) {
2677                 snprintf(invite, sizeof(invite), "sip:%s:%d", p->tohost, ntohs(p->sa.sin_port));
2678         } else {
2679                 snprintf(invite, sizeof(invite), "sip:%s", p->tohost);
2680         }
2681         strncpy(p->uri, invite, sizeof(p->uri) - 1);
2682         /* If there is a VXML URL append it to the SIP URL */
2683         if (vxml_url)
2684         {
2685                 snprintf(to, sizeof(to), "<%s>;%s", invite, vxml_url);
2686         }
2687         else
2688         {
2689                 snprintf(to, sizeof(to), "<%s>", invite );
2690         }
2691         memset(req, 0, sizeof(struct sip_request));
2692         init_req(req, cmd, invite);
2693         snprintf(tmp, sizeof(tmp), "%d %s", ++p->ocseq, cmd);
2694
2695         add_header(req, "Via", p->via);
2696         /* SLD: FIXME?: do Route: here too?  I think not cos this is the first request.
2697          * OTOH, then we won't have anything in p->route anyway */
2698         add_header(req, "From", from);
2699         strncpy(p->exten, l, sizeof(p->exten) - 1);
2700         build_contact(p);
2701         add_header(req, "To", to);
2702         add_header(req, "Contact", p->our_contact);
2703         add_header(req, "Call-ID", p->callid);
2704         add_header(req, "CSeq", tmp);
2705         add_header(req, "User-Agent", "Asterisk PBX");
2706 }
2707
2708 static int transmit_invite(struct sip_pvt *p, char *cmd, int sdp, char *auth, char *vxml_url, char *distinctive_ring, int init)
2709 {
2710         struct sip_request req;
2711
2712         if (init)
2713                 initreqprep(&req, p, cmd, vxml_url);
2714         else
2715                 reqprep(&req, p, cmd, 0);
2716
2717         if (auth)
2718                 add_header(&req, "Proxy-Authorization", auth);
2719
2720         if (distinctive_ring)
2721         {
2722                 add_header(&req, "Alert-info",distinctive_ring);
2723         }
2724         add_header(&req, "Allow", ALLOWED_METHODS);
2725         if (sdp) {
2726                 add_sdp(&req, p, NULL, NULL);
2727         } else {
2728                 add_header(&req, "Content-Length", "0");
2729                 add_blank_header(&req);
2730         }
2731
2732         if (!p->initreq.headers) {
2733                 /* Use this as the basis */
2734                 copy_request(&p->initreq, &req);
2735                 parse(&p->initreq);
2736                 determine_firstline_parts(&p->initreq);
2737         }
2738         p->lastinvite = p->ocseq;
2739         return send_request(p, &req, 1, p->ocseq);
2740 }
2741
2742 static int transmit_state_notify(struct sip_pvt *p, int state, int full)
2743 {
2744         char tmp[2000];
2745         char from[256], to[256];
2746         char *t, *c, *a;
2747         char *mfrom, *mto;
2748         struct sip_request req;
2749         char clen[20];
2750
2751         strncpy(from, get_header(&p->initreq, "From"), sizeof(from)-1);
2752
2753         c = ditch_braces(from);
2754         if (strncmp(c, "sip:", 4)) {
2755                 ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
2756                 return -1;
2757         }
2758         if ((a = strchr(c, ';'))) {
2759                 *a = '\0';
2760         }
2761         mfrom = c;
2762
2763         reqprep(&req, p, "NOTIFY", 0);
2764
2765         if (p->subscribed == 1) {
2766             strncpy(to, get_header(&p->initreq, "To"), sizeof(to)-1);
2767
2768             c = ditch_braces(to);
2769             if (strncmp(c, "sip:", 4)) {
2770                 ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
2771                 return -1;
2772             }
2773             if ((a = strchr(c, ';'))) {
2774                 *a = '\0';
2775             }
2776             mto = c;
2777
2778             add_header(&req, "Content-Type", "application/xpidf+xml");
2779
2780             if ((state==AST_EXTENSION_UNAVAILABLE) || (state==AST_EXTENSION_BUSY))
2781                 state = 2;
2782             else if (state==AST_EXTENSION_INUSE)
2783                 state = 1;
2784             else
2785                 state = 0;
2786
2787             t = tmp;
2788             sprintf(t, "<?xml version=\"1.0\"?>\n");
2789             t = tmp + strlen(tmp);
2790             sprintf(t, "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n");
2791             t = tmp + strlen(tmp);
2792             sprintf(t, "<presence>\n");
2793             t = tmp + strlen(tmp);
2794             sprintf(t, "<presentity uri=\"%s;method=SUBSCRIBE\" />\n", mfrom);
2795             t = tmp + strlen(tmp);
2796             sprintf(t, "<atom id=\"%s\">\n", p->exten);
2797             t = tmp + strlen(tmp);
2798             sprintf(t, "<address uri=\"%s;user=ip\" priority=\"0,800000\">\n", mto);
2799             t = tmp + strlen(tmp);
2800             sprintf(t, "<status status=\"%s\" />\n", !state ? "open" : (state==1) ? "inuse" : "closed");
2801             t = tmp + strlen(tmp);
2802             sprintf(t, "<msnsubstatus substatus=\"%s\" />\n", !state ? "online" : (state==1) ? "onthephone" : "offline");
2803             t = tmp + strlen(tmp);
2804             sprintf(t, "</address>\n</atom>\n</presence>\n");
2805         } else {
2806             add_header(&req, "Event", "dialog");
2807             add_header(&req, "Content-Type", "application/dialog-info+xml");
2808
2809             t = tmp;
2810             sprintf(t, "<?xml version=\"1.0\"?>\n");
2811             t = tmp + strlen(tmp);
2812             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);
2813             t = tmp + strlen(tmp);
2814             sprintf(t, "<dialog id=\"%s\">\n", p->exten);
2815             t = tmp + strlen(tmp);
2816             sprintf(t, "<state>%s</state>\n", state ? "confirmed" : "terminated");
2817             t = tmp + strlen(tmp);
2818             sprintf(t, "</dialog>\n</dialog-info>\n");
2819         }
2820
2821         snprintf(clen, sizeof(clen), "%d", strlen(tmp));
2822         add_header(&req, "Content-Length", clen);
2823         add_line(&req, tmp);
2824
2825         return send_request(p, &req, 1, p->ocseq);
2826 }
2827
2828 static int transmit_notify(struct sip_pvt *p, int newmsgs, int oldmsgs)
2829 {
2830         struct sip_request req;
2831         char tmp[256];
2832         char tmp2[256];
2833         char clen[20];
2834         initreqprep(&req, p, "NOTIFY", NULL);
2835         add_header(&req, "Event", "message-summary");
2836         add_header(&req, "Content-Type", notifymime);
2837
2838         snprintf(tmp, sizeof(tmp), "Messages-Waiting: %s\n", newmsgs ? "yes" : "no");
2839         snprintf(tmp2, sizeof(tmp2), "Voicemail: %d/%d\n", newmsgs, oldmsgs);
2840         snprintf(clen, sizeof(clen), "%d", strlen(tmp) + strlen(tmp2));
2841         add_header(&req, "Content-Length", clen);
2842         add_line(&req, tmp);
2843         add_line(&req, tmp2);
2844
2845         if (!p->initreq.headers) {
2846                 /* Use this as the basis */
2847                 copy_request(&p->initreq, &req);
2848                 parse(&p->initreq);
2849                 determine_firstline_parts(&p->initreq);
2850         }
2851
2852         return send_request(p, &req, 1, p->ocseq);
2853 }
2854
2855 static int transmit_register(struct sip_registry *r, char *cmd, char *auth, char *authheader);
2856
2857 static int sip_reregister(void *data)
2858 {
2859         /* if we are here, we know that we need to reregister. */
2860         struct sip_registry *r=(struct sip_registry *)data;
2861         r->expire = -1;
2862         sip_do_register(r);
2863         return 0;
2864 }
2865
2866
2867 static int sip_do_register(struct sip_registry *r)
2868 {
2869         int res;
2870         ast_mutex_lock(&r->lock);
2871         res=transmit_register(r, "REGISTER", NULL, NULL);
2872         ast_mutex_unlock(&r->lock);
2873         return res;
2874 }
2875
2876 static int sip_reg_timeout(void *data)
2877 {
2878         /* if we are here, our registration timed out, so we'll just do it over */
2879         struct sip_registry *r=data;
2880         struct sip_pvt *p;
2881         int res;
2882         ast_mutex_lock(&r->lock);
2883         ast_log(LOG_NOTICE, "Registration for '%s@%s' timed out, trying again\n", r->username, inet_ntoa(r->addr.sin_addr));
2884         if (r->call) {
2885                 /* Unlink us, destroy old call.  Locking is not relevent here because all this happens
2886                    in the single SIP manager thread. */
2887                 p = r->call;
2888                 p->registry = NULL;
2889                 r->call = NULL;
2890                 p->needdestroy = 1;
2891         }
2892         r->regstate=REG_STATE_UNREGISTERED;
2893         r->timeout = -1;
2894         res=transmit_register(r, "REGISTER", NULL, NULL);
2895         ast_mutex_unlock(&r->lock);
2896         return 0;
2897 }
2898
2899 static int transmit_register(struct sip_registry *r, char *cmd, char *auth, char *authheader)
2900 {
2901         struct sip_request req;
2902         char from[256];
2903         char to[256];
2904         char tmp[80];
2905         char via[80];
2906         char addr[80];
2907         struct sip_pvt *p;
2908         /* exit if we are already in process with this registrar ?*/
2909         if ( r == NULL || ((auth==NULL) && (r->regstate==REG_STATE_REGSENT || r->regstate==REG_STATE_AUTHSENT))) {
2910                 ast_log(LOG_NOTICE, "Strange, trying to register when registration already pending\n");
2911                 return 0;
2912         }
2913
2914         if (r->call) {
2915                 if (!auth) {
2916                         ast_log(LOG_WARNING, "Already have a call??\n");
2917                         return 0;
2918                 } else
2919                         p = r->call;
2920         } else {
2921                 if (!r->callid_valid) {
2922                         build_callid(r->callid, sizeof(r->callid), __ourip);
2923                         r->callid_valid = 1;
2924                 }
2925                 p=sip_alloc( r->callid, &r->addr, 0);
2926                 if (!p) {
2927                         ast_log(LOG_WARNING, "Unable to allocate registration call\n");
2928                         return 0;
2929                 }
2930                 p->outgoing = 1;
2931                 r->call=p;
2932                 p->registry=r;
2933                 strncpy(p->peersecret, r->secret, sizeof(p->peersecret)-1);
2934                 if (strlen(r->authuser))
2935                         strncpy(p->peername, r->authuser, sizeof(p->peername)-1);
2936                 else
2937                         strncpy(p->peername, r->username, sizeof(p->peername)-1);
2938                 strncpy(p->username, r->username, sizeof(p->username)-1);
2939                 strncpy(p->exten, r->contact, sizeof(p->exten) - 1);
2940                 /* Always bind to our IP if specified */
2941                 if (bindaddr.sin_addr.s_addr)
2942                         memcpy(&p->ourip, &bindaddr.sin_addr, sizeof(p->ourip));
2943                 build_contact(p);
2944         }
2945
2946         /* set up a timeout */
2947         if (auth==NULL)  {
2948                 if (r->timeout > -1) {
2949                         ast_log(LOG_WARNING, "Still have a timeout, %d\n", r->timeout);
2950                         ast_sched_del(sched, r->timeout);
2951                 }
2952                 r->timeout = ast_sched_add(sched, 20*1000, sip_reg_timeout, r);
2953                 ast_log(LOG_DEBUG, "Scheduled a timeout # %d\n", r->timeout);
2954         }
2955
2956         if (strchr(r->username, '@')) {
2957                 snprintf(from, sizeof(from), "<sip:%s>;tag=as%08x", r->username, p->tag);
2958                 snprintf(to, sizeof(to),     "<sip:%s>", r->username);
2959         } else {
2960                 snprintf(from, sizeof(from), "<sip:%s@%s>;tag=as%08x", r->username, r->hostname, p->tag);
2961                 snprintf(to, sizeof(to),     "<sip:%s@%s>", r->username, r->hostname);
2962         }
2963
2964         snprintf(addr, sizeof(addr), "sip:%s", r->hostname);
2965         strncpy(p->uri, addr, sizeof(p->uri) - 1);
2966
2967         memset(&req, 0, sizeof(req));
2968         init_req(&req, cmd, addr);
2969
2970         snprintf(tmp, sizeof(tmp), "%u %s", ++r->ocseq, cmd);
2971         p->ocseq = r->ocseq;
2972
2973         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
2974         snprintf(via, sizeof(via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
2975         add_header(&req, "Via", via);
2976         add_header(&req, "From", from);
2977         add_header(&req, "To", to);
2978         add_header(&req, "Call-ID", p->callid);
2979         add_header(&req, "CSeq", tmp);
2980         add_header(&req, "User-Agent", "Asterisk PBX");
2981         if (auth)
2982                 add_header(&req, authheader, auth);
2983
2984         snprintf(tmp, sizeof(tmp), "%d", default_expiry);
2985         add_header(&req, "Expires", tmp);
2986         add_header(&req, "Contact", p->our_contact);
2987         add_header(&req, "Event", "registration");
2988         add_header(&req, "Content-length", "0");
2989         add_blank_header(&req);
2990         copy_request(&p->initreq, &req);
2991         parse(&p->initreq);
2992         determine_firstline_parts(&p->initreq);
2993         r->regstate=auth?REG_STATE_AUTHSENT:REG_STATE_REGSENT;
2994         return send_request(p, &req, 1, p->ocseq);
2995 }
2996
2997 static int transmit_message_with_text(struct sip_pvt *p, char *text)
2998 {
2999         struct sip_request req;
3000         reqprep(&req, p, "MESSAGE", 0);
3001         add_text(&req, text);
3002         return send_request(p, &req, 1, p->ocseq);
3003 }
3004
3005 static int transmit_refer(struct sip_pvt *p, char *dest)
3006 {
3007         struct sip_request req;
3008         char from[256];
3009         char *of, *c;
3010         char referto[256];
3011         if (p->outgoing)
3012                 of = get_header(&p->initreq, "To");
3013         else
3014                 of = get_header(&p->initreq, "From");
3015         strncpy(from, of, sizeof(from) - 1);
3016         of = ditch_braces(from);
3017         strncpy(p->from,of,sizeof(p->from) - 1);
3018         if (strncmp(of, "sip:", 4)) {
3019                 ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
3020         } else
3021                 of += 4;
3022         /* Get just the username part */
3023         if ((c = strchr(of, '@'))) {
3024                 *c = '\0';
3025                 c++;
3026         }
3027         if (c) {
3028                 snprintf(referto, sizeof(referto), "<sip:%s@%s>", dest, c);
3029         } else {
3030                 snprintf(referto, sizeof(referto), "<sip:%s>", dest);
3031         }
3032
3033         reqprep(&req, p, "REFER", 0);
3034         add_header(&req, "Refer-To", referto);
3035         add_header(&req, "Referred-By", callerid);
3036         return send_request(p, &req, 1, p->ocseq);
3037 }
3038
3039 static int transmit_info_with_digit(struct sip_pvt *p, char digit)
3040 {
3041         struct sip_request req;
3042         reqprep(&req, p, "INFO", 0);
3043         add_digit(&req, digit);
3044         return send_request(p, &req, 1, p->ocseq);
3045 }
3046
3047 static int transmit_request(struct sip_pvt *p, char *msg, int seqno, int reliable)
3048 {
3049         struct sip_request resp;
3050         reqprep(&resp, p, msg, seqno);
3051         add_header(&resp, "Content-Length", "0");
3052         add_blank_header(&resp);
3053         return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
3054 }
3055
3056 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int seqno, int reliable)
3057 {
3058         struct sip_request resp;
3059         reqprep(&resp, p, msg, seqno);
3060         if (*p->realm)
3061         {
3062                 char digest[256];
3063                 memset(digest,0,sizeof(digest));
3064                 build_reply_digest(p, msg, digest, sizeof(digest));
3065                 add_header(&resp, "Proxy-Authorization", digest);
3066         }
3067
3068         add_header(&resp, "Content-Length", "0");
3069         add_blank_header(&resp);
3070         return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
3071 }
3072
3073 static int expire_register(void *data)
3074 {
3075         struct sip_peer *p = data;
3076         memset(&p->addr, 0, sizeof(p->addr));
3077         ast_db_del("SIP/Registry", p->name);
3078         p->expire = -1;
3079         ast_device_state_changed("SIP/%s", p->name);
3080         return 0;
3081 }
3082
3083 static int sip_poke_peer(struct sip_peer *peer);
3084
3085 static void reg_source_db(struct sip_peer *p)
3086 {
3087         char data[80];
3088         struct in_addr in;
3089         char *c, *d;
3090         int expiry;
3091         if (!ast_db_get("SIP/Registry", p->name, data, sizeof(data))) {
3092                 c = strchr(data, ':');
3093                 if (c) {
3094                         *c = '\0';
3095                         c++;
3096                         if (inet_aton(data, &in)) {
3097                                 d = strchr(c, ':');
3098                                 if (d) {
3099                                         *d = '\0';
3100                                         d++;
3101                                         ast_verbose(VERBOSE_PREFIX_3 "SIP Seeding '%s' at %s:%d for %d\n", p->name,
3102                                                 inet_ntoa(in), atoi(c), atoi(d));
3103                                         sip_poke_peer(p);
3104                                         expiry = atoi(d);
3105                                         memset(&p->addr, 0, sizeof(p->addr));
3106                                         p->addr.sin_family = AF_INET;
3107                                         p->addr.sin_addr = in;
3108                                         p->addr.sin_port = htons(atoi(c));
3109                                         if (p->expire > -1)
3110                                                 ast_sched_del(sched, p->expire);
3111                                         p->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, (void *)p);
3112                                 }
3113
3114                         }
3115                 }
3116         }
3117 }
3118
3119 static int parse_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req)
3120 {
3121         char contact[80]= "";
3122         char data[256];
3123         char *expires = get_header(req, "Expires");
3124         int expiry = atoi(expires);
3125         char *c, *n, *pt;
3126         int port;
3127         struct hostent *hp;
3128         struct sockaddr_in oldsin;
3129         if (!strlen(expires)) {
3130                 expires = strstr(get_header(req, "Contact"), "expires=");
3131                 if (expires) {
3132                         if (sscanf(expires + 8, "%d;", &expiry) != 1)
3133                                 expiry = default_expiry;
3134                 } else {
3135                         /* Nothing has been specified */
3136                         expiry = default_expiry;
3137                 }
3138         }
3139         /* Look for brackets */
3140         strncpy(contact, get_header(req, "Contact"), sizeof(contact) - 1);
3141         c = contact;
3142
3143         if ((n=strchr(c, '<'))) {
3144                 c = n + 1;
3145                 n = strchr(c, '>');
3146                 /* Lose the part after the > */
3147                 if (n)
3148                         *n = '\0';
3149         }
3150         if (!strcasecmp(c, "*") || !expiry) {
3151                 /* This means remove all registrations and return OK */
3152                 memset(&p->addr, 0, sizeof(p->addr));
3153                 if (p->expire > -1)
3154                         ast_sched_del(sched, p->expire);
3155                 p->expire = -1;
3156                 if (option_verbose > 2)
3157                         ast_verbose(VERBOSE_PREFIX_3 "Unregistered SIP '%s'\n", p->name);
3158                 return 0;
3159         }
3160         /* Make sure it's a SIP URL */
3161         if (strncasecmp(c, "sip:", 4)) {
3162                 ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", c);
3163         } else
3164                 c += 4;
3165         /* Ditch q */
3166         n = strchr(c, ';');
3167         if (n)
3168                 *n = '\0';
3169         /* Grab host */
3170         n = strchr(c, '@');
3171         if (!n) {
3172                 n = c;
3173                 c = NULL;
3174         } else {
3175                 *n = '\0';
3176                 n++;
3177         }
3178         pt = strchr(n, ':');
3179         if (pt) {
3180                 *pt = '\0';
3181                 pt++;
3182                 port = atoi(pt);
3183         } else
3184                 port = DEFAULT_SIP_PORT;
3185         memcpy(&oldsin, &p->addr, sizeof(oldsin));
3186         if (!p->nat) {
3187                 /* XXX This could block for a long time XXX */
3188                 hp = gethostbyname(n);
3189                 if (!hp)  {
3190                         ast_log(LOG_WARNING, "Invalid host '%s'\n", n);
3191                         return -1;
3192                 }
3193                 p->addr.sin_family = AF_INET;
3194                 memcpy(&p->addr.sin_addr, hp->h_addr, sizeof(p->addr.sin_addr));
3195                 p->addr.sin_port = htons(port);
3196         } else {
3197                 /* Don't trust the contact field.  Just use what they came to us
3198                    with */
3199                 memcpy(&p->addr, &pvt->recv, sizeof(p->addr));
3200         }
3201         if (c)
3202                 strncpy(p->username, c, sizeof(p->username) - 1);
3203         else
3204                 strcpy(p->username, "");
3205         if (p->expire > -1)
3206                 ast_sched_del(sched, p->expire);
3207         if ((expiry < 1) || (expiry > max_expiry))
3208                 expiry = max_expiry;
3209         p->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, p);
3210         pvt->expiry = expiry;
3211         if (inaddrcmp(&p->addr, &oldsin)) {
3212                 sip_poke_peer(p);
3213                 snprintf(data, sizeof(data), "%s:%d:%d", inet_ntoa(p->addr.sin_addr), ntohs(p->addr.sin_port), expiry);
3214                 ast_db_put("SIP/Registry", p->name, data);
3215                 if (option_verbose > 2)
3216                         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);
3217         }
3218         return 0;
3219 }
3220
3221 static void free_old_route(struct sip_route *route)
3222 {
3223         struct sip_route *next;
3224         while (route) {
3225                 next = route->next;
3226                 free(route);
3227                 route = next;
3228         }
3229 }
3230
3231 static void list_route(struct sip_route *route)
3232 {
3233         if (!route) {
3234                 ast_verbose("list_route: no route\n");
3235                 return;
3236         }
3237         while (route) {
3238                 ast_verbose("list_route: hop: <%s>\n", route->hop);
3239                 route = route->next;
3240         }
3241 }
3242
3243 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards)
3244 {
3245         struct sip_route *thishop, *head, *tail;
3246         int start = 0;
3247         int len;
3248         char *rr, *contact, *c;
3249
3250         if (p->route) {
3251                 free_old_route(p->route);
3252                 p->route = NULL;
3253         }
3254         /* We build up head, then assign it to p->route when we're done */
3255         head = NULL;  tail = head;
3256         /* 1st we pass through all the hops in any Record-Route headers */
3257         for (;;) {
3258                 /* Each Record-Route header */
3259                 rr = __get_header(req, "Record-Route", &start);
3260                 if (*rr == '\0') break;
3261                 for (;;) {
3262                         /* Each route entry */
3263                         /* Find < */
3264                         rr = strchr(rr, '<');
3265                         if (!rr) break; /* No more hops */
3266                         ++rr;
3267                         len = strcspn(rr, ">");
3268                         /* Make a struct route */
3269                         thishop = (struct sip_route *)malloc(sizeof(struct sip_route)+len+1);
3270                         if (thishop) {
3271                                 strncpy(thishop->hop, rr, len);
3272                                 thishop->hop[len] = '\0';
3273                                 ast_log(LOG_DEBUG, "build_route: Record-Route hop: <%s>\n", thishop->hop);
3274                                 /* Link in */
3275                                 if (backwards) {
3276                                         /* Link in at head so they end up in reverse order */
3277                                         thishop->next = head;
3278                                         head = thishop;
3279                                         /* If this was the first then it'll be the tail */
3280                                         if (!tail) tail = thishop;
3281                                 } else {
3282                                         thishop->next = NULL;
3283                                         /* Link in at the end */
3284                                         if (tail)
3285                                                 tail->next = thishop;
3286                                         else
3287                                                 head = thishop;
3288                                         tail = thishop;
3289                                 }
3290                         }
3291                         rr += len+1;
3292                 }
3293         }
3294         /* 2nd append the Contact: if there is one */
3295         /* Can be multiple Contact headers, comma separated values - we just take the first */
3296         contact = get_header(req, "Contact");
3297         if (strlen(contact)) {
3298                 ast_log(LOG_DEBUG, "build_route: Contact hop: %s\n", contact);
3299                 /* Look for <: delimited address */
3300                 c = strchr(contact, '<');
3301                 if (c) {
3302                         /* Take to > */
3303                         ++c;
3304                         len = strcspn(c, ">");
3305                 } else {
3306                         /* No <> - just take the lot */
3307                         c = contact; len = strlen(contact);
3308                 }
3309                 thishop = (struct sip_route *)malloc(sizeof(struct sip_route)+len+1);
3310                 if (thishop) {
3311                         strncpy(thishop->hop, c, len);
3312                         thishop->hop[len] = '\0';
3313                         thishop->next = NULL;
3314                         /* Goes at the end */
3315                         if (tail)
3316                                 tail->next = thishop;
3317                         else
3318                                 head = thishop;
3319                 }
3320         }
3321         /* Store as new route */
3322         p->route = head;
3323
3324         /* For debugging dump what we ended up with */
3325         if (sipdebug)
3326                 list_route(p->route);
3327 }
3328
3329 static void md5_hash(char *output, char *input)
3330 {
3331                 struct MD5Context md5;
3332                 unsigned char digest[16];
3333                 char *ptr;
3334                 int x;
3335                 MD5Init(&md5);
3336                 MD5Update(&md5, input, strlen(input));
3337                 MD5Final(digest, &md5);
3338                 ptr = output;
3339                 for (x=0;x<16;x++)
3340                         ptr += sprintf(ptr, "%2.2x", digest[x]);
3341 }
3342
3343 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)
3344 {
3345         int res = -1;
3346         /* Always OK if no secret */
3347         if (!strlen(secret))
3348                 return 0;
3349         if (!strlen(randdata) || !strlen(get_header(req, "Proxy-Authorization"))) {
3350                 snprintf(randdata, randlen, "%08x", rand());
3351                 transmit_response_with_auth(p, "407 Proxy Authentication Required", req, randdata, reliable);
3352                 /* Schedule auto destroy in 15 seconds */
3353                 sip_scheddestroy(p, 15000);
3354                 res = 1;
3355         } else {
3356                 /* Whoever came up with the authentication section of SIP can suck my %&#$&* for not putting
3357                    an example in the spec of just what it is you're doing a hash on. */
3358                 char a1[256];
3359                 char a2[256];
3360                 char a1_hash[256];
3361                 char a2_hash[256];
3362                 char resp[256];
3363                 char resp_hash[256];
3364                 char tmp[256] = "";
3365                 char *c;
3366                 char *z;
3367                 char *response ="";
3368                 char *resp_uri ="";
3369
3370                 /* Find their response among the mess that we'r sent for comparison */
3371                 strncpy(tmp, get_header(req, "Proxy-Authorization"), sizeof(tmp) - 1);
3372                 c = tmp;
3373
3374                 while(c) {
3375                         while (*c && (*c < 33)) c++;
3376                         if (!*c)
3377                                 break;
3378                         if (!strncasecmp(c, "response=", strlen("response="))) {
3379                                 c+= strlen("response=");
3380                                 if ((*c == '\"')) {
3381                                         response=++c;
3382                                         if((c = strchr(c,'\"')))
3383                                                 *c = '\0';
3384
3385                                 } else {
3386                                         response=c;
3387                                         if((c = strchr(c,',')))
3388                                                 *c = '\0';
3389                                 }
3390
3391                         } else if (!strncasecmp(c, "uri=", strlen("uri="))) {
3392                                 c+= strlen("uri=");
3393                                 if ((*c == '\"')) {
3394                                         resp_uri=++c;
3395                                         if((c = strchr(c,'\"')))
3396                                                 *c = '\0';
3397                                 } else {
3398                                         resp_uri=c;
3399                                         if((c = strchr(c,',')))
3400                                                 *c = '\0';
3401                                 }
3402
3403                         } else
3404                                 if ((z = strchr(c,' ')) || (z = strchr(c,','))) c=z;
3405                         if (c)
3406                                 c++;
3407                 }
3408                 snprintf(a1, sizeof(a1), "%s:%s:%s", username, "asterisk", secret);
3409                 if(strlen(resp_uri))
3410                         snprintf(a2, sizeof(a2), "%s:%s", method, resp_uri);
3411                 else
3412                         snprintf(a2, sizeof(a2), "%s:%s", method, uri);
3413                 md5_hash(a1_hash, a1);
3414                 md5_hash(a2_hash, a2);
3415                 snprintf(resp, sizeof(resp), "%s:%s:%s", a1_hash, randdata, a2_hash);
3416                 md5_hash(resp_hash, resp);
3417
3418                 /* resp_hash now has the expected response, compare the two */
3419
3420                 if (response && !strncasecmp(response, resp_hash, strlen(resp_hash))) {
3421                         /* Auth is OK */
3422                         res = 0;
3423                 }
3424                 /* Assume success ;-) */
3425                 /* Eliminate random data */
3426                 strcpy(randdata, "");
3427         }
3428         return res;
3429 }
3430
3431 static int cb_extensionstate(char *context, char* exten, int state, void *data)
3432 {
3433     struct sip_pvt *p = data;
3434     if (state == -1) {
3435         sip_scheddestroy(p, 15000);
3436         p->stateid = -1;
3437         return 0;
3438     }
3439
3440     transmit_state_notify(p, state, 1);
3441
3442     if (option_debug)
3443         ast_verbose(VERBOSE_PREFIX_1 "Extension Changed %s new state %d for Notify User %s\n", exten, state, p->username);
3444     return 0;
3445 }
3446
3447 static int register_verify(struct sip_pvt *p, struct sockaddr_in *sin, struct sip_request *req, char *uri)
3448 {
3449         int res = -1;
3450         struct sip_peer *peer;
3451         char tmp[256] = "";
3452         char *name, *c;
3453         char *t;
3454         /* Terminate URI */
3455         t = uri;
3456         while(*t && (*t > 32) && (*t != ';'))
3457                 t++;
3458         *t = '\0';
3459
3460         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
3461         c = ditch_braces(tmp);
3462         /* Ditch ;user=phone */
3463         name = strchr(c, ';');
3464         if (name)
3465                 *name = '\0';
3466
3467         if (!strncmp(c, "sip:", 4)) {
3468                 name = c + 4;
3469         } else {
3470                 name = c;
3471                 ast_log(LOG_NOTICE, "Invalid to address: '%s' from %s (missing sip:) trying to use anyway...\n", c, inet_ntoa(sin->sin_addr));
3472         }
3473         c = strchr(name, '@');
3474         if (c)
3475                 *c = '\0';
3476         strncpy(p->exten, name, sizeof(p->exten) - 1);
3477         build_contact(p);
3478         ast_mutex_lock(&peerl.lock);
3479         peer = peerl.peers;
3480         while(peer) {
3481                 if (!strcasecmp(peer->name, name) && peer->dynamic) {
3482                         p->nat = peer->nat;
3483                         transmit_response(p, "100 Trying", req);
3484                         if (!(res = check_auth(p, req, p->randdata, sizeof(p->randdata), peer->name, peer->secret, "REGISTER", uri, 0))) {
3485                                 sip_cancel_destroy(p);
3486                                 if (parse_contact(p, peer, req)) {
3487                                         ast_log(LOG_WARNING, "Failed to parse contact info\n");
3488                                 } else {
3489                                         /* Say OK and ask subsystem to retransmit msg counter */
3490                                         transmit_response_with_date(p, "200 OK", req);
3491                                         peer->lastmsgssent = -1;
3492                                         res = 0;
3493                                 }
3494                         }
3495                         break;
3496                 }
3497                 peer = peer->next;
3498         }
3499         ast_mutex_unlock(&peerl.lock);
3500         if (!res) {
3501             ast_device_state_changed("SIP/%s", peer->name);
3502         }
3503         if (res < 0)
3504                 transmit_response(p, "401 Unauthorized", &p->initreq);
3505         return res;
3506 }
3507
3508 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq)
3509 {
3510         char tmp[256] = "", *c, *a;
3511         struct sip_request *req;
3512
3513         req = oreq;
3514         if (!req)
3515                 req = &p->initreq;
3516         strncpy(tmp, get_header(req, "Diversion"), sizeof(tmp) - 1);
3517         if (!strlen(tmp))
3518                 return 0;
3519         c = ditch_braces(tmp);
3520         if (strncmp(c, "sip:", 4)) {
3521                 ast_log(LOG_WARNING, "Huh?  Not an RDNIS SIP header (%s)?\n", c);
3522                 return -1;
3523         }
3524         c += 4;
3525         if ((a = strchr(c, '@')) || (a = strchr(c, ';'))) {
3526                 *a = '\0';
3527         }
3528         if (sipdebug)
3529                 ast_verbose("RDNIS is %s\n", c);
3530         strncpy(p->rdnis, c, sizeof(p->rdnis) - 1);
3531
3532         return 0;
3533 }
3534 static int get_destination(struct sip_pvt *p, struct sip_request *oreq)