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