channels/chan_sip.c

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