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