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