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