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