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