Initialize secrets properly (bug #1748)
[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 static ast_mutex_t mysqllock = AST_MUTEX_INITIALIZER;
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 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
159
160 /* Protect the interface list (of sip_pvt's) */
161 static ast_mutex_t iflock = AST_MUTEX_INITIALIZER;
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 static ast_mutex_t netlock = AST_MUTEX_INITIALIZER;
166
167 static ast_mutex_t monlock = AST_MUTEX_INITIALIZER;
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 static ast_mutex_t sip_reload_lock = AST_MUTEX_INITIALIZER;
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 = { NULL, AST_MUTEX_INITIALIZER };
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 = { NULL, AST_MUTEX_INITIALIZER };
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 = { NULL, AST_MUTEX_INITIALIZER };
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                 free(p);
1372         }
1373 }
1374
1375 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1376 /* Note: This is going to be replaced by app_groupcount */
1377 static int update_user_counter(struct sip_pvt *fup, int event)
1378 {
1379         char name[256] = "";
1380         struct sip_user *u;
1381         strncpy(name, fup->username, sizeof(name) - 1);
1382         ast_mutex_lock(&userl.lock);
1383         u = find_user(name);
1384         if (!u) {
1385                 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1386                 ast_mutex_unlock(&userl.lock);
1387                 return 0;
1388         }
1389         switch(event) {
1390                 /* incoming and outgoing affects the inUse counter */
1391                 case DEC_OUT_USE:
1392                 case DEC_IN_USE:
1393                         if ( u->inUse > 0 ) {
1394                                 u->inUse--;
1395                         } else {
1396                                 u->inUse = 0;
1397                         }
1398                         break;
1399                 case INC_IN_USE:
1400                 case INC_OUT_USE:
1401                         if (u->incominglimit > 0 ) {
1402                                 if (u->inUse >= u->incominglimit) {
1403                                         ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1404                                         /* inc inUse as well */
1405                                         if ( event == INC_OUT_USE ) {
1406                                                 u->inUse++;
1407                                         }
1408                                         ast_mutex_unlock(&userl.lock);
1409                                         return -1; 
1410                                 }
1411                         }
1412                         u->inUse++;
1413                         ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1414                         break;
1415                 /* we don't use these anymore
1416                 case DEC_OUT_USE:
1417                         if ( u->outUse > 0 ) {
1418                                 u->outUse--;
1419                         } else {
1420                                 u->outUse = 0;
1421                         }
1422                         break;
1423                 case INC_OUT_USE:
1424                         if ( u->outgoinglimit > 0 ) {
1425                                 if ( u->outUse >= u->outgoinglimit ) {
1426                                         ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1427                                         ast_mutex_unlock(&userl.lock);
1428                                         return -1;
1429                                 }
1430                         }
1431                         u->outUse++;
1432                         break;
1433                 */
1434                 default:
1435                         ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1436         }
1437         ast_mutex_unlock(&userl.lock);
1438         return 0;
1439 }
1440
1441 /*--- sip_destroy: Destroy SIP call structure ---*/
1442 static void sip_destroy(struct sip_pvt *p)
1443 {
1444         ast_mutex_lock(&iflock);
1445         __sip_destroy(p, 1);
1446         ast_mutex_unlock(&iflock);
1447 }
1448
1449
1450 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1451
1452 static int hangup_sip2cause(int cause)
1453 {
1454 /* Possible values from causes.h
1455         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
1456         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
1457 */
1458
1459         switch(cause) {
1460                 case 404:       /* Not found */
1461                         return AST_CAUSE_UNALLOCATED;
1462                 case 483:       /* Too many hops */
1463                         return AST_CAUSE_FAILURE;
1464                 case 486:
1465                         return AST_CAUSE_BUSY;
1466                 default:
1467                         return AST_CAUSE_NORMAL;
1468         }
1469         /* Never reached */
1470         return 0;
1471 }
1472
1473 static char *hangup_cause2sip(int cause)
1474 {
1475         switch(cause)
1476         {
1477                 case AST_CAUSE_FAILURE:
1478                         return "500 Server internal failure";
1479                 case AST_CAUSE_CONGESTION:
1480                         return "503 Service Unavailable";
1481                 case AST_CAUSE_BUSY:
1482                         return "486 Busy";
1483                 default:
1484                         return NULL;
1485         }
1486         /* Never reached */
1487         return 0;
1488 }
1489
1490 /*--- sip_hangup: Hangup SIP call */
1491 static int sip_hangup(struct ast_channel *ast)
1492 {
1493         struct sip_pvt *p = ast->pvt->pvt;
1494         int needcancel = 0;
1495         int needdestroy = 0;
1496         if (option_debug)
1497                 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1498         if (!ast->pvt->pvt) {
1499                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1500                 return 0;
1501         }
1502         ast_mutex_lock(&p->lock);
1503         if ( p->outgoing ) {
1504                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1505                 update_user_counter(p, DEC_OUT_USE);
1506         } else {
1507                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1508                 update_user_counter(p, DEC_IN_USE);
1509         }
1510         /* Determine how to disconnect */
1511         if (p->owner != ast) {
1512                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
1513                 ast_mutex_unlock(&p->lock);
1514                 return 0;
1515         }
1516         if (!ast || (ast->_state != AST_STATE_UP))
1517                 needcancel = 1;
1518         /* Disconnect */
1519         p = ast->pvt->pvt;
1520         if (p->vad) {
1521             ast_dsp_free(p->vad);
1522         }
1523         p->owner = NULL;
1524         ast->pvt->pvt = NULL;
1525
1526         ast_mutex_lock(&usecnt_lock);
1527         usecnt--;
1528         ast_mutex_unlock(&usecnt_lock);
1529         ast_update_use_count();
1530
1531         needdestroy = 1; 
1532         /* Start the process if it's not already started */
1533         if (!p->alreadygone && !ast_strlen_zero(p->initreq.data)) {
1534                 if (needcancel) {
1535                         if (p->outgoing) {
1536                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1537                                 /* Actually don't destroy us yet, wait for the 487 on our original 
1538                                    INVITE, but do set an autodestruct just in case we never get it. */
1539                                 needdestroy = 0;
1540                                 sip_scheddestroy(p, 15000);
1541                                 if ( p->initid != -1 ) {
1542                                         /* channel still up - reverse dec of inUse counter
1543                                            only if the channel is not auto-congested */
1544                                         if ( p->outgoing ) {
1545                                                 update_user_counter(p, INC_OUT_USE);
1546                                         }
1547                                         else {
1548                                                 update_user_counter(p, INC_IN_USE);
1549                                         }
1550                                 }
1551                         } else {
1552                                 char *res;
1553                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1554                                         transmit_response_reliable(p, res, &p->initreq, 1);
1555                                 } else 
1556                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1557                         }
1558                 } else {
1559                         if (!p->pendinginvite) {
1560                                 /* Send a hangup */
1561                                 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1562                         } else {
1563                                 /* Note we will need a BYE when this all settles out
1564                                    but we can't send one while we have "INVITE" outstanding. */
1565                                 p->pendingbye = 1;
1566                                 p->needreinvite = 0;
1567                         }
1568                 }
1569         }
1570         p->needdestroy = needdestroy;
1571         ast_mutex_unlock(&p->lock);
1572         return 0;
1573 }
1574
1575 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1576 static int sip_answer(struct ast_channel *ast)
1577 {
1578         int res = 0,fmt;
1579         char *codec;
1580         struct sip_pvt *p = ast->pvt->pvt;
1581
1582         
1583         if (ast->_state != AST_STATE_UP) {
1584         
1585         
1586         
1587                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1588                 if (codec) {
1589                         fmt=ast_getformatbyname(codec);
1590                         if (fmt) {
1591                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1592                                 p->jointcapability=fmt;
1593                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1594                 }
1595
1596                 ast_setstate(ast, AST_STATE_UP);
1597                 if (option_debug)
1598                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1599                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1600         }
1601         return res;
1602 }
1603
1604 /*--- sip_write: Send response, support audio media ---*/
1605 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1606 {
1607         struct sip_pvt *p = ast->pvt->pvt;
1608         int res = 0;
1609         if (frame->frametype == AST_FRAME_VOICE) {
1610                 if (!(frame->subclass & ast->nativeformats)) {
1611                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1612                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1613                         return -1;
1614                 }
1615                 if (p) {
1616                         ast_mutex_lock(&p->lock);
1617                         if (p->rtp) {
1618                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1619                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1620                                         p->progress = 1;
1621                                 }
1622                                 res =  ast_rtp_write(p->rtp, frame);
1623                         }
1624                         ast_mutex_unlock(&p->lock);
1625                 }
1626         } else if (frame->frametype == AST_FRAME_VIDEO) {
1627                 if (p) {
1628                         ast_mutex_lock(&p->lock);
1629                         if (p->vrtp) {
1630                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1631                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1632                                         p->progress = 1;
1633                                 }
1634                                 res =  ast_rtp_write(p->vrtp, frame);
1635                         }
1636                         ast_mutex_unlock(&p->lock);
1637                 }
1638         } else if (frame->frametype == AST_FRAME_IMAGE) {
1639                 return 0;
1640         } else {
1641                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1642                 return 0;
1643         }
1644
1645         return res;
1646 }
1647
1648 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
1649         Basically update any ->owner links ----*/
1650 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1651 {
1652         struct sip_pvt *p = newchan->pvt->pvt;
1653         ast_mutex_lock(&p->lock);
1654         if (p->owner != oldchan) {
1655                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1656                 ast_mutex_unlock(&p->lock);
1657                 return -1;
1658         }
1659         p->owner = newchan;
1660         ast_mutex_unlock(&p->lock);
1661         return 0;
1662 }
1663
1664 /*--- sip_senddigit: Send DTMF character on SIP channel */
1665 /*    within one call, we're able to transmit in many methods simultaneously */
1666 static int sip_senddigit(struct ast_channel *ast, char digit)
1667 {
1668         struct sip_pvt *p = ast->pvt->pvt;
1669         if (p && (p->dtmfmode & SIP_DTMF_INFO)) {
1670                 transmit_info_with_digit(p, digit);
1671         }
1672         if (p && p->rtp && (p->dtmfmode & SIP_DTMF_RFC2833)) {
1673                 ast_rtp_senddigit(p->rtp, digit);
1674         }
1675         /* If in-band DTMF is desired, send that */
1676         if (p->dtmfmode & SIP_DTMF_INBAND)
1677                 return -1;
1678         return 0;
1679 }
1680
1681
1682 /*--- sip_transfer: Transfer SIP call */
1683 static int sip_transfer(struct ast_channel *ast, char *dest)
1684 {
1685         struct sip_pvt *p = ast->pvt->pvt;
1686         int res;
1687         res = transmit_refer(p, dest);
1688         return res;
1689 }
1690
1691 /*--- sip_indicate: Play indication to user */
1692 /* With SIP a lot of indications is sent as messages, letting the device play
1693    the indication - busy signal, congestion etc */
1694 static int sip_indicate(struct ast_channel *ast, int condition)
1695 {
1696         struct sip_pvt *p = ast->pvt->pvt;
1697         switch(condition) {
1698         case AST_CONTROL_RINGING:
1699                 if (ast->_state == AST_STATE_RING) {
1700                         if (!p->progress) {
1701                                 transmit_response(p, "180 Ringing", &p->initreq);
1702                                 p->ringing = 1;
1703                                 break;
1704                         } else {
1705                                 /* Oops, we've sent progress tones.  Let Asterisk do it instead */
1706                         }
1707                 }
1708                 return -1;
1709         case AST_CONTROL_BUSY:
1710                 if (ast->_state != AST_STATE_UP) {
1711                         transmit_response(p, "486 Busy Here", &p->initreq);
1712                         p->alreadygone = 1;
1713                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1714                         break;
1715                 }
1716                 return -1;
1717         case AST_CONTROL_CONGESTION:
1718                 if (ast->_state != AST_STATE_UP) {
1719                         transmit_response(p, "503 Service Unavailable", &p->initreq);
1720                         p->alreadygone = 1;
1721                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1722                         break;
1723                 }
1724                 return -1;
1725         case AST_CONTROL_PROGRESS:
1726                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1727                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1728                         p->progress = 1;
1729                         break;
1730                 }
1731                 return -1;
1732         case -1:
1733                 return -1;
1734         default:
1735                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1736                 return -1;
1737         }
1738         return 0;
1739 }
1740
1741
1742
1743 /*--- sip_new: Initiate a call in the SIP channel */
1744 /*      called from sip_request_call (calls from the pbx ) */
1745 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1746 {
1747         struct ast_channel *tmp;
1748         int fmt;
1749         tmp = ast_channel_alloc(1);
1750         if (tmp) {
1751                 /* Select our native format based on codec preference until we receive
1752                    something from another device to the contrary. */
1753                 if (i->jointcapability)
1754                         tmp->nativeformats = sip_codec_choose(i->jointcapability);
1755                 else if (i->capability)
1756                         tmp->nativeformats = sip_codec_choose(i->capability);
1757                 else
1758                         tmp->nativeformats = sip_codec_choose(capability);
1759                 fmt = ast_best_codec(tmp->nativeformats);
1760                 if (title)
1761                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
1762                 else
1763                         if (strchr(i->fromdomain,':'))
1764                         {
1765                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(i));
1766                         }
1767                         else
1768                         {
1769                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(i));
1770                         }
1771                 tmp->type = type;
1772                 if (i->dtmfmode & SIP_DTMF_INBAND) {
1773                     i->vad = ast_dsp_new();
1774                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
1775                     if (relaxdtmf)
1776                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
1777                 }
1778                 tmp->fds[0] = ast_rtp_fd(i->rtp);
1779                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
1780                 if (i->vrtp) {
1781                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
1782                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
1783                 }
1784                 if (state == AST_STATE_RING)
1785                         tmp->rings = 1;
1786                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1787                 tmp->writeformat = fmt;
1788                 tmp->pvt->rawwriteformat = fmt;
1789                 tmp->readformat = fmt;
1790                 tmp->pvt->rawreadformat = fmt;
1791                 tmp->pvt->pvt = i;
1792                 tmp->pvt->send_text = sip_sendtext;
1793                 tmp->pvt->call = sip_call;
1794                 tmp->pvt->hangup = sip_hangup;
1795                 tmp->pvt->answer = sip_answer;
1796                 tmp->pvt->read = sip_read;
1797                 tmp->pvt->write = sip_write;
1798                 tmp->pvt->write_video = sip_write;
1799                 tmp->pvt->indicate = sip_indicate;
1800                 tmp->pvt->transfer = sip_transfer;
1801                 tmp->pvt->fixup = sip_fixup;
1802                 tmp->pvt->send_digit = sip_senddigit;
1803
1804                 tmp->pvt->bridge = ast_rtp_bridge;
1805
1806                 tmp->callgroup = i->callgroup;
1807                 tmp->pickupgroup = i->pickupgroup;
1808                 tmp->restrictcid = i->restrictcid;
1809                 if (!ast_strlen_zero(i->accountcode))
1810                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
1811                 if (i->amaflags)
1812                         tmp->amaflags = i->amaflags;
1813                 if (!ast_strlen_zero(i->language))
1814                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
1815                 if (!ast_strlen_zero(i->musicclass))
1816                         strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
1817                 i->owner = tmp;
1818                 ast_mutex_lock(&usecnt_lock);
1819                 usecnt++;
1820                 ast_mutex_unlock(&usecnt_lock);
1821                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
1822                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
1823                 if (!ast_strlen_zero(i->callerid))
1824                         tmp->callerid = strdup(i->callerid);
1825                 if (!ast_strlen_zero(i->rdnis))
1826                         tmp->rdnis = strdup(i->rdnis);
1827                 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
1828                         tmp->dnid = strdup(i->exten);
1829                 tmp->priority = 1;
1830                 if (!ast_strlen_zero(i->domain)) {
1831                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
1832                 }
1833                 if (!ast_strlen_zero(i->useragent)) {
1834                         pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
1835                 }
1836                 if (!ast_strlen_zero(i->callid)) {
1837                         pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
1838                 }
1839                 ast_setstate(tmp, state);
1840                 if (state != AST_STATE_DOWN) {
1841                         if (ast_pbx_start(tmp)) {
1842                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1843                                 ast_hangup(tmp);
1844                                 tmp = NULL;
1845                         }
1846                 }
1847         } else
1848                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1849         return tmp;
1850 }
1851
1852 static struct cfalias {
1853         char *fullname;
1854         char *shortname;
1855 } aliases[] = {
1856         { "Content-Type", "c" },
1857         { "Content-Encoding", "e" },
1858         { "From", "f" },
1859         { "Call-ID", "i" },
1860         { "Contact", "m" },
1861         { "Content-Length", "l" },
1862         { "Subject", "s" },
1863         { "To", "t" },
1864         { "Supported", "k" },
1865         { "Refer-To", "r" },
1866         { "Allow-Events", "u" },
1867         { "Event", "o" },
1868         { "Via", "v" },
1869 };
1870
1871 /*--- get_sdp_by_line: Reads one line of SIP message body */
1872 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
1873   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
1874     char* r = line + nameLen + 1;
1875     while (*r && (*r < 33)) ++r;
1876     return r;
1877   }
1878
1879   return "";
1880 }
1881
1882 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
1883    but the name wrongly applies _only_ sdp */
1884 static char *get_sdp(struct sip_request *req, char *name) {
1885   int x;
1886   int len = strlen(name);
1887   char *r;
1888
1889   for (x=0; x<req->lines; x++) {
1890     r = get_sdp_by_line(req->line[x], name, len);
1891     if (r[0] != '\0') return r;
1892   }
1893   return "";
1894 }
1895
1896
1897 static void sdpLineNum_iterator_init(int* iterator) {
1898   *iterator = 0;
1899 }
1900
1901 static char* get_sdp_iterate(int* iterator,
1902                              struct sip_request *req, char *name) {
1903   int len = strlen(name);
1904   char *r;
1905   while (*iterator < req->lines) {
1906     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
1907     if (r[0] != '\0') return r;
1908   }
1909   return "";
1910 }
1911
1912 static char *__get_header(struct sip_request *req, char *name, int *start)
1913 {
1914         int x;
1915         int len = strlen(name);
1916         char *r;
1917         for (x=*start;x<req->headers;x++) {
1918                 if (!strncasecmp(req->header[x], name, len) && 
1919                                 (req->header[x][len] == ':')) {
1920                                         r = req->header[x] + len + 1;
1921                                         while(*r && (*r < 33))
1922                                                         r++;
1923                                         *start = x+1;
1924                                         return r;
1925                 }
1926         }
1927         /* Try aliases */
1928         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
1929                 if (!strcasecmp(aliases[x].fullname, name))
1930                         return __get_header(req, aliases[x].shortname, start);
1931
1932         /* Don't return NULL, so get_header is always a valid pointer */
1933         return "";
1934 }
1935
1936 /*--- get_header: Get header from SIP request ---*/
1937 static char *get_header(struct sip_request *req, char *name)
1938 {
1939         int start = 0;
1940         return __get_header(req, name, &start);
1941 }
1942
1943 /*--- sip_rtp_read: Read RTP from network ---*/
1944 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
1945 {
1946         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
1947         struct ast_frame *f;
1948         static struct ast_frame null_frame = { AST_FRAME_NULL, };
1949         switch(ast->fdno) {
1950         case 0:
1951                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
1952                 break;
1953         case 1:
1954                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
1955                 break;
1956         case 2:
1957                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
1958                 break;
1959         case 3:
1960                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
1961                 break;
1962         default:
1963                 f = &null_frame;
1964         }
1965         /* Don't send RFC2833 if we're not supposed to */
1966         if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & SIP_DTMF_RFC2833))
1967                 return &null_frame;
1968         if (p->owner) {
1969                 /* We already hold the channel lock */
1970                 if (f->frametype == AST_FRAME_VOICE) {
1971                         if (f->subclass != p->owner->nativeformats) {
1972                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
1973                                 p->owner->nativeformats = f->subclass;
1974                                 ast_set_read_format(p->owner, p->owner->readformat);
1975                                 ast_set_write_format(p->owner, p->owner->writeformat);
1976                         }
1977             if ((p->dtmfmode & SIP_DTMF_INBAND) && p->vad) {
1978                    f = ast_dsp_process(p->owner,p->vad,f);
1979                    if (f && (f->frametype == AST_FRAME_DTMF)) 
1980                         ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
1981             }
1982                 }
1983         }
1984         return f;
1985 }
1986
1987 /*--- sip_read: Read SIP RTP from channel */
1988 static struct ast_frame *sip_read(struct ast_channel *ast)
1989 {
1990         struct ast_frame *fr;
1991         struct sip_pvt *p = ast->pvt->pvt;
1992         ast_mutex_lock(&p->lock);
1993         fr = sip_rtp_read(ast, p);
1994         time(&p->lastrtprx);
1995         ast_mutex_unlock(&p->lock);
1996         return fr;
1997 }
1998
1999 /*--- build_callid: Build SIP CALLID header ---*/
2000 static void build_callid(char *callid, int len, struct in_addr ourip)
2001 {
2002         int res;
2003         int val;
2004         int x;
2005         for (x=0;x<4;x++) {
2006                 val = rand();
2007                 res = snprintf(callid, len, "%08x", val);
2008                 len -= res;
2009                 callid += res;
2010         }
2011         /* It's not important that we really use our right IP here... */
2012         snprintf(callid, len, "@%s", inet_ntoa(ourip));
2013 }
2014
2015 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2016 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobalnat)
2017 {
2018         struct sip_pvt *p;
2019
2020         p = malloc(sizeof(struct sip_pvt));
2021         if (!p)
2022                 return NULL;
2023         /* Keep track of stuff */
2024         memset(p, 0, sizeof(struct sip_pvt));
2025         p->initid = -1;
2026         p->autokillid = -1;
2027         p->stateid = -1;
2028         p->rtp = ast_rtp_new(sched, io, 1, 0);
2029         if (videosupport)
2030                 p->vrtp = ast_rtp_new(sched, io, 1, 0);
2031         p->branch = rand();     
2032         p->tag = rand();
2033         
2034         /* Start with 101 instead of 1 */
2035         p->ocseq = 101;
2036         if (!p->rtp) {
2037                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2038                 free(p);
2039                 return NULL;
2040         }
2041         ast_rtp_settos(p->rtp, tos);
2042         if (p->vrtp)
2043                 ast_rtp_settos(p->vrtp, tos);
2044         if (useglobalnat && sin) {
2045                 /* Setup NAT structure according to global settings if we have an address */
2046                 p->nat = globalnat;
2047                 memcpy(&p->recv, sin, sizeof(p->recv));
2048                 ast_rtp_setnat(p->rtp, p->nat);
2049                 if (p->vrtp)
2050                         ast_rtp_setnat(p->vrtp, p->nat);
2051         }
2052         ast_mutex_init(&p->lock);
2053
2054         if (sin) {
2055                 memcpy(&p->sa, sin, sizeof(p->sa));
2056                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2057                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2058         } else {
2059                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2060         }
2061         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
2062         snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
2063         if (!callid)
2064                 build_callid(p->callid, sizeof(p->callid), p->ourip);
2065         else
2066                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2067         /* Assume reinvite OK and via INVITE */
2068         p->canreinvite = globalcanreinvite;
2069         /* Assign default music on hold class */
2070         strncpy(p->musicclass, globalmusicclass, sizeof(p->musicclass));
2071         p->dtmfmode = globaldtmfmode;
2072         p->rtptimeout = globalrtptimeout;
2073         p->rtpholdtimeout = globalrtpholdtimeout;
2074         p->capability = capability;
2075         if (p->dtmfmode & SIP_DTMF_RFC2833)
2076                 p->noncodeccapability |= AST_RTP_DTMF;
2077         strncpy(p->context, context, sizeof(p->context) - 1);
2078         strncpy(p->fromdomain, fromdomain, sizeof(p->fromdomain) - 1);
2079         /* Add to list */
2080         ast_mutex_lock(&iflock);
2081         p->next = iflist;
2082         iflist = p;
2083         ast_mutex_unlock(&iflock);
2084         if (option_debug)
2085                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2086         return p;
2087 }
2088
2089 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2090 /*               Called by handle_request ,sipsock_read */
2091 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2092 {
2093         struct sip_pvt *p;
2094         char *callid;
2095         char tmp[256] = "";
2096         char *cmd;
2097         char *tag = "", *c;
2098         int themisfrom;
2099         callid = get_header(req, "Call-ID");
2100
2101         if (pedanticsipchecking) {
2102                 /* In principle Call-ID's uniquely identify a call, however some vendors
2103                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
2104                    tags in order to simplify billing.  The RFC does state that we have to
2105                    compare tags in addition to the call-id, but this generate substantially
2106                    more overhead which is totally unnecessary for the vast majority of sane
2107                    SIP implementations, and thus Asterisk does not enable this behavior
2108                    by default. Short version: You'll need this option to support conferencing
2109                    on the pingtel */
2110                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2111                 cmd = tmp;
2112                 c = strchr(tmp, ' ');
2113                 if (c)
2114                         *c = '\0';
2115                 if (!strcasecmp(cmd, "SIP/2.0")) {
2116                         themisfrom = 0;
2117                 } else {
2118                         themisfrom = 1;
2119                 }
2120                 if (themisfrom)
2121                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2122                 else
2123                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2124                 tag = strstr(tmp, "tag=");
2125                 if (tag) {
2126                         tag += 4;
2127                         c = strchr(tag, ';');
2128                         if (c)
2129                                 *c = '\0';
2130                 }
2131                         
2132         }
2133                 
2134         if (ast_strlen_zero(callid)) {
2135                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", inet_ntoa(sin->sin_addr));
2136                 return NULL;
2137         }
2138         ast_mutex_lock(&iflock);
2139         p = iflist;
2140         while(p) {
2141                 if (!strcmp(p->callid, callid) && 
2142                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2143                         /* Found the call */
2144                         ast_mutex_lock(&p->lock);
2145                         ast_mutex_unlock(&iflock);
2146                         return p;
2147                 }
2148                 p = p->next;
2149         }
2150         ast_mutex_unlock(&iflock);
2151         p = sip_alloc(callid, sin, 1);
2152         if (p)
2153                 ast_mutex_lock(&p->lock);
2154         return p;
2155 }
2156
2157 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2158 static int sip_register(char *value, int lineno)
2159 {
2160         struct sip_registry *reg;
2161         char copy[256] = "";
2162         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2163         char *porta=NULL;
2164         char *contact=NULL;
2165         char *stringp=NULL;
2166         
2167         struct hostent *hp;
2168         struct ast_hostent ahp;
2169         if (!value)
2170                 return -1;
2171         strncpy(copy, value, sizeof(copy)-1);
2172         stringp=copy;
2173         username = stringp;
2174         hostname = strrchr(stringp, '@');
2175         if (hostname) {
2176                 *hostname = '\0';
2177                 hostname++;
2178         }
2179         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2180                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2181                 return -1;
2182         }
2183         stringp=username;
2184         username = strsep(&stringp, ":");
2185         if (username) {
2186                 secret = strsep(&stringp, ":");
2187                 if (secret) 
2188                         authuser = strsep(&stringp, ":");
2189         }
2190         stringp = hostname;
2191         hostname = strsep(&stringp, "/");
2192         if (hostname) 
2193                 contact = strsep(&stringp, "/");
2194         if (!contact || ast_strlen_zero(contact))
2195                 contact = "s";
2196         stringp=hostname;
2197         hostname = strsep(&stringp, ":");
2198         porta = strsep(&stringp, ":");
2199         
2200         if (porta && !atoi(porta)) {
2201                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2202                 return -1;
2203         }
2204         hp = ast_gethostbyname(hostname, &ahp);
2205         if (!hp) {
2206                 ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
2207                 return -1;
2208         }
2209         reg = malloc(sizeof(struct sip_registry));
2210         if (reg) {
2211                 memset(reg, 0, sizeof(struct sip_registry));
2212                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2213                 if (username)
2214                         strncpy(reg->username, username, sizeof(reg->username)-1);
2215                 if (hostname)
2216                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2217                 if (authuser)
2218                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2219                 if (secret)
2220                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2221                 reg->expire = -1;
2222                 reg->timeout =  -1;
2223                 reg->refresh = default_expiry;
2224                 reg->addr.sin_family = AF_INET;
2225                 memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
2226                 reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(DEFAULT_SIP_PORT);
2227                 reg->callid_valid = 0;
2228                 reg->ocseq = 101;
2229                 ast_mutex_lock(&regl.lock);
2230                 reg->next = regl.registrations;
2231                 regl.registrations = reg;
2232                 ast_mutex_unlock(&regl.lock);
2233         } else {
2234                 ast_log(LOG_ERROR, "Out of memory\n");
2235                 return -1;
2236         }
2237         return 0;
2238 }
2239
2240 /*--- lws2sws: Parse multiline SIP headers into one header */
2241 /* This is enabled if pedanticsipchecking is enabled */
2242 static int lws2sws(char *msgbuf, int len) 
2243
2244         int h = 0, t = 0; 
2245         int lws = 0; 
2246
2247         for (; h < len;) { 
2248                 /* Eliminate all CRs */ 
2249                 if (msgbuf[h] == '\r') { 
2250                         h++; 
2251                         continue; 
2252                 } 
2253                 /* Check for end-of-line */ 
2254                 if (msgbuf[h] == '\n') { 
2255                 /* Check for end-of-message */ 
2256                         if (h + 1 == len) 
2257                         break; 
2258                 /* Check for a continuation line */ 
2259                 if (msgbuf[h + 1] == ' ') { 
2260                 /* Merge continuation line */ 
2261                         h++; 
2262                         continue; 
2263                 } 
2264                 /* Propagate LF and start new line */ 
2265                 msgbuf[t++] = msgbuf[h++]; 
2266                 lws = 0;
2267                 continue; 
2268         } 
2269
2270         if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
2271                 if (lws) { 
2272                         h++; 
2273                         continue; 
2274                 } 
2275                 msgbuf[t++] = msgbuf[h++]; 
2276                 lws = 1; 
2277                 continue; 
2278         } 
2279         msgbuf[t++] = msgbuf[h++]; 
2280         if (lws) 
2281                 lws = 0; 
2282         } 
2283         msgbuf[t] = '\0'; 
2284         return t; 
2285 }
2286
2287 /*--- parse: Parse a SIP message ----*/
2288 static void parse(struct sip_request *req)
2289 {
2290         /* Divide fields by NULL's */
2291         char *c;
2292         int f = 0;
2293         c = req->data;
2294
2295         /* First header starts immediately */
2296         req->header[f] = c;
2297         while(*c) {
2298                 if (*c == '\n') {
2299                         /* We've got a new header */
2300                         *c = 0;
2301
2302 #if 0
2303                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2304 #endif                  
2305                         if (ast_strlen_zero(req->header[f])) {
2306                                 /* Line by itself means we're now in content */
2307                                 c++;
2308                                 break;
2309                         }
2310                         if (f >= SIP_MAX_HEADERS - 1) {
2311                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2312                         } else
2313                                 f++;
2314                         req->header[f] = c + 1;
2315                 } else if (*c == '\r') {
2316                         /* Ignore but eliminate \r's */
2317                         *c = 0;
2318                 }
2319                 c++;
2320         }
2321         /* Check for last header */
2322         if (!ast_strlen_zero(req->header[f])) 
2323                 f++;
2324         req->headers = f;
2325         /* Now we process any mime content */
2326         f = 0;
2327         req->line[f] = c;
2328         while(*c) {
2329                 if (*c == '\n') {
2330                         /* We've got a new line */
2331                         *c = 0;
2332 #if 0
2333                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2334 #endif                  
2335                         if (f >= SIP_MAX_LINES - 1) {
2336                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2337                         } else
2338                                 f++;
2339                         req->line[f] = c + 1;
2340                 } else if (*c == '\r') {
2341                         /* Ignore and eliminate \r's */
2342                         *c = 0;
2343                 }
2344                 c++;
2345         }
2346         /* Check for last line */
2347         if (!ast_strlen_zero(req->line[f])) 
2348                 f++;
2349         req->lines = f;
2350         if (*c) 
2351                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2352 }
2353
2354 /*--- process_sdp: Process SIP SDP ---*/
2355 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2356 {
2357         char *m;
2358         char *c;
2359         char *a;
2360         char host[258];
2361         int len = -1;
2362         int portno=0;
2363         int vportno=0;
2364         int peercapability, peernoncodeccapability;
2365         int vpeercapability=0, vpeernoncodeccapability=0;
2366         struct sockaddr_in sin;
2367         char *codecs;
2368         struct hostent *hp;
2369         struct ast_hostent ahp;
2370         int codec;
2371         int iterator;
2372         int sendonly = 0;
2373         int x;
2374
2375         /* Update our last rtprx when we receive an SDP, too */
2376         time(&p->lastrtprx);
2377
2378         /* Get codec and RTP info from SDP */
2379         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2380                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2381                 return -1;
2382         }
2383         m = get_sdp(req, "m");
2384         c = get_sdp(req, "c");
2385         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2386                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2387                 return -1;
2388         }
2389         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2390                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2391                 return -1;
2392         }
2393         /* XXX This could block for a long time, and block the main thread! XXX */
2394         hp = ast_gethostbyname(host, &ahp);
2395         if (!hp) {
2396                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2397                 return -1;
2398         }
2399         sdpLineNum_iterator_init(&iterator);
2400         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2401                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
2402                         portno = x;
2403                         /* Scan through the RTP payload types specified in a "m=" line: */
2404                         ast_rtp_pt_clear(p->rtp);
2405                         codecs = m + len;
2406                         while(!ast_strlen_zero(codecs)) {
2407                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2408                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2409                                         return -1;
2410                                 }
2411                                 if (sip_debug_test_pvt(p))
2412                                         ast_verbose("Found RTP audio format %d\n", codec);
2413                                 ast_rtp_set_m_type(p->rtp, codec);
2414                                 codecs += len;
2415                                 /* Skip over any whitespace */
2416                                 while(*codecs && (*codecs < 33)) codecs++;
2417                         }
2418                 }
2419                 if (p->vrtp)
2420                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2421
2422                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2423                         vportno = x;
2424                         /* Scan through the RTP payload types specified in a "m=" line: */
2425                         codecs = m + len;
2426                         while(!ast_strlen_zero(codecs)) {
2427                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2428                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2429                                         return -1;
2430                                 }
2431                                 if (sip_debug_test_pvt(p))
2432                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2433                                 ast_rtp_set_m_type(p->vrtp, codec);
2434                                 codecs += len;
2435                                 /* Skip over any whitespace */
2436                                 while(*codecs && (*codecs < 33)) codecs++;
2437                         }
2438                 }
2439         }
2440
2441         /* RTP addresses and ports for audio and video */
2442         sin.sin_family = AF_INET;
2443         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2444         /* Setup audio port number */
2445         sin.sin_port = htons(portno);
2446         if (p->rtp && sin.sin_port)
2447                 ast_rtp_set_peer(p->rtp, &sin);
2448         /* Setup video port number */
2449         sin.sin_port = htons(vportno);
2450         if (p->vrtp && sin.sin_port)
2451                 ast_rtp_set_peer(p->vrtp, &sin);
2452
2453         if (sipdebug)
2454                 ast_verbose("Peer RTP is at port %s:%d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2455
2456         /* Next, scan through each "a=rtpmap:" line, noting each
2457          * specified RTP payload type (with corresponding MIME subtype):
2458          */
2459         sdpLineNum_iterator_init(&iterator);
2460         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2461       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2462           if (!strcasecmp(a, "sendonly")) {
2463                 sendonly=1;
2464                 continue;
2465           }
2466           if (!strcasecmp(a, "sendrecv")) {
2467                 sendonly=0;
2468           }
2469           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2470           if (sip_debug_test_pvt(p))
2471                 ast_verbose("Found description format %s\n", mimeSubtype);
2472           /* Note: should really look at the 'freq' and '#chans' params too */
2473           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2474           if (p->vrtp)
2475                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2476         }
2477
2478         /* Now gather all of the codecs that were asked for: */
2479         ast_rtp_get_current_formats(p->rtp,
2480                                 &peercapability, &peernoncodeccapability);
2481         if (p->vrtp)
2482                 ast_rtp_get_current_formats(p->vrtp,
2483                                 &vpeercapability, &vpeernoncodeccapability);
2484         p->jointcapability = p->capability & (peercapability | vpeercapability);
2485         p->noncodeccapability = noncodeccapability & (peernoncodeccapability | vpeernoncodeccapability);
2486         
2487         if (sip_debug_test_pvt(p)) {
2488                 const unsigned slen=80;
2489                 char s1[slen], s2[slen], s3[slen], s4[slen];
2490
2491                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2492                         ast_getformatname_multiple(s1, slen, p->capability),
2493                         ast_getformatname_multiple(s2, slen, peercapability),
2494                         ast_getformatname_multiple(s3, slen, vpeercapability),
2495                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2496
2497                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2498                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2499                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2500                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2501         }
2502         if (!p->jointcapability) {
2503                 ast_log(LOG_WARNING, "No compatible codecs!\n");
2504                 return -1;
2505         }
2506         if (p->owner) {
2507                 if (!(p->owner->nativeformats & p->jointcapability)) {
2508                         const unsigned slen=80;
2509                         char s1[slen], s2[slen];
2510                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n", 
2511                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2512                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2513                         p->owner->nativeformats = sip_codec_choose(p->jointcapability);
2514                         ast_set_read_format(p->owner, p->owner->readformat);
2515                         ast_set_write_format(p->owner, p->owner->writeformat);
2516                 }
2517                 if (p->owner->bridge) {
2518                         /* Turn on/off music on hold if we are holding/unholding */
2519                         if (sin.sin_addr.s_addr && !sendonly) {
2520                                 ast_moh_stop(p->owner->bridge);
2521                         } else {
2522                                 ast_moh_start(p->owner->bridge, NULL);
2523                         }
2524                 }
2525         }
2526         return 0;
2527         
2528 }
2529
2530 /*--- add_header: Add header to SIP message */
2531 static int add_header(struct sip_request *req, char *var, char *value)
2532 {
2533         if (req->len >= sizeof(req->data) - 4) {
2534                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2535                 return -1;
2536         }
2537         if (req->lines) {
2538                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2539                 return -1;
2540         }
2541         req->header[req->headers] = req->data + req->len;
2542         snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2543         req->len += strlen(req->header[req->headers]);
2544         if (req->headers < SIP_MAX_HEADERS)
2545                 req->headers++;
2546         else {
2547                 ast_log(LOG_WARNING, "Out of header space\n");
2548                 return -1;
2549         }
2550         return 0;       
2551 }
2552
2553 /*--- add_blank_header: Add blank header to SIP message */
2554 static int add_blank_header(struct sip_request *req)
2555 {
2556         if (req->len >= sizeof(req->data) - 4) {
2557                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2558                 return -1;
2559         }
2560         if (req->lines) {
2561                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2562                 return -1;
2563         }
2564         req->header[req->headers] = req->data + req->len;
2565         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2566         req->len += strlen(req->header[req->headers]);
2567         if (req->headers < SIP_MAX_HEADERS)
2568                 req->headers++;
2569         else {
2570                 ast_log(LOG_WARNING, "Out of header space\n");
2571                 return -1;
2572         }
2573         return 0;       
2574 }
2575
2576 /*--- add_line: Add content (not header) to SIP message */
2577 static int add_line(struct sip_request *req, char *line)
2578 {
2579         if (req->len >= sizeof(req->data) - 4) {
2580                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2581                 return -1;
2582         }
2583         if (!req->lines) {
2584                 /* Add extra empty return */
2585                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2586                 req->len += strlen(req->data + req->len);
2587         }
2588         req->line[req->lines] = req->data + req->len;
2589         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2590         req->len += strlen(req->line[req->lines]);
2591         if (req->lines < SIP_MAX_LINES)
2592                 req->lines++;
2593         else {
2594                 ast_log(LOG_WARNING, "Out of line space\n");
2595                 return -1;
2596         }
2597         return 0;       
2598 }
2599
2600 /*--- copy_header: Copy one header field from one request to another */
2601 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2602 {
2603         char *tmp;
2604         tmp = get_header(orig, field);
2605         if (!ast_strlen_zero(tmp)) {
2606                 /* Add what we're responding to */
2607                 return add_header(req, field, tmp);
2608         }
2609         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2610         return -1;
2611 }
2612
2613 /*--- copy_all_header: Copy all headers from one request to another ---*/
2614 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2615 {
2616         char *tmp;
2617         int start = 0;
2618         int copied = 0;
2619         for (;;) {
2620                 tmp = __get_header(orig, field, &start);
2621                 if (!ast_strlen_zero(tmp)) {
2622                         /* Add what we're responding to */
2623                         add_header(req, field, tmp);
2624                         copied++;
2625                 } else
2626                         break;
2627         }
2628         return copied ? 0 : -1;
2629 }
2630
2631 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2632 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2633 {
2634         char *tmp;
2635         int start = 0;
2636         int copied = 0;
2637         char new[256];
2638         for (;;) {
2639                 tmp = __get_header(orig, field, &start);
2640                 if (!ast_strlen_zero(tmp)) {
2641                         if (!copied && p->nat) {
2642 #ifdef THE_SIP_AUTHORS_CAN_SUCK_MY_GONADS
2643                                 /* SLD: FIXME: Nice try, but the received= should not have a port */
2644                                 /* SLD: FIXME: See RFC2543 BNF in Section 6.40.5 */
2645                                 /* MAS: Yup, RFC says you can't do it.  No way to indicate PAT...
2646                                    good job fellas. */
2647                                 if (ntohs(p->recv.sin_port) != DEFAULT_SIP_PORT)
2648                                         snprintf(new, sizeof(new), "%s;received=%s:%d", tmp, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
2649                                 else
2650 #endif                          
2651                                         snprintf(new, sizeof(new), "%s;received=%s", tmp, inet_ntoa(p->recv.sin_addr));
2652                                 add_header(req, field, new);
2653                         } else {
2654                                 /* Add what we're responding to */
2655                                 add_header(req, field, tmp);
2656                         }
2657                         copied++;
2658                 } else
2659                         break;
2660         }
2661         if (!copied) {
2662                 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2663                 return -1;
2664         }
2665         return 0;
2666 }
2667
2668 /*--- add_route: Add route header into request per learned route ---*/
2669 static void add_route(struct sip_request *req, struct sip_route *route)
2670 {
2671         char r[256], *p;
2672         int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2673
2674         if (!route) return;
2675
2676         p = r;
2677         while (route) {
2678                 n = strlen(route->hop);
2679                 if ((n+3)>rem) break;
2680                 if (p != r) {
2681                         *p++ = ',';
2682                         --rem;
2683                 }
2684                 *p++ = '<';
2685                 strcpy(p, route->hop);  p += n;
2686                 *p++ = '>';
2687                 rem -= (n+2);
2688                 route = route->next;
2689         }
2690         *p = '\0';
2691         add_header(req, "Route", r);
2692 }
2693
2694 /*--- set_destination: Set destination from SIP URI ---*/
2695 static void set_destination(struct sip_pvt *p, char *uri)
2696 {
2697         char *h, *maddr, hostname[256];
2698         int port, hn;
2699         struct hostent *hp;
2700         struct ast_hostent ahp;
2701
2702         /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2703         /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2704
2705         if (sip_debug_test_pvt(p))
2706                 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2707
2708         /* Find and parse hostname */
2709         h = strchr(uri, '@');
2710         if (h)
2711                 ++h;
2712         else {
2713                 h = uri;
2714                 if (strncmp(h, "sip:", 4) == 0)
2715                         h += 4;
2716                 else if (strncmp(h, "sips:", 5) == 0)
2717                         h += 5;
2718         }
2719         hn = strcspn(h, ":;>");
2720         if (hn>255) hn=255;
2721         strncpy(hostname, h, hn);  hostname[hn] = '\0';
2722         h+=hn;
2723
2724         /* Is "port" present? if not default to 5060 */
2725         if (*h == ':') {
2726                 /* Parse port */
2727                 ++h;
2728                 port = strtol(h, &h, 10);
2729         }
2730         else
2731                 port = 5060;
2732
2733         /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
2734         maddr = strstr(h, "maddr=");
2735         if (maddr) {
2736                 maddr += 6;
2737                 hn = strspn(maddr, "0123456789.");
2738                 if (hn>255) hn=255;
2739                 strncpy(hostname, maddr, hn);  hostname[hn] = '\0';
2740         }
2741         
2742         hp = ast_gethostbyname(hostname, &ahp);
2743         if (hp == NULL)  {
2744                 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
2745                 return;
2746         }
2747         p->sa.sin_family = AF_INET;
2748         memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
2749         p->sa.sin_port = htons(port);
2750         if (sip_debug_test_pvt(p))
2751                 ast_verbose("set_destination: set destination to %s, port %d\n", inet_ntoa(p->sa.sin_addr), port);
2752 }
2753
2754 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
2755 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
2756 {
2757         /* Initialize a response */
2758         if (req->headers || req->len) {
2759                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2760                 return -1;
2761         }
2762         req->header[req->headers] = req->data + req->len;
2763         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
2764         req->len += strlen(req->header[req->headers]);
2765         if (req->headers < SIP_MAX_HEADERS)
2766                 req->headers++;
2767         else
2768                 ast_log(LOG_WARNING, "Out of header space\n");
2769         return 0;
2770 }
2771
2772 /*--- init_req: Initialize SIP request ---*/
2773 static int init_req(struct sip_request *req, char *resp, char *recip)
2774 {
2775         /* Initialize a response */
2776         if (req->headers || req->len) {
2777                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2778                 return -1;
2779         }
2780         req->header[req->headers] = req->data + req->len;
2781         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
2782         req->len += strlen(req->header[req->headers]);
2783         if (req->headers < SIP_MAX_HEADERS)
2784                 req->headers++;
2785         else
2786                 ast_log(LOG_WARNING, "Out of header space\n");
2787         return 0;
2788 }
2789
2790
2791 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
2792 {
2793         char newto[256] = "", *ot;
2794         memset(resp, 0, sizeof(*resp));
2795         init_resp(resp, msg, req);
2796         copy_via_headers(p, resp, req, "Via");
2797         if (msg[0] == '2') copy_all_header(resp, req, "Record-Route");
2798         copy_header(resp, req, "From");
2799         ot = get_header(req, "To");
2800         if (!strstr(ot, "tag=")) {
2801                 /* Add the proper tag if we don't have it already.  If they have specified
2802                    their tag, use it.  Otherwise, use our own tag */
2803                 if (!ast_strlen_zero(p->theirtag) && p->outgoing)
2804                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
2805                 else if (p->tag && !p->outgoing)
2806                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
2807                 else
2808                         strncpy(newto, ot, sizeof(newto) - 1);
2809                 ot = newto;
2810         }
2811         add_header(resp, "To", ot);
2812         copy_header(resp, req, "Call-ID");
2813         copy_header(resp, req, "CSeq");
2814         add_header(resp, "User-Agent", useragent);
2815         add_header(resp, "Allow", ALLOWED_METHODS);
2816         if (p->expiry) {
2817                 /* For registration responses, we also need expiry and
2818                    contact info */
2819                 char contact[256];
2820                 char tmp[256];
2821                 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
2822                 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
2823                 add_header(resp, "Expires", tmp);
2824                 add_header(resp, "Contact", contact);
2825         } else {
2826                 add_header(resp, "Contact", p->our_contact);
2827         }
2828         return 0;
2829 }
2830
2831 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno, int newbranch)
2832 {
2833         struct sip_request *orig = &p->initreq;
2834         char stripped[80] ="";
2835         char tmp[80];
2836         char newto[256];
2837         char *c, *n;
2838         char *ot, *of;
2839
2840         memset(req, 0, sizeof(struct sip_request));
2841         
2842         snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
2843         
2844         if (!seqno) {
2845                 p->ocseq++;
2846                 seqno = p->ocseq;
2847         }
2848         
2849         if (newbranch) {
2850                 p->branch ^= rand();
2851                 snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
2852         }
2853
2854         if (!ast_strlen_zero(p->uri)) {
2855                 c = p->uri;
2856         } else {
2857                 if (p->outgoing)
2858                         strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
2859                 else
2860                         strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
2861                 
2862                 c = strchr(stripped, '<');
2863                 if (c) 
2864                         c++;
2865                 else
2866                         c = stripped;
2867                 n = strchr(c, '>');
2868                 if (n)
2869                         *n = '\0';
2870                 n = strchr(c, ';');
2871                 if (n)
2872                         *n = '\0';
2873         }       
2874         init_req(req, msg, c);
2875
2876         snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
2877
2878         add_header(req, "Via", p->via);
2879         if (p->route) {
2880                 set_destination(p, p->route->hop);
2881                 add_route(req, p->route->next);
2882         }
2883
2884         ot = get_header(orig, "To");
2885         of = get_header(orig, "From");
2886
2887         /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
2888            as our original request, including tag (or presumably lack thereof) */
2889         if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
2890                 /* Add the proper tag if we don't have it already.  If they have specified
2891                    their tag, use it.  Otherwise, use our own tag */
2892                 if (p->outgoing && !ast_strlen_zero(p->theirtag))
2893                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
2894                 else if (!p->outgoing)
2895                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
2896                 else
2897                         snprintf(newto, sizeof(newto), "%s", ot);
2898                 ot = newto;
2899         }
2900
2901         if (p->outgoing) {
2902                 add_header(req, "From", of);
2903                 add_header(req, "To", ot);
2904         } else {
2905                 add_header(req, "From", ot);
2906                 add_header(req, "To", of);
2907         }
2908         add_header(req, "Contact", p->our_contact);
2909         copy_header(req, orig, "Call-ID");
2910         add_header(req, "CSeq", tmp);
2911
2912         add_header(req, "User-Agent", useragent);
2913         return 0;
2914 }
2915
2916 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
2917 {
2918         struct sip_request resp;
2919         int seqno = 0;
2920         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
2921                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
2922                 return -1;
2923         }
2924         respprep(&resp, p, msg, req);
2925         add_header(&resp, "Content-Length", "0");
2926         add_blank_header(&resp);
2927         return send_response(p, &resp, reliable, seqno);
2928 }
2929
2930 /*--- transmit_response: Transmit response, no retransmits */
2931 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req) 
2932 {
2933         return __transmit_response(p, msg, req, 0);
2934 }
2935
2936 /*--- transmit_response: Transmit response, Make sure you get a reply */
2937 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal)
2938 {
2939         return __transmit_response(p, msg, req, fatal ? 2 : 1);
2940 }
2941
2942 /*--- append_date: Append date to SIP message ---*/
2943 static void append_date(struct sip_request *req)
2944 {
2945         char tmpdat[256];
2946         struct tm tm;
2947         time_t t;
2948         time(&t);
2949         gmtime_r(&t, &tm);
2950         strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
2951         add_header(req, "Date", tmpdat);
2952 }
2953
2954 /*--- transmit_response_with_date: Append date and content length before transmitting response ---*/
2955 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
2956 {
2957         struct sip_request resp;
2958         respprep(&resp, p, msg, req);
2959         append_date(&resp);
2960         add_header(&resp, "Content-Length", "0");
2961         add_blank_header(&resp);
2962         return send_response(p, &resp, 0, 0);
2963 }
2964
2965 /*--- transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
2966 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
2967 {
2968         struct sip_request resp;
2969         respprep(&resp, p, msg, req);
2970         add_header(&resp, "Accept", "application/sdp");
2971         add_header(&resp, "Content-Length", "0");
2972         add_blank_header(&resp);
2973         return send_response(p, &resp, reliable, 0);
2974 }
2975
2976 /* transmit_response_with_auth: Respond with authorization request */
2977 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable)
2978 {
2979         struct sip_request resp;
2980         char tmp[256];
2981         int seqno = 0;
2982         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
2983                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
2984                 return -1;
2985         }
2986         snprintf(tmp, sizeof(tmp), "Digest realm=\"%s\", nonce=\"%s\"", global_realm, randdata);
2987         respprep(&resp, p, msg, req);
2988         add_header(&resp, "Proxy-Authenticate", tmp);
2989         add_header(&resp, "Content-Length", "0");
2990         add_blank_header(&resp);
2991         return send_response(p, &resp, reliable, seqno);
2992 }
2993
2994 /*--- add_text: Add text body to SIP message ---*/
2995 static int add_text(struct sip_request *req, char *text)
2996 {
2997         /* XXX Convert \n's to \r\n's XXX */
2998         int len = strlen(text);
2999         char clen[256];
3000         snprintf(clen, sizeof(clen), "%d", len);
3001         add_header(req, "Content-Type", "text/plain");
3002         add_header(req, "Content-Length", clen);
3003         add_line(req, text);
3004         return 0;
3005 }
3006
3007 /*--- add_digit: add DTMF INFO tone to sip message ---*/
3008 /* Always adds default duration 250 ms, regardless of what came in over the line */
3009 static int add_digit(struct sip_request *req, char digit)
3010 {
3011         char tmp[256];
3012         int len;
3013         char clen[256];
3014         snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
3015         len = strlen(tmp);
3016         snprintf(clen, sizeof(clen), "%d", len);
3017         add_header(req, "Content-Type", "application/dtmf-relay");
3018         add_header(req, "Content-Length", clen);
3019         add_line(req, tmp);
3020         return 0;
3021 }
3022
3023 /*--- add_sdp: Add Session Description Protocol message ---*/
3024 static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
3025 {
3026         int len;
3027         int codec;
3028         int alreadysent = 0;
3029         char costr[80];
3030         struct sockaddr_in sin;
3031         struct sockaddr_in vsin;
3032         struct sip_codec_pref *cur;
3033         char v[256] = "";
3034         char s[256] = "";
3035         char o[256] = "";
3036         char c[256] = "";
3037         char t[256] = "";
3038         char m[256] = "";
3039         char m2[256] = "";
3040         char a[1024] = "";
3041         char a2[1024] = "";
3042         int x;
3043         int capability;
3044         struct sockaddr_in dest;
3045         struct sockaddr_in vdest = { 0, };
3046         /* XXX We break with the "recommendation" and send our IP, in order that our
3047                peer doesn't have to ast_gethostbyname() us XXX */
3048         len = 0;
3049         if (!p->rtp) {
3050                 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
3051                 return -1;
3052         }
3053         capability = p->jointcapability;
3054                 
3055         if (!p->sessionid) {
3056                 p->sessionid = getpid();
3057                 p->sessionversion = p->sessionid;
3058         } else
3059                 p->sessionversion++;
3060         ast_rtp_get_us(p->rtp, &sin);
3061         if (p->vrtp)
3062                 ast_rtp_get_us(p->vrtp, &vsin);
3063
3064         if (p->redirip.sin_addr.s_addr) {
3065                 dest.sin_port = p->redirip.sin_port;
3066                 dest.sin_addr = p->redirip.sin_addr;
3067                 if (p->redircodecs)
3068                         capability = p->redircodecs;
3069         } else {
3070                 dest.sin_addr = p->ourip;
3071                 dest.sin_port = sin.sin_port;
3072         }
3073
3074         /* Determine video destination */
3075         if (p->vrtp) {
3076                 if (p->vredirip.sin_addr.s_addr) {
3077                         vdest.sin_port = p->vredirip.sin_port;
3078                         vdest.sin_addr = p->vredirip.sin_addr;
3079                 } else {
3080                         vdest.sin_addr = p->ourip;
3081                         vdest.sin_port = vsin.sin_port;
3082                 }
3083         }
3084         if (sip_debug_test_pvt(p))
3085                 ast_verbose("We're at %s port %d\n", inet_ntoa(p->ourip), ntohs(sin.sin_port)); 
3086         if (sip_debug_test_pvt(p) && p->vrtp)
3087                 ast_verbose("Video is at %s port %d\n", inet_ntoa(p->ourip), ntohs(vsin.sin_port));     
3088         snprintf(v, sizeof(v), "v=0\r\n");
3089         snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, inet_ntoa(dest.sin_addr));
3090         snprintf(s, sizeof(s), "s=session\r\n");
3091         snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", inet_ntoa(dest.sin_addr));
3092         snprintf(t, sizeof(t), "t=0 0\r\n");
3093         snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
3094         snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
3095         if (capability & p->prefcodec) {
3096                 if (sip_debug_test_pvt(p))
3097                         ast_verbose("Answering/Requesting with root capability %d\n", p->prefcodec);
3098                 codec = ast_rtp_lookup_code(p->rtp, 1, p->prefcodec);
3099                 if (codec > -1) {
3100                         snprintf(costr, sizeof(costr), " %d", codec);
3101                         if (p->prefcodec <= AST_FORMAT_MAX_AUDIO) {
3102                                 strncat(m, costr, sizeof(m) - strlen(m));
3103                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3104                                 strncat(a, costr, sizeof(a));
3105                         } else {
3106                                 strncat(m2, costr, sizeof(m2) - strlen(m2));
3107                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3108                                 strncat(a2, costr, sizeof(a2));
3109                         }
3110                 }
3111                 alreadysent |= p->prefcodec;
3112         }
3113         /* Start by sending our preferred codecs */
3114         cur = prefs;
3115         while(cur) {
3116                 if ((capability & cur->codec) && !(alreadysent & cur->codec)) {
3117                         if (sip_debug_test_pvt(p))
3118                                 ast_verbose("Answering with preferred capability 0x%x(%s)\n", cur->codec, ast_getformatname(cur->codec));
3119                         codec = ast_rtp_lookup_code(p->rtp, 1, cur->codec);
3120                         if (codec > -1) {
3121                                 snprintf(costr, sizeof(costr), " %d", codec);
3122                                 if (cur->codec <= AST_FORMAT_MAX_AUDIO) {
3123                                         strncat(m, costr, sizeof(m) - strlen(m));
3124                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
3125                                         strncat(a, costr, sizeof(a));
3126                                 } else {
3127                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
3128                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
3129                                         strncat(a2, costr, sizeof(a2));
3130                                 }
3131                         }
3132                 }
3133                 alreadysent |= cur->codec;
3134                 cur = cur->next;
3135         }
3136         /* Now send any other common codecs, and non-codec formats: */
3137         for (x = 1; x <= (videosupport ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) {
3138                 if ((capability & x) && !(alreadysent & x)) {
3139                         if (sip_debug_test_pvt(p))
3140                                 ast_verbose("Answering with capability 0x%x(%s)\n", x, ast_getformatname(x));
3141                         codec = ast_rtp_lookup_code(p->rtp, 1, x);
3142                         if (codec > -1) {
3143                                 snprintf(costr, sizeof(costr), " %d", codec);
3144                                 if (x <= AST_FORMAT_MAX_AUDIO) {
3145                                         strncat(m, costr, sizeof(m) - strlen(m));
3146                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
3147                                         strncat(a, costr, sizeof(a) - strlen(a));
3148                                 } else {
3149                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
3150                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
3151                                         strncat(a2, costr, sizeof(a2) - strlen(a2));
3152                                 }
3153                         }
3154                 }
3155         }
3156         for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
3157                 if (p->noncodeccapability & x) {
3158                         if (sip_debug_test_pvt(p))
3159                                 ast_verbose("Answering with non-codec capability 0x%x(%s)\n", x, ast_getformatname(x));
3160                         codec = ast_rtp_lookup_code(p->rtp, 0, x);
3161                         if (codec > -1) {
3162                                 snprintf(costr, sizeof(costr), " %d", codec);
3163                                 strncat(m, costr, sizeof(m) - strlen(m));
3164                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
3165                                 strncat(a, costr, sizeof(a) - strlen(a));
3166                                 if (x == AST_RTP_DTMF) {
3167                                   /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
3168                                   snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n",
3169                                            codec);
3170                                   strncat(a, costr, sizeof(a) - strlen(a));
3171                                 }
3172                         }
3173                 }
3174         }
3175         strncat(a, "a=silenceSupp:off - - - -\r\n", sizeof(a) - strlen(a));
3176         if (strlen(m) < sizeof(m) - 2)
3177                 strcat(m, "\r\n");
3178         if (strlen(m2) < sizeof(m2) - 2)
3179                 strcat(m2, "\r\n");
3180         if ((sizeof(m) <= strlen(m) - 2) || (sizeof(m2) <= strlen(m2) - 2) || (sizeof(a) == strlen(a)) || (sizeof(a2) == strlen(a2)))
3181                 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
3182         len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
3183         if ((p->vrtp) && (capability & VIDEO_CODEC_MASK)) /* only if video response is appropriate */
3184                 len += strlen(m2) + strlen(a2);
3185         snprintf(costr, sizeof(costr), "%d", len);
3186         add_header(resp, "Content-Type", "application/sdp");
3187         add_header(resp, "Content-Length", costr);
3188         add_line(resp, v);
3189         add_line(resp, o);
3190         add_line(resp, s);
3191         add_line(resp, c);
3192         add_line(resp, t);
3193         add_line(resp, m);
3194         add_line(resp, a);
3195         if ((p->vrtp) && (capability & VIDEO_CODEC_MASK)) { /* only if video response is appropriate */
3196                 add_line(resp, m2);
3197                 add_line(resp, a2);
3198         }
3199         /* Update lastrtprx when we send our SDP */
3200         time(&p->lastrtprx);
3201         return 0;
3202 }
3203
3204 /*--- copy_request: copy SIP request (mostly used to save request for responses) ---*/
3205 static void copy_request(struct sip_request *dst,struct sip_request *src)
3206 {
3207         long offset;
3208         int x;
3209         offset = ((void *)dst) - ((void *)src);
3210         /* First copy stuff */
3211         memcpy(dst, src, sizeof(*dst));
3212         /* Now fix pointer arithmetic */
3213         for (x=0;x<src->headers;x++)
3214                 dst->header[x] += offset;
3215         for (x=0;x<src->lines;x++)
3216                 dst->line[x] += offset;
3217 }
3218
3219 /*--- transmit_response_with_sdp: Used for 200 OK ---*/
3220 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
3221 {
3222         struct sip_request resp;
3223         int seqno;
3224         if (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1) {
3225                 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
3226                 return -1;
3227         }
3228         respprep(&resp, p, msg, req);
3229         add_sdp(&resp, p);
3230         return send_response(p, &resp, retrans, seqno);
3231 }
3232
3233 /*--- determine_firstline_parts: parse first line of incoming SIP request */
3234 static int determine_firstline_parts( struct sip_request *req ) {
3235
3236   char *e, *cmd;
3237   int len;
3238   
3239   cmd= req->header[0];
3240   while(*cmd && (*cmd < 33)) {
3241     cmd++;
3242   }
3243   if (!*cmd) {
3244     return -1;
3245   }
3246   e= cmd;
3247   while(*e && (*e > 32)) {
3248     e++;
3249   }
3250   /* Get the command */
3251   if (*e) {
3252     *e = '\0';
3253     e++;
3254   }
3255   req->rlPart1= cmd;
3256   while( *e && ( *e < 33 ) ) {
3257     e++; 
3258   }
3259   if( !*e ) {
3260     return -1;
3261   }
3262     
3263   if ( !strcasecmp(cmd, "SIP/2.0") ) {
3264     /* We have a response */
3265     req->rlPart2= e;
3266     len= strlen( req->rlPart2 );
3267     if( len < 2 ) { return -1; }
3268     e+= len - 1;
3269     while( *e && *e<33 ) {
3270       e--; 
3271     }
3272     *(++e)= '\0';
3273   } else {
3274     /* We have a request */
3275     if( *e == '<' ) { 
3276       e++;
3277       if( !*e ) { return -1; }  
3278     }
3279     req->rlPart2= e;
3280     if( ( e= strrchr( req->rlPart2, 'S' ) ) == NULL ) {
3281       return -1;
3282     }
3283     while( isspace( *(--e) ) ) {}
3284     if( *e == '>' ) {
3285       *e= '\0';
3286     } else {
3287       *(++e)= '\0';
3288     }
3289   }
3290   return 1;
3291 }
3292
3293 /* transmit_reinvite_with_sdp: Transmit reinvite with SDP :-) ---*/
3294 /*   A re-invite is basically a new INVITE with the same CALL-ID and TAG as the
3295      INVITE that opened the SIP dialogue */
3296 static int transmit_reinvite_with_sdp(struct sip_pvt *p)
3297 {
3298         struct sip_request req;
3299         if (p->canreinvite == REINVITE_UPDATE)
3300                 reqprep(&req, p, "UPDATE", 0, 1);
3301         else 
3302                 reqprep(&req, p, "INVITE", 0, 1);
3303         
3304         add_header(&req, "Allow", ALLOWED_METHODS);
3305         add_sdp(&req, p);
3306         /* Use this as the basis */
3307         copy_request(&p->initreq, &req);
3308         parse(&p->initreq);
3309         if (sip_debug_test_pvt(p))
3310                 ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
3311         determine_firstline_parts(&p->initreq);
3312         p->lastinvite = p->ocseq;
3313         p->outgoing = 1;
3314         return send_request(p, &req, 1, p->ocseq);
3315 }
3316
3317 /*--- extract_uri: Check Contact: URI of SIP message ---*/
3318 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
3319 {
3320         char stripped[256]="";
3321         char *c, *n;
3322         strncpy(stripped, get_header(req, "Contact"), sizeof(stripped) - 1);
3323         c = strchr(stripped, '<');
3324         if (c) 
3325                 c++;
3326         else
3327                 c = stripped;
3328         n = strchr(c, '>');
3329         if (n)
3330                 *n = '\0';
3331         n = strchr(c, ';');
3332         if (n)
3333                 *n = '\0';
3334         if (c && !ast_strlen_zero(c))
3335                 strncpy(p->uri, c, sizeof(p->uri) - 1);
3336 }
3337
3338 /*--- build_contact: Build contact header - the contact header we send out ---*/
3339 static void build_contact(struct sip_pvt *p)
3340 {
3341         /* Construct Contact: header */
3342         if (ourport != 5060)
3343                 snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s@%s:%d>", p->exten, inet_ntoa(p->ourip), ourport);
3344         else
3345                 snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s@%s>", p->exten, inet_ntoa(p->ourip));
3346 }
3347
3348 /*--- initreqprep: Initiate SIP request to peer/user ---*/
3349 static void initreqprep(struct sip_request *req, struct sip_pvt *p, char *cmd, char *vxml_url)
3350 {
3351         char invite[256];
3352         char from[256];
3353         char to[256];
3354         char tmp[80];
3355         char cid[256];
3356         char *l = callerid, *n=NULL;
3357
3358         snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", cmd);
3359
3360         if (p->owner && p->owner->callerid) {
3361                 strcpy(cid, p->owner->callerid);
3362                 ast_callerid_parse(cid, &n, &l);
3363                 if (l) 
3364                         ast_shrink_phone_number(l);
3365                 if (!l || !ast_isphonenumber(l))
3366                                 l = callerid;
3367         }
3368         /* if user want's his callerid restricted */
3369         if (p->restrictcid) {
3370                 l = CALLERID_UNKNOWN;
3371                 n = l;
3372         }
3373         if (!n || ast_strlen_zero(n))
3374                 n = l;
3375         /* Allow user to be overridden */
3376         if (!ast_strlen_zero(p->fromuser))
3377                 l = p->fromuser;
3378
3379         if ((ourport != 5060) && ast_strlen_zero(p->fromdomain))
3380                 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);
3381         else
3382                 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);
3383
3384         if (!ast_strlen_zero(p->username)) {
3385                 if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) {
3386                         snprintf(invite, sizeof(invite), "sip:%s@%s:%d",p->username, p->tohost, ntohs(p->sa.sin_port));
3387                 } else {
3388                         snprintf(invite, sizeof(invite), "sip:%s@%s",p->username, p->tohost);
3389                 }
3390         } else if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) {
3391                 snprintf(invite, sizeof(invite), "sip:%s:%d", p->tohost, ntohs(p->sa.sin_port));
3392         } else {
3393                 snprintf(invite, sizeof(invite), "sip:%s", p->tohost);
3394         }
3395         strncpy(p->uri, invite, sizeof(p->uri) - 1);
3396         /* If there is a VXML URL append it to the SIP URL */
3397         if (vxml_url)
3398         {
3399                 snprintf(to, sizeof(to), "<%s>;%s", invite, vxml_url);
3400         }
3401         else
3402         {
3403                 snprintf(to, sizeof(to), "<%s>", invite );
3404         }
3405         memset(req, 0, sizeof(struct sip_request));
3406         init_req(req, cmd, invite);
3407         snprintf(tmp, sizeof(tmp), "%d %s", ++p->ocseq, cmd);
3408
3409         add_header(req, "Via", p->via);
3410         /* SLD: FIXME?: do Route: here too?  I think not cos this is the first request.
3411          * OTOH, then we won't have anything in p->route anyway */
3412         add_header(req, "From", from);
3413         strncpy(p->exten, l, sizeof(p->exten) - 1);
3414         build_contact(p);
3415         add_header(req, "To", to);
3416         add_header(req, "Contact", p->our_contact);
3417         add_header(req, "Call-ID", p->callid);
3418         add_header(req, "CSeq", tmp);
3419         add_header(req, "User-Agent", useragent);
3420 }
3421
3422         
3423 /*--- transmit_invite: Build REFER/INVITE/OPTIONS message and trasmit it ---*/
3424 static int transmit_invite(struct sip_pvt *p, char *cmd, int sdp, char *auth, char *authheader, char *vxml_url, char *distinctive_ring, int init)
3425 {
3426         struct sip_request req;
3427         
3428         if (init) {
3429                 /* Bump branch even on initial requests */
3430                 p->branch ^= rand();
3431                 snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
3432                 initreqprep(&req, p, cmd, vxml_url);
3433         } else
3434                 reqprep(&req, p, cmd, 0, 1);
3435                 
3436         if (auth)
3437                 add_header(&req, authheader, auth);
3438         append_date(&req);
3439         if (!strcasecmp(cmd, "REFER")) {
3440                 if (!ast_strlen_zero(p->refer_to))
3441                         add_header(&req, "Refer-To", p->refer_to);
3442                 if (!ast_strlen_zero(p->referred_by))
3443                         add_header(&req, "Referred-By", p->referred_by);
3444         }
3445         
3446         if (distinctive_ring && !ast_strlen_zero(distinctive_ring))
3447         {
3448                 add_header(&req, "Alert-info",distinctive_ring);
3449         }
3450         add_header(&req, "Allow", ALLOWED_METHODS);
3451         if (sdp) {
3452                 add_sdp(&req, p);
3453         } else {
3454                 add_header(&req, "Content-Length", "0");
3455                 add_blank_header(&req);
3456         }
3457
3458         if (!p->initreq.headers) {
3459                 /* Use this as the basis */
3460                 copy_request(&p->initreq, &req);
3461                 parse(&p->initreq);
3462                 if (sip_debug_test_pvt(p))
3463                         ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
3464                 determine_firstline_parts(&p->initreq);
3465         }
3466         p->lastinvite = p->ocseq;
3467         return send_request(p, &req, init ? 2 : 1, p->ocseq);
3468 }
3469
3470 /*--- transmit_state_notify: Used in the SUBSCRIBE notification subsystem ----*/
3471 static int transmit_state_notify(struct sip_pvt *p, int state, int full)
3472 {
3473         char tmp[4000];
3474         char from[256], to[256];
3475         char *t, *c, *a;
3476         char *mfrom, *mto;
3477         struct sip_request req;
3478         char clen[20];
3479         
3480         strncpy(from, get_header(&p->initreq, "From"), sizeof(from)-1);
3481
3482         c = ditch_braces(from);
3483         if (strncmp(c, "sip:", 4)) {
3484                 ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
3485                 return -1;
3486         }
3487         if ((a = strchr(c, ';'))) {
3488                 *a = '\0';
3489         }
3490         mfrom = c;
3491                 
3492         reqprep(&req, p, "NOTIFY", 0, 1);
3493
3494         if (p->subscribed == 1) {
3495             strncpy(to, get_header(&p->initreq, "To"), sizeof(to)-1);
3496
3497             c = ditch_braces(to);
3498             if (strncmp(c, "sip:", 4)) {
3499                 ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
3500                 return -1;
3501             }
3502             if ((a = strchr(c, ';'))) {
3503                 *a = '\0';
3504             }
3505             mto = c;
3506
3507             add_header(&req, "Content-Type", "application/xpidf+xml");
3508
3509             if ((state==AST_EXTENSION_UNAVAILABLE) || (state==AST_EXTENSION_BUSY))
3510                 state = 2;
3511             else if (state==AST_EXTENSION_INUSE)
3512                 state = 1;