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