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