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