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