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