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