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