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