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