Allow sip show users/peers to filter on regexp (bug #3222)
[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 temponly);
1115
1116 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1117 {
1118         struct ast_variable *var, *tmp=NULL;
1119         char iabuf[80];
1120         struct sip_peer *peer=NULL;
1121         time_t nowtime, regseconds;
1122         int dynamic=0;
1123         
1124         if (sin)
1125                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1126         if (peername) 
1127                 var = ast_load_realtime("sipfriends", "name", peername, NULL);
1128         else
1129                 var = ast_load_realtime("sipfriends", "ipaddr", iabuf, NULL);
1130         if (var) {
1131                 /* Make sure it's not a user only... */
1132                 peer = build_peer(peername, var, 1);
1133                 if (peer) {
1134                         /* Add some finishing touches, addresses, etc */
1135                         ast_set_flag(peer, SIP_REALTIME);
1136                         tmp = var;
1137                         while(tmp) {
1138                                 if (!strcasecmp(tmp->name, "type")) {
1139                                         if (strcasecmp(tmp->value, "friend") &&
1140                                                 strcasecmp(tmp->value, "peer")) {
1141                                                 /* Whoops, we weren't supposed to exist! */
1142                                                 sip_destroy_peer(peer);
1143                                                 peer = NULL;
1144                                                 break;
1145                                         } 
1146                                 } else if (!strcasecmp(tmp->name, "regseconds")) {
1147                                         if (sscanf(tmp->value, "%li", &regseconds) != 1)
1148                                                 regseconds = 0;
1149                                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
1150                                         inet_aton(tmp->value, &(peer->addr.sin_addr));
1151                                 } else if (!strcasecmp(tmp->name, "port")) {
1152                                         peer->addr.sin_port = htons(atoi(tmp->value));
1153                                 } else if (!strcasecmp(tmp->name, "host")) {
1154                                         if (!strcasecmp(tmp->value, "dynamic"))
1155                                                 dynamic = 1;
1156                                 }
1157                                 tmp = tmp->next;
1158                         }
1159                         if (peer && dynamic) {
1160                                 time(&nowtime);
1161                                 if ((nowtime - regseconds) > 0) {
1162                                         memset(&peer->addr, 0, sizeof(peer->addr));
1163                                         if (option_debug)
1164                                                 ast_log(LOG_DEBUG, "Bah, we're expired (%ld/%ld/%ld)!\n", nowtime - regseconds, regseconds, nowtime);
1165                                 }
1166                         }
1167                 }
1168                 ast_destroy_realtime(var);
1169         }
1170         if (peer) {
1171                 /* Destroy, so when our caller unrefs, it will disappear */
1172                 ASTOBJ_DESTROY(peer, sip_destroy_peer);
1173         }
1174         return peer;
1175 }
1176
1177 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1178 {
1179         /* We know name is the first field, so we can cast */
1180         struct sip_peer *p = (struct sip_peer *)name;
1181         return  !(!inaddrcmp(&p->addr, sin) || 
1182                                         (ast_test_flag(p, SIP_INSECURE) &&
1183                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1184 }
1185
1186 /*--- find_peer: Locate peer by name or ip address */
1187 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin)
1188 {
1189         struct sip_peer *p = NULL;
1190
1191         if (peer)
1192                 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1193         else
1194                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1195
1196         if (!p) {
1197                 p = realtime_peer(peer, sin);
1198         }
1199
1200         return(p);
1201 }
1202
1203 static void sip_destroy_user(struct sip_user *user)
1204 {
1205         ast_free_ha(user->ha);
1206         if(user->vars) {
1207                 ast_destroy_realtime(user->vars);
1208                 user->vars = NULL;
1209         }
1210         if (ast_test_flag(user, SIP_REALTIME))
1211                 ruserobjs--;
1212         else
1213                 suserobjs--;
1214         free(user);
1215 }
1216
1217 static struct sip_user *build_user(const char *name, struct ast_variable *v);
1218 static struct sip_user *realtime_user(const char *username)
1219 {
1220         struct ast_variable *var;
1221         struct ast_variable *tmp;
1222         struct sip_user *user=NULL;
1223         var = ast_load_realtime("sipfriends", "name", username, NULL);
1224         if (var) {
1225                 /* Make sure it's not a user only... */
1226                 user = build_user(username, var);
1227                 if (user) {
1228                         /* Move counter from s to r... */
1229                         suserobjs--;
1230                         ruserobjs++;
1231                         /* Add some finishing touches, addresses, etc */
1232                         ast_set_flag(user, SIP_REALTIME);       
1233                         tmp = var;
1234                         while(tmp) {
1235                                 if (!strcasecmp(tmp->name, "type")) {
1236                                         if (strcasecmp(tmp->value, "friend") &&
1237                                                 strcasecmp(tmp->value, "user")) {
1238                                                 /* Whoops, we weren't supposed to exist! */
1239                                                 sip_destroy_user(user);
1240                                                 user = NULL;
1241                                                 break;
1242                                         } 
1243                                 }
1244                                 tmp = tmp->next;
1245                         }
1246                 }
1247                 ast_destroy_realtime(var);
1248         }
1249         if (user) {
1250                 /* Reference and destroy, so when our caller unrefs, we disappear */
1251                 ASTOBJ_REF(user);
1252                 ASTOBJ_DESTROY(user, sip_destroy_user);
1253         }
1254         return user;
1255 }
1256
1257 /*--- find_user: Locate user by name */
1258 static struct sip_user *find_user(const char *name)
1259 {
1260         struct sip_user *u = NULL;
1261         u = ASTOBJ_CONTAINER_FIND(&userl,name);
1262         if (!u) {
1263                 u = realtime_user(name);
1264         }
1265         return(u);
1266 }
1267
1268 /*--- create_addr: create address structure from peer definition ---*/
1269 /*      Or, if peer not found, find it in the global DNS */
1270 /*      returns TRUE on failure, FALSE on success */
1271 static int create_addr(struct sip_pvt *r, char *opeer)
1272 {
1273         struct hostent *hp;
1274         struct ast_hostent ahp;
1275         struct sip_peer *p;
1276         int found=0;
1277         char *port;
1278         char *callhost;
1279         int portno;
1280         char host[256], *hostn;
1281         char peer[256]="";
1282
1283         strncpy(peer, opeer, sizeof(peer) - 1);
1284         port = strchr(peer, ':');
1285         if (port) {
1286                 *port = '\0';
1287                 port++;
1288         }
1289         r->sa.sin_family = AF_INET;
1290         p = find_peer(peer, NULL);
1291
1292         if (p) {
1293                         found++;
1294                         ast_copy_flags(r, p, SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE | SIP_INSECURE);
1295                         r->capability = p->capability;
1296                         if (r->rtp) {
1297                                 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1298                                 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1299                         }
1300                         if (r->vrtp) {
1301                                 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1302                                 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1303                         }
1304                         strncpy(r->peername, p->username, sizeof(r->peername)-1);
1305                         strncpy(r->authname, p->username, sizeof(r->authname)-1);
1306                         strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1307                         strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1308                         strncpy(r->username, p->username, sizeof(r->username)-1);
1309                         strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1310                         strncpy(r->fullcontact, p->fullcontact, sizeof(r->fullcontact)-1);
1311                         if (!r->initreq.headers && !ast_strlen_zero(p->fromdomain)) {
1312                                 if ((callhost = strchr(r->callid, '@'))) {
1313                                         strncpy(callhost + 1, p->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1314                                 }
1315                         }
1316                         if (ast_strlen_zero(r->tohost)) {
1317                                 if (p->addr.sin_addr.s_addr)
1318                                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->addr.sin_addr);
1319                                 else
1320                                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->defaddr.sin_addr);
1321                         }
1322                         if (!ast_strlen_zero(p->fromdomain))
1323                                 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1324                         if (!ast_strlen_zero(p->fromuser))
1325                                 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1326                         r->maxtime = p->maxms;
1327                         r->callgroup = p->callgroup;
1328                         r->pickupgroup = p->pickupgroup;
1329                         if (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833)
1330                                 r->noncodeccapability |= AST_RTP_DTMF;
1331                         else
1332                                 r->noncodeccapability &= ~AST_RTP_DTMF;
1333                         strncpy(r->context, p->context,sizeof(r->context)-1);
1334                         if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1335                                 (!p->maxms || ((p->lastms >= 0)  && (p->lastms <= p->maxms)))) {
1336                                 if (p->addr.sin_addr.s_addr) {
1337                                         r->sa.sin_addr = p->addr.sin_addr;
1338                                         r->sa.sin_port = p->addr.sin_port;
1339                                 } else {
1340                                         r->sa.sin_addr = p->defaddr.sin_addr;
1341                                         r->sa.sin_port = p->defaddr.sin_port;
1342                                 }
1343                                 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1344                         } else {
1345                                 ASTOBJ_UNREF(p,sip_destroy_peer);
1346                         }
1347         }
1348         if (!p && !found) {
1349                 hostn = peer;
1350                 if (port)
1351                         portno = atoi(port);
1352                 else
1353                         portno = DEFAULT_SIP_PORT;
1354                 if (srvlookup) {
1355                         char service[256];
1356                         int tportno;
1357                         int ret;
1358                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1359                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1360                         if (ret > 0) {
1361                                 hostn = host;
1362                                 portno = tportno;
1363                         }
1364                 }
1365                 hp = ast_gethostbyname(hostn, &ahp);
1366                 if (hp) {
1367                         strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1368                         memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1369                         r->sa.sin_port = htons(portno);
1370                         memcpy(&r->recv, &r->sa, sizeof(r->recv));
1371                         return 0;
1372                 } else {
1373                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1374                         return -1;
1375                 }
1376         } else if (!p)
1377                 return -1;
1378         else {
1379                 ASTOBJ_UNREF(p,sip_destroy_peer);
1380                 return 0;
1381         }
1382 }
1383
1384 /*--- auto_congest: Scheduled congestion on a call ---*/
1385 static int auto_congest(void *nothing)
1386 {
1387         struct sip_pvt *p = nothing;
1388         ast_mutex_lock(&p->lock);
1389         p->initid = -1;
1390         if (p->owner) {
1391                 if (!ast_mutex_trylock(&p->owner->lock)) {
1392                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1393                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1394                         ast_mutex_unlock(&p->owner->lock);
1395                 }
1396         }
1397         ast_mutex_unlock(&p->lock);
1398         return 0;
1399 }
1400
1401
1402
1403
1404 /*--- sip_call: Initiate SIP call from PBX ---*/
1405 /*      used from the dial() application      */
1406 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1407 {
1408         int res;
1409         struct sip_pvt *p;
1410         char *vxml_url = NULL;
1411         char *distinctive_ring = NULL;
1412         char *osptoken = NULL;
1413 #ifdef OSP_SUPPORT
1414         char *osphandle = NULL;
1415 #endif  
1416         struct varshead *headp;
1417         struct ast_var_t *current;
1418         int addsipheaders = 0;
1419         
1420         p = ast->pvt->pvt;
1421         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1422                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1423                 return -1;
1424         }
1425         /* Check whether there is vxml_url, distinctive ring variables */
1426
1427         headp=&ast->varshead;
1428         AST_LIST_TRAVERSE(headp,current,entries) {
1429                 /* Check whether there is a VXML_URL variable */
1430                 if (!vxml_url && !strcasecmp(ast_var_name(current),"VXML_URL")) {
1431                         vxml_url = ast_var_value(current);
1432                 } else if (!distinctive_ring && !strcasecmp(ast_var_name(current),"ALERT_INFO")) {
1433                         /* Check whether there is a ALERT_INFO variable */
1434                         distinctive_ring = ast_var_value(current);
1435                 } else if (!addsipheaders && !strncasecmp(ast_var_name(current),"SIPADDHEADER",strlen("SIPADDHEADER"))) {
1436                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
1437                         addsipheaders = 1;
1438                 }
1439
1440                 
1441 #ifdef OSP_SUPPORT
1442                   else if (!osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1443                         osptoken = ast_var_value(current);
1444                 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1445                         osphandle = ast_var_value(current);
1446                 }
1447 #endif
1448         }
1449         
1450         res = 0;
1451         ast_set_flag(p, SIP_OUTGOING);
1452 #ifdef OSP_SUPPORT
1453         if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1454                 /* Force Disable OSP support */
1455                 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", osptoken, osphandle);
1456                 osptoken = NULL;
1457                 osphandle = NULL;
1458                 p->osphandle = -1;
1459         }
1460 #endif
1461         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1462         res = update_user_counter(p,INC_OUT_USE);
1463         if ( res != -1 ) {
1464                 p->callingpres = ast->cid.cid_pres;
1465                 p->jointcapability = p->capability;
1466                 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, addsipheaders, 1);
1467                 if (p->maxtime) {
1468                         /* Initialize auto-congest time */
1469                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1470                 }
1471         }
1472         return res;
1473 }
1474
1475 static void sip_registry_destroy(struct sip_registry *reg)
1476 {
1477         /* Really delete */
1478         if (reg->call) {
1479                 /* Clear registry before destroying to ensure
1480                    we don't get reentered trying to grab the registry lock */
1481                 reg->call->registry = NULL;
1482                 sip_destroy(reg->call);
1483         }
1484         if (reg->expire > -1)
1485                 ast_sched_del(sched, reg->expire);
1486         if (reg->timeout > -1)
1487                 ast_sched_del(sched, reg->timeout);
1488         regobjs--;
1489         free(reg);
1490         
1491 }
1492
1493 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
1494 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1495 {
1496         struct sip_pvt *cur, *prev = NULL;
1497         struct sip_pkt *cp;
1498         struct sip_history *hist;
1499
1500         if (sip_debug_test_pvt(p))
1501                 ast_verbose("Destroying call '%s'\n", p->callid);
1502         if (p->stateid > -1)
1503                 ast_extension_state_del(p->stateid, NULL);
1504         if (p->initid > -1)
1505                 ast_sched_del(sched, p->initid);
1506         if (p->autokillid > -1)
1507                 ast_sched_del(sched, p->autokillid);
1508
1509         if (p->rtp) {
1510                 ast_rtp_destroy(p->rtp);
1511         }
1512         if (p->vrtp) {
1513                 ast_rtp_destroy(p->vrtp);
1514         }
1515         if (p->route) {
1516                 free_old_route(p->route);
1517                 p->route = NULL;
1518         }
1519         if (p->registry) {
1520                 if (p->registry->call == p)
1521                         p->registry->call = NULL;
1522                 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
1523         }
1524         /* Unlink us from the owner if we have one */
1525         if (p->owner) {
1526                 if (lockowner)
1527                         ast_mutex_lock(&p->owner->lock);
1528                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1529                 p->owner->pvt->pvt = NULL;
1530                 if (lockowner)
1531                         ast_mutex_unlock(&p->owner->lock);
1532         }
1533         /* Clear history */
1534         while(p->history) {
1535                 hist = p->history;
1536                 p->history = p->history->next;
1537                 free(hist);
1538         }
1539         cur = iflist;
1540         while(cur) {
1541                 if (cur == p) {
1542                         if (prev)
1543                                 prev->next = cur->next;
1544                         else
1545                                 iflist = cur->next;
1546                         break;
1547                 }
1548                 prev = cur;
1549                 cur = cur->next;
1550         }
1551         if (!cur) {
1552                 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1553         } else {
1554                 if (p->initid > -1)
1555                         ast_sched_del(sched, p->initid);
1556                 while((cp = p->packets)) {
1557                         p->packets = p->packets->next;
1558                         if (cp->retransid > -1)
1559                                 ast_sched_del(sched, cp->retransid);
1560                         free(cp);
1561                 }
1562                 ast_mutex_destroy(&p->lock);
1563                 if(p->vars) {
1564                         ast_destroy_realtime(p->vars);
1565                         p->vars = NULL;
1566                 }
1567                 free(p);
1568         }
1569 }
1570
1571 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1572 /* Note: This is going to be replaced by app_groupcount */
1573 static int update_user_counter(struct sip_pvt *fup, int event)
1574 {
1575         char name[256] = "";
1576         struct sip_user *u;
1577         strncpy(name, fup->username, sizeof(name) - 1);
1578         u = find_user(name);
1579         if (!u) {
1580                 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1581                 return 0;
1582         }
1583         switch(event) {
1584                 /* incoming and outgoing affects the inUse counter */
1585                 case DEC_OUT_USE:
1586                 case DEC_IN_USE:
1587                         if ( u->inUse > 0 ) {
1588                                 u->inUse--;
1589                         } else {
1590                                 u->inUse = 0;
1591                         }
1592                         break;
1593                 case INC_IN_USE:
1594                 case INC_OUT_USE:
1595                         if (u->incominglimit > 0 ) {
1596                                 if (u->inUse >= u->incominglimit) {
1597                                         ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1598                                         /* inc inUse as well */
1599                                         if ( event == INC_OUT_USE ) {
1600                                                 u->inUse++;
1601                                         }
1602                                         ASTOBJ_UNREF(u,sip_destroy_user);
1603                                         return -1; 
1604                                 }
1605                         }
1606                         u->inUse++;
1607                         ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1608                         break;
1609                 /* we don't use these anymore
1610                 case DEC_OUT_USE:
1611                         if ( u->outUse > 0 ) {
1612                                 u->outUse--;
1613                         } else {
1614                                 u->outUse = 0;
1615                         }
1616                         break;
1617                 case INC_OUT_USE:
1618                         if ( u->outgoinglimit > 0 ) {
1619                                 if ( u->outUse >= u->outgoinglimit ) {
1620                                         ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1621                                         ast_mutex_unlock(&userl.lock);
1622                                         if (u->temponly) {
1623                                                 destroy_user(u);
1624                                         }
1625                                         return -1;
1626                                 }
1627                         }
1628                         u->outUse++;
1629                         break;
1630                 */
1631                 default:
1632                         ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1633         }
1634         ASTOBJ_UNREF(u,sip_destroy_user);
1635         return 0;
1636 }
1637
1638 /*--- sip_destroy: Destroy SIP call structure ---*/
1639 static void sip_destroy(struct sip_pvt *p)
1640 {
1641         ast_mutex_lock(&iflock);
1642         __sip_destroy(p, 1);
1643         ast_mutex_unlock(&iflock);
1644 }
1645
1646
1647 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1648
1649 static int hangup_sip2cause(int cause)
1650 {
1651 /* Possible values from causes.h
1652         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
1653         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
1654 */
1655
1656         switch(cause) {
1657                 case 404:       /* Not found */
1658                         return AST_CAUSE_UNALLOCATED;
1659                 case 483:       /* Too many hops */
1660                         return AST_CAUSE_FAILURE;
1661                 case 486:
1662                         return AST_CAUSE_BUSY;
1663                 default:
1664                         return AST_CAUSE_NORMAL;
1665         }
1666         /* Never reached */
1667         return 0;
1668 }
1669
1670 static char *hangup_cause2sip(int cause)
1671 {
1672         switch(cause)
1673         {
1674                 case AST_CAUSE_FAILURE:
1675                         return "500 Server internal failure";
1676                 case AST_CAUSE_CONGESTION:
1677                         return "503 Service Unavailable";
1678                 case AST_CAUSE_BUSY:
1679                         return "486 Busy";
1680                 default:
1681                         return NULL;
1682         }
1683         /* Never reached */
1684         return 0;
1685 }
1686
1687 /*--- sip_hangup: Hangup SIP call */
1688 static int sip_hangup(struct ast_channel *ast)
1689 {
1690         struct sip_pvt *p = ast->pvt->pvt;
1691         int needcancel = 0;
1692         struct ast_flags locflags = {0};
1693         if (option_debug)
1694                 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1695         if (!ast->pvt->pvt) {
1696                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1697                 return 0;
1698         }
1699         ast_mutex_lock(&p->lock);
1700 #ifdef OSP_SUPPORT
1701         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1702                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1703         }
1704 #endif  
1705         if (ast_test_flag(p, SIP_OUTGOING)) {
1706                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1707                 update_user_counter(p, DEC_OUT_USE);
1708         } else {
1709                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1710                 update_user_counter(p, DEC_IN_USE);
1711         }
1712         /* Determine how to disconnect */
1713         if (p->owner != ast) {
1714                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
1715                 ast_mutex_unlock(&p->lock);
1716                 return 0;
1717         }
1718         if (!ast || (ast->_state != AST_STATE_UP))
1719                 needcancel = 1;
1720         /* Disconnect */
1721         p = ast->pvt->pvt;
1722         if (p->vad) {
1723             ast_dsp_free(p->vad);
1724         }
1725         p->owner = NULL;
1726         ast->pvt->pvt = NULL;
1727
1728         ast_mutex_lock(&usecnt_lock);
1729         usecnt--;
1730         ast_mutex_unlock(&usecnt_lock);
1731         ast_update_use_count();
1732
1733         ast_set_flag(&locflags, SIP_NEEDDESTROY);       
1734         /* Start the process if it's not already started */
1735         if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
1736                 if (needcancel) {
1737                         if (ast_test_flag(p, SIP_OUTGOING)) {
1738                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1739                                 /* Actually don't destroy us yet, wait for the 487 on our original 
1740                                    INVITE, but do set an autodestruct just in case we never get it. */
1741                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
1742                                 sip_scheddestroy(p, 15000);
1743                                 if ( p->initid != -1 ) {
1744                                         /* channel still up - reverse dec of inUse counter
1745                                            only if the channel is not auto-congested */
1746                                         if (ast_test_flag(p, SIP_OUTGOING)) {
1747                                                 update_user_counter(p, INC_OUT_USE);
1748                                         }
1749                                         else {
1750                                                 update_user_counter(p, INC_IN_USE);
1751                                         }
1752                                 }
1753                         } else {
1754                                 char *res;
1755                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1756                                         transmit_response_reliable(p, res, &p->initreq, 1);
1757                                 } else 
1758                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1759                         }
1760                 } else {
1761                         if (!p->pendinginvite) {
1762                                 /* Send a hangup */
1763                                 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1764                         } else {
1765                                 /* Note we will need a BYE when this all settles out
1766                                    but we can't send one while we have "INVITE" outstanding. */
1767                                 ast_set_flag(p, SIP_PENDINGBYE);        
1768                                 ast_clear_flag(p, SIP_NEEDREINVITE);    
1769                         }
1770                 }
1771         }
1772         ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);        
1773         ast_mutex_unlock(&p->lock);
1774         return 0;
1775 }
1776
1777 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1778 static int sip_answer(struct ast_channel *ast)
1779 {
1780         int res = 0,fmt;
1781         char *codec;
1782         struct sip_pvt *p = ast->pvt->pvt;
1783
1784         ast_mutex_lock(&p->lock);
1785         if (ast->_state != AST_STATE_UP) {
1786 #ifdef OSP_SUPPORT      
1787                 time(&p->ospstart);
1788 #endif
1789         
1790                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1791                 if (codec) {
1792                         fmt=ast_getformatbyname(codec);
1793                         if (fmt) {
1794                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1795                                 if (p->jointcapability & fmt) {
1796                                         p->jointcapability &= fmt;
1797                                         p->capability &= fmt;
1798                                 } else
1799                                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
1800                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1801                 }
1802
1803                 ast_setstate(ast, AST_STATE_UP);
1804                 if (option_debug)
1805                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1806                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1807         }
1808         ast_mutex_unlock(&p->lock);
1809         return res;
1810 }
1811
1812 /*--- sip_write: Send response, support audio media ---*/
1813 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1814 {
1815         struct sip_pvt *p = ast->pvt->pvt;
1816         int res = 0;
1817         if (frame->frametype == AST_FRAME_VOICE) {
1818                 if (!(frame->subclass & ast->nativeformats)) {
1819                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1820                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1821                         return 0;
1822                 }
1823                 if (p) {
1824                         ast_mutex_lock(&p->lock);
1825                         if (p->rtp) {
1826                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1827                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1828                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
1829                                 }
1830                                 time(&p->lastrtptx);
1831                                 res =  ast_rtp_write(p->rtp, frame);
1832                         }
1833                         ast_mutex_unlock(&p->lock);
1834                 }
1835         } else if (frame->frametype == AST_FRAME_VIDEO) {
1836                 if (p) {
1837                         ast_mutex_lock(&p->lock);
1838                         if (p->vrtp) {
1839                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1840                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1841                                         ast_set_flag(p, SIP_PROGRESS_SENT);     
1842                                 }
1843                                 time(&p->lastrtptx);
1844                                 res =  ast_rtp_write(p->vrtp, frame);
1845                         }
1846                         ast_mutex_unlock(&p->lock);
1847                 }
1848         } else if (frame->frametype == AST_FRAME_IMAGE) {
1849                 return 0;
1850         } else {
1851                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1852                 return 0;
1853         }
1854
1855         return res;
1856 }
1857
1858 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
1859         Basically update any ->owner links ----*/
1860 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1861 {
1862         struct sip_pvt *p = newchan->pvt->pvt;
1863         ast_mutex_lock(&p->lock);
1864         if (p->owner != oldchan) {
1865                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1866                 ast_mutex_unlock(&p->lock);
1867                 return -1;
1868         }
1869         p->owner = newchan;
1870         ast_mutex_unlock(&p->lock);
1871         return 0;
1872 }
1873
1874 /*--- sip_senddigit: Send DTMF character on SIP channel */
1875 /*    within one call, we're able to transmit in many methods simultaneously */
1876 static int sip_senddigit(struct ast_channel *ast, char digit)
1877 {
1878         struct sip_pvt *p = ast->pvt->pvt;
1879         int res = 0;
1880         ast_mutex_lock(&p->lock);
1881         switch (ast_test_flag(p, SIP_DTMF)) {
1882         case SIP_DTMF_INFO:
1883                 transmit_info_with_digit(p, digit);
1884                 break;
1885         case SIP_DTMF_RFC2833:
1886                 if (p->rtp)
1887                         ast_rtp_senddigit(p->rtp, digit);
1888                 break;
1889         case SIP_DTMF_INBAND:
1890                 res = -1;
1891                 break;
1892         }
1893         ast_mutex_unlock(&p->lock);
1894         return res;
1895 }
1896
1897
1898 /*--- sip_transfer: Transfer SIP call */
1899 static int sip_transfer(struct ast_channel *ast, char *dest)
1900 {
1901         struct sip_pvt *p = ast->pvt->pvt;
1902         int res;
1903         ast_mutex_lock(&p->lock);
1904         res = transmit_refer(p, dest);
1905         ast_mutex_unlock(&p->lock);
1906         return res;
1907 }
1908
1909 /*--- sip_indicate: Play indication to user */
1910 /* With SIP a lot of indications is sent as messages, letting the device play
1911    the indication - busy signal, congestion etc */
1912 static int sip_indicate(struct ast_channel *ast, int condition)
1913 {
1914         struct sip_pvt *p = ast->pvt->pvt;
1915         int res = 0;
1916
1917         ast_mutex_lock(&p->lock);
1918         switch(condition) {
1919         case AST_CONTROL_RINGING:
1920                 if (ast->_state == AST_STATE_RING) {
1921                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
1922                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
1923                                 /* Send 180 ringing if out-of-band seems reasonable */
1924                                 transmit_response(p, "180 Ringing", &p->initreq);
1925                                 ast_set_flag(p, SIP_RINGING);
1926                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
1927                                         break;
1928                         } else {
1929                                 /* Well, if it's not reasonable, just send in-band */
1930                         }
1931                 }
1932                 res = -1;
1933                 break;
1934         case AST_CONTROL_BUSY:
1935                 if (ast->_state != AST_STATE_UP) {
1936                         transmit_response(p, "486 Busy Here", &p->initreq);
1937                         ast_set_flag(p, SIP_ALREADYGONE);       
1938                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1939                         break;
1940                 }
1941                 res = -1;
1942                 break;
1943         case AST_CONTROL_CONGESTION:
1944                 if (ast->_state != AST_STATE_UP) {
1945                         transmit_response(p, "503 Service Unavailable", &p->initreq);
1946                         ast_set_flag(p, SIP_ALREADYGONE);       
1947                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1948                         break;
1949                 }
1950                 res = -1;
1951                 break;
1952         case AST_CONTROL_PROGRESS:
1953         case AST_CONTROL_PROCEEDING:
1954                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1955                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1956                         ast_set_flag(p, SIP_PROGRESS_SENT);     
1957                         break;
1958                 }
1959                 res = -1;
1960                 break;
1961         case -1:
1962                 res = -1;
1963                 break;
1964         default:
1965                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1966                 res = -1;
1967                 break;
1968         }
1969         ast_mutex_unlock(&p->lock);
1970         return res;
1971 }
1972
1973
1974
1975 /*--- sip_new: Initiate a call in the SIP channel */
1976 /*      called from sip_request_call (calls from the pbx ) */
1977 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1978 {
1979         struct ast_channel *tmp;
1980         struct ast_variable *v = NULL;
1981         int fmt;
1982         
1983         ast_mutex_unlock(&i->lock);
1984         /* Don't hold a sip pvt lock while we allocate a channel */
1985         tmp = ast_channel_alloc(1);
1986         ast_mutex_lock(&i->lock);
1987         if (tmp) {
1988                 /* Select our native format based on codec preference until we receive
1989                    something from another device to the contrary. */
1990                 ast_mutex_lock(&i->lock);
1991                 if (i->jointcapability)
1992                         tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
1993                 else if (i->capability)
1994                         tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
1995                 else
1996                         tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
1997                 ast_mutex_unlock(&i->lock);
1998                 fmt = ast_best_codec(tmp->nativeformats);
1999                 if (title)
2000                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2001                 else
2002                         if (strchr(i->fromdomain,':'))
2003                         {
2004                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2005                         }
2006                         else
2007                         {
2008                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2009                         }
2010                 tmp->type = channeltype;
2011                 if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2012                     i->vad = ast_dsp_new();
2013                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2014                     if (relaxdtmf)
2015                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2016                 }
2017                 tmp->fds[0] = ast_rtp_fd(i->rtp);
2018                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2019                 if (i->vrtp) {
2020                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
2021                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2022                 }
2023                 if (state == AST_STATE_RING)
2024                         tmp->rings = 1;
2025                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2026                 tmp->writeformat = fmt;
2027                 tmp->pvt->rawwriteformat = fmt;
2028                 tmp->readformat = fmt;
2029                 tmp->pvt->rawreadformat = fmt;
2030                 tmp->pvt->pvt = i;
2031                 tmp->pvt->send_text = sip_sendtext;
2032                 tmp->pvt->call = sip_call;
2033                 tmp->pvt->hangup = sip_hangup;
2034                 tmp->pvt->answer = sip_answer;
2035                 tmp->pvt->read = sip_read;
2036                 tmp->pvt->write = sip_write;
2037                 tmp->pvt->write_video = sip_write;
2038                 tmp->pvt->indicate = sip_indicate;
2039                 tmp->pvt->transfer = sip_transfer;
2040                 tmp->pvt->fixup = sip_fixup;
2041                 tmp->pvt->send_digit = sip_senddigit;
2042
2043                 tmp->pvt->bridge = ast_rtp_bridge;
2044
2045                 tmp->callgroup = i->callgroup;
2046                 tmp->pickupgroup = i->pickupgroup;
2047                 tmp->cid.cid_pres = i->callingpres;
2048                 if (!ast_strlen_zero(i->accountcode))
2049                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2050                 if (i->amaflags)
2051                         tmp->amaflags = i->amaflags;
2052                 if (!ast_strlen_zero(i->language))
2053                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2054                 if (!ast_strlen_zero(i->musicclass))
2055                         strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2056                 i->owner = tmp;
2057                 ast_mutex_lock(&usecnt_lock);
2058                 usecnt++;
2059                 ast_mutex_unlock(&usecnt_lock);
2060                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2061                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2062                 if (!ast_strlen_zero(i->cid_num)) 
2063                         tmp->cid.cid_num = strdup(i->cid_num);
2064                 if (!ast_strlen_zero(i->cid_name))
2065                         tmp->cid.cid_name = strdup(i->cid_name);
2066                 if (!ast_strlen_zero(i->rdnis))
2067                         tmp->cid.cid_rdnis = strdup(i->rdnis);
2068                 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2069                         tmp->cid.cid_dnid = strdup(i->exten);
2070                 tmp->priority = 1;
2071                 if (!ast_strlen_zero(i->uri)) {
2072                         pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2073                 }
2074                 if (!ast_strlen_zero(i->domain)) {
2075                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2076                 }
2077                 if (!ast_strlen_zero(i->useragent)) {
2078                         pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2079                 }
2080                 if (!ast_strlen_zero(i->callid)) {
2081                         pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2082                 }
2083                 ast_setstate(tmp, state);
2084                 if (state != AST_STATE_DOWN) {
2085                         if (ast_pbx_start(tmp)) {
2086                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2087                                 ast_hangup(tmp);
2088                                 tmp = NULL;
2089                         }
2090                 }
2091                 for (v = i->vars ; v ; v = v->next)
2092                         pbx_builtin_setvar_helper(tmp,v->name,v->value);
2093                                 
2094         } else
2095                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2096         return tmp;
2097 }
2098
2099 static struct cfalias {
2100         char *fullname;
2101         char *shortname;
2102 } aliases[] = {
2103         { "Content-Type", "c" },
2104         { "Content-Encoding", "e" },
2105         { "From", "f" },
2106         { "Call-ID", "i" },
2107         { "Contact", "m" },
2108         { "Content-Length", "l" },
2109         { "Subject", "s" },
2110         { "To", "t" },
2111         { "Supported", "k" },
2112         { "Refer-To", "r" },
2113         { "Allow-Events", "u" },
2114         { "Event", "o" },
2115         { "Via", "v" },
2116 };
2117
2118 /*--- get_sdp_by_line: Reads one line of SIP message body */
2119 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2120   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2121     char* r = line + nameLen + 1;
2122     while (*r && (*r < 33)) ++r;
2123     return r;
2124   }
2125
2126   return "";
2127 }
2128
2129 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2130    but the name wrongly applies _only_ sdp */
2131 static char *get_sdp(struct sip_request *req, char *name) {
2132   int x;
2133   int len = strlen(name);
2134   char *r;
2135
2136   for (x=0; x<req->lines; x++) {
2137     r = get_sdp_by_line(req->line[x], name, len);
2138     if (r[0] != '\0') return r;
2139   }
2140   return "";
2141 }
2142
2143
2144 static void sdpLineNum_iterator_init(int* iterator) {
2145   *iterator = 0;
2146 }
2147
2148 static char* get_sdp_iterate(int* iterator,
2149                              struct sip_request *req, char *name) {
2150   int len = strlen(name);
2151   char *r;
2152   while (*iterator < req->lines) {
2153     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2154     if (r[0] != '\0') return r;
2155   }
2156   return "";
2157 }
2158
2159 static char *__get_header(struct sip_request *req, char *name, int *start)
2160 {
2161         int x;
2162         int len = strlen(name);
2163         char *r;
2164         if (pedanticsipchecking) {
2165                 /* Technically you can place arbitrary whitespace both before and after the ':' in
2166                    a header, although RFC3261 clearly says you shouldn't before, and place just
2167                    one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
2168                    a good idea to say you can do it, and if you can do it, why in the hell would 
2169                    you say you shouldn't.  */
2170                 for (x=*start;x<req->headers;x++) {
2171                         if (!strncasecmp(req->header[x], name, len)) {
2172                                 r = req->header[x] + len;
2173                                 while(*r && (*r < 33))
2174                                         r++;
2175                                 if (*r == ':') {
2176                                         r++ ;
2177                                         while(*r && (*r < 33))
2178                                                 r++;
2179                                         *start = x+1;
2180                                         return r;
2181                                 }
2182                         }
2183                 }
2184         } else {
2185                 /* We probably shouldn't even bother counting whitespace afterwards but
2186                    I guess for backwards compatibility we will */
2187                 for (x=*start;x<req->headers;x++) {
2188                         if (!strncasecmp(req->header[x], name, len) && 
2189                                         (req->header[x][len] == ':')) {
2190                                                 r = req->header[x] + len + 1;
2191                                                 while(*r && (*r < 33))
2192                                                                 r++;
2193                                                 *start = x+1;
2194                                                 return r;
2195                         }
2196                 }
2197         }
2198         /* Try aliases */
2199         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2200                 if (!strcasecmp(aliases[x].fullname, name))
2201                         return __get_header(req, aliases[x].shortname, start);
2202
2203         /* Don't return NULL, so get_header is always a valid pointer */
2204         return "";
2205 }
2206
2207 /*--- get_header: Get header from SIP request ---*/
2208 static char *get_header(struct sip_request *req, char *name)
2209 {
2210         int start = 0;
2211         return __get_header(req, name, &start);
2212 }
2213
2214 /*--- sip_rtp_read: Read RTP from network ---*/
2215 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2216 {
2217         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2218         struct ast_frame *f;
2219         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2220         switch(ast->fdno) {
2221         case 0:
2222                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2223                 break;
2224         case 1:
2225                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2226                 break;
2227         case 2:
2228                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2229                 break;
2230         case 3:
2231                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2232                 break;
2233         default:
2234                 f = &null_frame;
2235         }
2236         /* Don't send RFC2833 if we're not supposed to */
2237         if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2238                 return &null_frame;
2239         if (p->owner) {
2240                 /* We already hold the channel lock */
2241                 if (f->frametype == AST_FRAME_VOICE) {
2242                         if (f->subclass != p->owner->nativeformats) {
2243                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2244                                 p->owner->nativeformats = f->subclass;
2245                                 ast_set_read_format(p->owner, p->owner->readformat);
2246                                 ast_set_write_format(p->owner, p->owner->writeformat);
2247                         }
2248             if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2249                    f = ast_dsp_process(p->owner,p->vad,f);
2250                    if (f && (f->frametype == AST_FRAME_DTMF)) 
2251                         ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2252             }
2253                 }
2254         }
2255         return f;
2256 }
2257
2258 /*--- sip_read: Read SIP RTP from channel */
2259 static struct ast_frame *sip_read(struct ast_channel *ast)
2260 {
2261         struct ast_frame *fr;
2262         struct sip_pvt *p = ast->pvt->pvt;
2263         ast_mutex_lock(&p->lock);
2264         fr = sip_rtp_read(ast, p);
2265         time(&p->lastrtprx);
2266         ast_mutex_unlock(&p->lock);
2267         return fr;
2268 }
2269
2270 /*--- build_callid: Build SIP CALLID header ---*/
2271 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2272 {
2273         int res;
2274         int val;
2275         int x;
2276         char iabuf[INET_ADDRSTRLEN];
2277         for (x=0;x<4;x++) {
2278                 val = rand();
2279                 res = snprintf(callid, len, "%08x", val);
2280                 len -= res;
2281                 callid += res;
2282         }
2283         if (!ast_strlen_zero(fromdomain))
2284                 snprintf(callid, len, "@%s", fromdomain);
2285         else
2286         /* It's not important that we really use our right IP here... */
2287                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2288 }
2289
2290 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2291 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2292 {
2293         struct sip_pvt *p;
2294
2295         p = malloc(sizeof(struct sip_pvt));
2296         if (!p)
2297                 return NULL;
2298         /* Keep track of stuff */
2299         memset(p, 0, sizeof(struct sip_pvt));
2300         ast_mutex_init(&p->lock);
2301
2302         p->initid = -1;
2303         p->autokillid = -1;
2304         p->stateid = -1;
2305         p->prefs = prefs;
2306 #ifdef OSP_SUPPORT
2307         p->osphandle = -1;
2308 #endif  
2309         if (sin) {
2310                 memcpy(&p->sa, sin, sizeof(p->sa));
2311                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2312                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2313         } else {
2314                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2315         }
2316         p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2317         if (videosupport)
2318                 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2319         p->branch = rand();     
2320         p->tag = rand();
2321         
2322         /* Start with 101 instead of 1 */
2323         p->ocseq = 101;
2324         if (!p->rtp) {
2325                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2326                 ast_mutex_destroy(&p->lock);
2327                 if(p->vars) {
2328                         ast_destroy_realtime(p->vars);
2329                         p->vars = NULL;
2330                 }
2331                 free(p);
2332                 return NULL;
2333         }
2334         ast_rtp_settos(p->rtp, tos);
2335         if (p->vrtp)
2336                 ast_rtp_settos(p->vrtp, tos);
2337         if (useglobal_nat && sin) {
2338                 /* Setup NAT structure according to global settings if we have an address */
2339                 ast_copy_flags(p, &global_flags, SIP_NAT);
2340                 memcpy(&p->recv, sin, sizeof(p->recv));
2341                 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2342                 if (p->vrtp)
2343                         ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2344         }
2345
2346         strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2347         build_via(p, p->via, sizeof(p->via));
2348         if (!callid)
2349                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2350         else
2351                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2352         ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2353         /* Assign default music on hold class */
2354         strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2355         p->rtptimeout = global_rtptimeout;
2356         p->rtpholdtimeout = global_rtpholdtimeout;
2357         p->rtpkeepalive = global_rtpkeepalive;
2358         p->capability = global_capability;
2359         if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833)
2360                 p->noncodeccapability |= AST_RTP_DTMF;
2361         strncpy(p->context, default_context, sizeof(p->context) - 1);
2362         /* Add to list */
2363         ast_mutex_lock(&iflock);
2364         p->next = iflist;
2365         iflist = p;
2366         ast_mutex_unlock(&iflock);
2367         if (option_debug)
2368                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2369         return p;
2370 }
2371
2372 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2373 /*               Called by handle_request ,sipsock_read */
2374 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2375 {
2376         struct sip_pvt *p;
2377         char *callid;
2378         char tmp[256] = "";
2379         char iabuf[INET_ADDRSTRLEN];
2380         char *cmd;
2381         char *tag = "", *c;
2382
2383         callid = get_header(req, "Call-ID");
2384
2385         if (pedanticsipchecking) {
2386                 /* In principle Call-ID's uniquely identify a call, however some vendors
2387                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
2388                    tags in order to simplify billing.  The RFC does state that we have to
2389                    compare tags in addition to the call-id, but this generate substantially
2390                    more overhead which is totally unnecessary for the vast majority of sane
2391                    SIP implementations, and thus Asterisk does not enable this behavior
2392                    by default. Short version: You'll need this option to support conferencing
2393                    on the pingtel */
2394                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2395                 cmd = tmp;
2396                 c = strchr(tmp, ' ');
2397                 if (c)
2398                         *c = '\0';
2399                 if (!strcasecmp(cmd, "SIP/2.0"))
2400                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2401                 else
2402                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2403                 tag = strstr(tmp, "tag=");
2404                 if (tag) {
2405                         tag += 4;
2406                         c = strchr(tag, ';');
2407                         if (c)
2408                                 *c = '\0';
2409                 }
2410                         
2411         }
2412                 
2413         if (ast_strlen_zero(callid)) {
2414                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2415                 return NULL;
2416         }
2417         ast_mutex_lock(&iflock);
2418         p = iflist;
2419         while(p) {
2420                 if (!strcmp(p->callid, callid) && 
2421                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2422                         /* Found the call */
2423                         ast_mutex_lock(&p->lock);
2424                         ast_mutex_unlock(&iflock);
2425                         return p;
2426                 }
2427                 p = p->next;
2428         }
2429         ast_mutex_unlock(&iflock);
2430         p = sip_alloc(callid, sin, 1);
2431         if (p)
2432                 ast_mutex_lock(&p->lock);
2433         return p;
2434 }
2435
2436 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2437 static int sip_register(char *value, int lineno)
2438 {
2439         struct sip_registry *reg;
2440         char copy[256] = "";
2441         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2442         char *porta=NULL;
2443         char *contact=NULL;
2444         char *stringp=NULL;
2445         
2446         if (!value)
2447                 return -1;
2448         strncpy(copy, value, sizeof(copy)-1);
2449         stringp=copy;
2450         username = stringp;
2451         hostname = strrchr(stringp, '@');
2452         if (hostname) {
2453                 *hostname = '\0';
2454                 hostname++;
2455         }
2456         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2457                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2458                 return -1;
2459         }
2460         stringp=username;
2461         username = strsep(&stringp, ":");
2462         if (username) {
2463                 secret = strsep(&stringp, ":");
2464                 if (secret) 
2465                         authuser = strsep(&stringp, ":");
2466         }
2467         stringp = hostname;
2468         hostname = strsep(&stringp, "/");
2469         if (hostname) 
2470                 contact = strsep(&stringp, "/");
2471         if (!contact || ast_strlen_zero(contact))
2472                 contact = "s";
2473         stringp=hostname;
2474         hostname = strsep(&stringp, ":");
2475         porta = strsep(&stringp, ":");
2476         
2477         if (porta && !atoi(porta)) {
2478                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2479                 return -1;
2480         }
2481         reg = malloc(sizeof(struct sip_registry));
2482         if (reg) {
2483                 memset(reg, 0, sizeof(struct sip_registry));
2484                 regobjs++;
2485                 ASTOBJ_INIT(reg);
2486                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2487                 if (username)
2488                         strncpy(reg->username, username, sizeof(reg->username)-1);
2489                 if (hostname)
2490                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2491                 if (authuser)
2492                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2493                 if (secret)
2494                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2495                 reg->expire = -1;
2496                 reg->timeout =  -1;
2497                 reg->refresh = default_expiry;
2498                 reg->portno = porta ? atoi(porta) : 0;
2499                 reg->callid_valid = 0;
2500                 reg->ocseq = 101;
2501                 ASTOBJ_CONTAINER_LINK(&regl, reg);
2502                 ASTOBJ_UNREF(reg,sip_registry_destroy);
2503         } else {
2504                 ast_log(LOG_ERROR, "Out of memory\n");
2505                 return -1;
2506         }
2507         return 0;
2508 }
2509
2510 /*--- lws2sws: Parse multiline SIP headers into one header */
2511 /* This is enabled if pedanticsipchecking is enabled */
2512 static int lws2sws(char *msgbuf, int len) 
2513
2514         int h = 0, t = 0; 
2515         int lws = 0; 
2516
2517         for (; h < len;) { 
2518                 /* Eliminate all CRs */ 
2519                 if (msgbuf[h] == '\r') { 
2520                         h++; 
2521                         continue; 
2522                 } 
2523                 /* Check for end-of-line */ 
2524                 if (msgbuf[h] == '\n') { 
2525                         /* Check for end-of-message */ 
2526                         if (h + 1 == len) 
2527                                 break; 
2528                         /* Check for a continuation line */ 
2529                         if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') { 
2530                                 /* Merge continuation line */ 
2531                                 h++; 
2532                                 continue; 
2533                         } 
2534                         /* Propagate LF and start new line */ 
2535                         msgbuf[t++] = msgbuf[h++]; 
2536                         lws = 0;
2537                         continue; 
2538                 } 
2539                 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
2540                         if (lws) { 
2541                                 h++; 
2542                                 continue; 
2543                         } 
2544                         msgbuf[t++] = msgbuf[h++]; 
2545                         lws = 1; 
2546                         continue; 
2547                 } 
2548                 msgbuf[t++] = msgbuf[h++]; 
2549                 if (lws) 
2550                         lws = 0; 
2551         } 
2552         msgbuf[t] = '\0'; 
2553         return t; 
2554 }
2555
2556 /*--- parse: Parse a SIP message ----*/
2557 static void parse(struct sip_request *req)
2558 {
2559         /* Divide fields by NULL's */
2560         char *c;
2561         int f = 0;
2562         c = req->data;
2563
2564         /* First header starts immediately */
2565         req->header[f] = c;
2566         while(*c) {
2567                 if (*c == '\n') {
2568                         /* We've got a new header */
2569                         *c = 0;
2570
2571 #if 0
2572                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2573 #endif                  
2574                         if (ast_strlen_zero(req->header[f])) {
2575                                 /* Line by itself means we're now in content */
2576                                 c++;
2577                                 break;
2578                         }
2579                         if (f >= SIP_MAX_HEADERS - 1) {
2580                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2581                         } else
2582                                 f++;
2583                         req->header[f] = c + 1;
2584                 } else if (*c == '\r') {
2585                         /* Ignore but eliminate \r's */
2586                         *c = 0;
2587                 }
2588                 c++;
2589         }
2590         /* Check for last header */
2591         if (!ast_strlen_zero(req->header[f])) 
2592                 f++;
2593         req->headers = f;
2594         /* Now we process any mime content */
2595         f = 0;
2596         req->line[f] = c;
2597         while(*c) {
2598                 if (*c == '\n') {
2599                         /* We've got a new line */
2600                         *c = 0;
2601 #if 0
2602                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2603 #endif                  
2604                         if (f >= SIP_MAX_LINES - 1) {
2605                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2606                         } else
2607                                 f++;
2608                         req->line[f] = c + 1;
2609                 } else if (*c == '\r') {
2610                         /* Ignore and eliminate \r's */
2611                         *c = 0;
2612                 }
2613                 c++;
2614         }
2615         /* Check for last line */
2616         if (!ast_strlen_zero(req->line[f])) 
2617                 f++;
2618         req->lines = f;
2619         if (*c) 
2620                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2621 }
2622
2623 /*--- process_sdp: Process SIP SDP ---*/
2624 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2625 {
2626         char *m;
2627         char *c;
2628         char *a;
2629         char host[258];
2630         char iabuf[INET_ADDRSTRLEN];
2631         int len = -1;
2632         int portno=0;
2633         int vportno=0;
2634         int peercapability, peernoncodeccapability;
2635         int vpeercapability=0, vpeernoncodeccapability=0;
2636         struct sockaddr_in sin;
2637         char *codecs;
2638         struct hostent *hp;
2639         struct ast_hostent ahp;
2640         int codec;
2641         int destiterator = 0;
2642         int iterator;
2643         int sendonly = 0;
2644         int x,y;
2645         int debug=sip_debug_test_pvt(p);
2646
2647         /* Update our last rtprx when we receive an SDP, too */
2648         time(&p->lastrtprx);
2649         time(&p->lastrtptx);
2650
2651         /* Get codec and RTP info from SDP */
2652         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2653                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2654                 return -1;
2655         }
2656         m = get_sdp(req, "m");
2657         sdpLineNum_iterator_init(&destiterator);
2658         c = get_sdp_iterate(&destiterator, req, "c");
2659         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2660                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2661                 return -1;
2662         }
2663         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2664                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2665                 return -1;
2666         }
2667         /* XXX This could block for a long time, and block the main thread! XXX */
2668         hp = ast_gethostbyname(host, &ahp);
2669         if (!hp) {
2670                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2671                 return -1;
2672         }
2673         sdpLineNum_iterator_init(&iterator);
2674         ast_set_flag(p, SIP_NOVIDEO);   
2675         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2676                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
2677                     (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
2678                         portno = x;
2679                         /* Scan through the RTP payload types specified in a "m=" line: */
2680                         ast_rtp_pt_clear(p->rtp);
2681                         codecs = m + len;
2682                         while(!ast_strlen_zero(codecs)) {
2683                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2684                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2685                                         return -1;
2686                                 }
2687                                 if (debug)
2688                                         ast_verbose("Found RTP audio format %d\n", codec);
2689                                 ast_rtp_set_m_type(p->rtp, codec);
2690                                 codecs += len;
2691                                 /* Skip over any whitespace */
2692                                 while(*codecs && (*codecs < 33)) codecs++;
2693                         }
2694                 }
2695                 if (p->vrtp)
2696                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2697
2698                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2699                         ast_clear_flag(p, SIP_NOVIDEO); 
2700                         vportno = x;
2701                         /* Scan through the RTP payload types specified in a "m=" line: */
2702                         codecs = m + len;
2703                         while(!ast_strlen_zero(codecs)) {
2704                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2705                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2706                                         return -1;
2707                                 }
2708                                 if (debug)
2709                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2710                                 ast_rtp_set_m_type(p->vrtp, codec);
2711                                 codecs += len;
2712                                 /* Skip over any whitespace */
2713                                 while(*codecs && (*codecs < 33)) codecs++;
2714                         }
2715                 }
2716         }
2717         /* Check for Media-description-level-address for audio */
2718         if (pedanticsipchecking) {
2719                 c = get_sdp_iterate(&destiterator, req, "c");
2720                 if (!ast_strlen_zero(c)) {
2721                         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2722                                 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2723                         } else {
2724                                 /* XXX This could block for a long time, and block the main thread! XXX */
2725                                 hp = ast_gethostbyname(host, &ahp);
2726                                 if (!hp) {
2727                                         ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2728                                 }
2729                         }
2730                 }
2731         }
2732         /* RTP addresses and ports for audio and video */
2733         sin.sin_family = AF_INET;
2734         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2735
2736         /* Setup audio port number */
2737         sin.sin_port = htons(portno);
2738         if (p->rtp && sin.sin_port) {
2739                 ast_rtp_set_peer(p->rtp, &sin);
2740                 if (debug) {
2741                         ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2742                         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));
2743                 }
2744         }
2745         /* Check for Media-description-level-address for video */
2746         if (pedanticsipchecking) {
2747                 c = get_sdp_iterate(&destiterator, req, "c");
2748                 if (!ast_strlen_zero(c)) {
2749                         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2750                                 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2751                         } else {
2752                                 /* XXX This could block for a long time, and block the main thread! XXX */
2753                                 hp = ast_gethostbyname(host, &ahp);
2754                                 if (!hp) {
2755                                         ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2756                                 }
2757                         }
2758                 }
2759         }
2760         /* Setup video port number */
2761         sin.sin_port = htons(vportno);
2762         if (p->vrtp && sin.sin_port) {
2763                 ast_rtp_set_peer(p->vrtp, &sin);
2764                 if (debug) {
2765                         ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2766                         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));
2767                 }
2768         }
2769
2770         /* Next, scan through each "a=rtpmap:" line, noting each
2771          * specified RTP payload type (with corresponding MIME subtype):
2772          */
2773         sdpLineNum_iterator_init(&iterator);
2774         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2775       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2776           if (!strcasecmp(a, "sendonly")) {
2777                 sendonly=1;
2778                 continue;
2779           }
2780           if (!strcasecmp(a, "sendrecv")) {
2781                 sendonly=0;
2782           }
2783           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2784           if (debug)
2785                 ast_verbose("Found description format %s\n", mimeSubtype);
2786           /* Note: should really look at the 'freq' and '#chans' params too */
2787           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2788           if (p->vrtp)
2789                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2790         }
2791
2792         /* Now gather all of the codecs that were asked for: */
2793         ast_rtp_get_current_formats(p->rtp,
2794                                 &peercapability, &peernoncodeccapability);
2795         if (p->vrtp)
2796                 ast_rtp_get_current_formats(p->vrtp,
2797                                 &vpeercapability, &vpeernoncodeccapability);
2798         p->jointcapability = p->capability & (peercapability | vpeercapability);
2799         p->peercapability = (peercapability | vpeercapability);
2800         p->noncodeccapability = noncodeccapability & peernoncodeccapability;
2801         
2802         if (debug) {
2803                 /* shame on whoever coded this.... */
2804                 const unsigned slen=512;
2805                 char s1[slen], s2[slen], s3[slen], s4[slen];
2806
2807                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2808                         ast_getformatname_multiple(s1, slen, p->capability),
2809                         ast_getformatname_multiple(s2, slen, peercapability),
2810                         ast_getformatname_multiple(s3, slen, vpeercapability),
2811                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2812
2813                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2814                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2815                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2816                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2817         }
2818         if (!p->jointcapability) {
2819                 ast_log(LOG_WARNING, "No compatible codecs!\n");
2820                 return -1;
2821         }
2822         if (p->owner) {
2823                 if (!(p->owner->nativeformats & p->jointcapability)) {
2824                         const unsigned slen=512;
2825                         char s1[slen], s2[slen];
2826                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n", 
2827                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2828                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2829                         p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1);
2830                         ast_set_read_format(p->owner, p->owner->readformat);
2831                         ast_set_write_format(p->owner, p->owner->writeformat);
2832                 }
2833                 if (ast_bridged_channel(p->owner)) {
2834                         /* Turn on/off music on hold if we are holding/unholding */
2835                         if (sin.sin_addr.s_addr && !sendonly) {
2836                                 ast_moh_stop(ast_bridged_channel(p->owner));
2837                         } else {
2838                                 ast_moh_start(ast_bridged_channel(p->owner), NULL);
2839                                 if (sendonly)
2840                                         ast_rtp_stop(p->rtp);
2841                         }
2842                 }
2843         }
2844         return 0;
2845         
2846 }
2847
2848 /*--- add_header: Add header to SIP message */
2849 static int add_header(struct sip_request *req, char *var, char *value)
2850 {
2851         int x = 0;
2852         char *shortname = "";
2853         if (req->len >= sizeof(req->data) - 4) {
2854                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2855                 return -1;
2856         }
2857         if (req->lines) {
2858                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2859                 return -1;
2860         }
2861
2862         req->header[req->headers] = req->data + req->len;
2863         if (compactheaders) {
2864                 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2865                         if (!strcasecmp(aliases[x].fullname, var))
2866                                 shortname = aliases[x].shortname;
2867         }
2868         if(!ast_strlen_zero(shortname)) {
2869                 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", shortname, value);
2870         } else {
2871                 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2872         }
2873         req->len += strlen(req->header[req->headers]);
2874         if (req->headers < SIP_MAX_HEADERS)
2875                 req->headers++;
2876         else {
2877                 ast_log(LOG_WARNING, "Out of header space\n");
2878                 return -1;
2879         }
2880         return 0;       
2881 }
2882
2883 /*--- add_blank_header: Add blank header to SIP message */
2884 static int add_blank_header(struct sip_request *req)
2885 {
2886         if (req->len >= sizeof(req->data) - 4) {
2887                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2888                 return -1;
2889         }
2890         if (req->lines) {
2891                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2892                 return -1;
2893         }
2894         req->header[req->headers] = req->data + req->len;
2895         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2896         req->len += strlen(req->header[req->headers]);
2897         if (req->headers < SIP_MAX_HEADERS)
2898                 req->headers++;
2899         else {
2900                 ast_log(LOG_WARNING, "Out of header space\n");
2901                 return -1;
2902         }
2903         return 0;       
2904 }
2905
2906 /*--- add_line: Add content (not header) to SIP message */
2907 static int add_line(struct sip_request *req, char *line)
2908 {
2909         if (req->len >= sizeof(req->data) - 4) {
2910                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2911                 return -1;
2912         }
2913         if (!req->lines) {
2914                 /* Add extra empty return */
2915                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2916                 req->len += strlen(req->data + req->len);
2917         }
2918         req->line[req->lines] = req->data + req->len;
2919         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2920         req->len += strlen(req->line[req->lines]);
2921         if (req->lines < SIP_MAX_LINES)
2922                 req->lines++;
2923         else {
2924                 ast_log(LOG_WARNING, "Out of line space\n");
2925                 return -1;
2926         }
2927         return 0;       
2928 }
2929
2930 /*--- copy_header: Copy one header field from one request to another */
2931 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2932 {
2933         char *tmp;
2934         tmp = get_header(orig, field);
2935         if (!ast_strlen_zero(tmp)) {
2936                 /* Add what we're responding to */
2937                 return add_header(req, field, tmp);
2938         }
2939         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2940         return -1;
2941 }
2942
2943 /*--- copy_all_header: Copy all headers from one request to another ---*/
2944 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2945 {
2946         char *tmp;
2947         int start = 0;
2948         int copied = 0;
2949         for (;;) {
2950                 tmp = __get_header(orig, field, &start);
2951                 if (!ast_strlen_zero(tmp)) {
2952                         /* Add what we're responding to */
2953                         add_header(req, field, tmp);
2954                         copied++;
2955                 } else
2956                         break;
2957         }
2958         return copied ? 0 : -1;
2959 }
2960
2961 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2962 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2963 {
2964         char tmp[256]="", *oh, *end;
2965         int start = 0;
2966         int copied = 0;
2967         char new[256];
2968         char iabuf[INET_ADDRSTRLEN];
2969         for (;;) {
2970                 oh = __get_header(orig, field, &start);
2971                 if (!ast_strlen_zero(oh)) {
2972                         /* Strip ;rport */
2973                         strncpy(tmp, oh, sizeof(tmp) - 1);
2974                         oh = strstr(tmp, ";rport");
2975                         if (oh) {
2976                                 end = strchr(oh + 1, ';');
2977                                 if (end)
2978                                         memmove(oh, end, strlen(end) + 1);
2979                                 else
2980                                         *oh = '\0';
2981                         }
2982                         if (!copied && (ast_test_flag(p, SIP_NAT) == SIP_NAT_ALWAYS)) {
2983                                 /* Whoo hoo!  Now we can indicate port address translation too!  Just
2984                                    another RFC (RFC3581). I'll leave the original comments in for
2985                                    posterity.  */
2986                                 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));
2987                                 add_header(req, field, new);
2988                         } else {
2989                                 /* Add what we're responding to */
2990                                 add_header(req, field, tmp);
2991                         }
2992                         copied++;
2993                 } else