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