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