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