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