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