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