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