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