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