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