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