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