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