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