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