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