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