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