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