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