Minor sipredirect fixes (bug #3789)
[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         ast_mutex_unlock(&p->lock);
2082         return res;
2083 }
2084
2085 /*--- sip_indicate: Play indication to user */
2086 /* With SIP a lot of indications is sent as messages, letting the device play
2087    the indication - busy signal, congestion etc */
2088 static int sip_indicate(struct ast_channel *ast, int condition)
2089 {
2090         struct sip_pvt *p = ast->tech_pvt;
2091         int res = 0;
2092
2093         ast_mutex_lock(&p->lock);
2094         switch(condition) {
2095         case AST_CONTROL_RINGING:
2096                 if (ast->_state == AST_STATE_RING) {
2097                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2098                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2099                                 /* Send 180 ringing if out-of-band seems reasonable */
2100                                 transmit_response(p, "180 Ringing", &p->initreq);
2101                                 ast_set_flag(p, SIP_RINGING);
2102                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2103                                         break;
2104                         } else {
2105                                 /* Well, if it's not reasonable, just send in-band */
2106                         }
2107                 }
2108                 res = -1;
2109                 break;
2110         case AST_CONTROL_BUSY:
2111                 if (ast->_state != AST_STATE_UP) {
2112                         transmit_response(p, "486 Busy Here", &p->initreq);
2113                         ast_set_flag(p, SIP_ALREADYGONE);       
2114                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2115                         break;
2116                 }
2117                 res = -1;
2118                 break;
2119         case AST_CONTROL_CONGESTION:
2120                 if (ast->_state != AST_STATE_UP) {
2121                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2122                         ast_set_flag(p, SIP_ALREADYGONE);       
2123                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2124                         break;
2125                 }
2126                 res = -1;
2127                 break;
2128         case AST_CONTROL_PROGRESS:
2129         case AST_CONTROL_PROCEEDING:
2130                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2131                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2132                         ast_set_flag(p, SIP_PROGRESS_SENT);     
2133                         break;
2134                 }
2135                 res = -1;
2136                 break;
2137         case -1:
2138                 res = -1;
2139                 break;
2140         default:
2141                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2142                 res = -1;
2143                 break;
2144         }
2145         ast_mutex_unlock(&p->lock);
2146         return res;
2147 }
2148
2149
2150
2151 /*--- sip_new: Initiate a call in the SIP channel */
2152 /*      called from sip_request_call (calls from the pbx ) */
2153 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2154 {
2155         struct ast_channel *tmp;
2156         struct ast_variable *v = NULL;
2157         int fmt;
2158         
2159         ast_mutex_unlock(&i->lock);
2160         /* Don't hold a sip pvt lock while we allocate a channel */
2161         tmp = ast_channel_alloc(1);
2162         ast_mutex_lock(&i->lock);
2163         if (tmp) {
2164                 tmp->tech = &sip_tech;
2165                 /* Select our native format based on codec preference until we receive
2166                    something from another device to the contrary. */
2167                 ast_mutex_lock(&i->lock);
2168                 if (i->jointcapability)
2169                         tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2170                 else if (i->capability)
2171                         tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2172                 else
2173                         tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2174                 ast_mutex_unlock(&i->lock);
2175                 fmt = ast_best_codec(tmp->nativeformats);
2176                 if (title)
2177                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2178                 else
2179                         if (strchr(i->fromdomain,':'))
2180                         {
2181                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2182                         }
2183                         else
2184                         {
2185                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2186                         }
2187                 tmp->type = channeltype;
2188                 if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2189                     i->vad = ast_dsp_new();
2190                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2191                     if (relaxdtmf)
2192                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2193                 }
2194                 tmp->fds[0] = ast_rtp_fd(i->rtp);
2195                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2196                 if (i->vrtp) {
2197                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
2198                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2199                 }
2200                 if (state == AST_STATE_RING)
2201                         tmp->rings = 1;
2202                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2203                 tmp->writeformat = fmt;
2204                 tmp->rawwriteformat = fmt;
2205                 tmp->readformat = fmt;
2206                 tmp->rawreadformat = fmt;
2207                 tmp->tech_pvt = i;
2208
2209                 tmp->callgroup = i->callgroup;
2210                 tmp->pickupgroup = i->pickupgroup;
2211                 tmp->cid.cid_pres = i->callingpres;
2212                 if (!ast_strlen_zero(i->accountcode))
2213                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2214                 if (i->amaflags)
2215                         tmp->amaflags = i->amaflags;
2216                 if (!ast_strlen_zero(i->language))
2217                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2218                 if (!ast_strlen_zero(i->musicclass))
2219                         strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2220                 i->owner = tmp;
2221                 ast_mutex_lock(&usecnt_lock);
2222                 usecnt++;
2223                 ast_mutex_unlock(&usecnt_lock);
2224                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2225                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2226                 if (!ast_strlen_zero(i->cid_num)) 
2227                         tmp->cid.cid_num = strdup(i->cid_num);
2228                 if (!ast_strlen_zero(i->cid_name))
2229                         tmp->cid.cid_name = strdup(i->cid_name);
2230                 if (!ast_strlen_zero(i->rdnis))
2231                         tmp->cid.cid_rdnis = strdup(i->rdnis);
2232                 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2233                         tmp->cid.cid_dnid = strdup(i->exten);
2234                 tmp->priority = 1;
2235                 if (!ast_strlen_zero(i->uri)) {
2236                         pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2237                 }
2238                 if (!ast_strlen_zero(i->domain)) {
2239                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2240                 }
2241                 if (!ast_strlen_zero(i->useragent)) {
2242                         pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2243                 }
2244                 if (!ast_strlen_zero(i->callid)) {
2245                         pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2246                 }
2247                 ast_setstate(tmp, state);
2248                 if (state != AST_STATE_DOWN) {
2249                         if (ast_pbx_start(tmp)) {
2250                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2251                                 ast_hangup(tmp);
2252                                 tmp = NULL;
2253                         }
2254                 }
2255                 /* Set channel variables for this call from configuration */
2256                 for (v = i->chanvars ; v ; v = v->next)
2257                         pbx_builtin_setvar_helper(tmp,v->name,v->value);
2258                                 
2259         } else
2260                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2261         return tmp;
2262 }
2263
2264 /* Structure for conversion between compressed SIP and "normal" SIP */
2265 static struct cfalias {
2266         char *fullname;
2267         char *shortname;
2268 } aliases[] = {
2269         { "Content-Type", "c" },
2270         { "Content-Encoding", "e" },
2271         { "From", "f" },
2272         { "Call-ID", "i" },
2273         { "Contact", "m" },
2274         { "Content-Length", "l" },
2275         { "Subject", "s" },
2276         { "To", "t" },
2277         { "Supported", "k" },
2278         { "Refer-To", "r" },
2279         { "Allow-Events", "u" },
2280         { "Event", "o" },
2281         { "Via", "v" },
2282 };
2283
2284 /*--- get_sdp_by_line: Reads one line of SIP message body */
2285 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2286   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2287     char* r = line + nameLen + 1;
2288     while (*r && (*r < 33)) ++r;
2289     return r;
2290   }
2291
2292   return "";
2293 }
2294
2295 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2296    but the name wrongly applies _only_ sdp */
2297 static char *get_sdp(struct sip_request *req, char *name) {
2298   int x;
2299   int len = strlen(name);
2300   char *r;
2301
2302   for (x=0; x<req->lines; x++) {
2303     r = get_sdp_by_line(req->line[x], name, len);
2304     if (r[0] != '\0') return r;
2305   }
2306   return "";
2307 }
2308
2309
2310 static void sdpLineNum_iterator_init(int* iterator) {
2311   *iterator = 0;
2312 }
2313
2314 static char* get_sdp_iterate(int* iterator,
2315                              struct sip_request *req, char *name) {
2316   int len = strlen(name);
2317   char *r;
2318   while (*iterator < req->lines) {
2319     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2320     if (r[0] != '\0') return r;
2321   }
2322   return "";
2323 }
2324
2325 static char *__get_header(struct sip_request *req, char *name, int *start)
2326 {
2327         int x;
2328         int len = strlen(name);
2329         char *r;
2330         if (pedanticsipchecking) {
2331                 /* Technically you can place arbitrary whitespace both before and after the ':' in
2332                    a header, although RFC3261 clearly says you shouldn't before, and place just
2333                    one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
2334                    a good idea to say you can do it, and if you can do it, why in the hell would 
2335                    you say you shouldn't.  */
2336                 for (x=*start;x<req->headers;x++) {
2337                         if (!strncasecmp(req->header[x], name, len)) {
2338                                 r = req->header[x] + len;
2339                                 while(*r && (*r < 33))
2340                                         r++;
2341                                 if (*r == ':') {
2342                                         r++ ;
2343                                         while(*r && (*r < 33))
2344                                                 r++;
2345                                         *start = x+1;
2346                                         return r;
2347                                 }
2348                         }
2349                 }
2350         } else {
2351                 /* We probably shouldn't even bother counting whitespace afterwards but
2352                    I guess for backwards compatibility we will */
2353                 for (x=*start;x<req->headers;x++) {
2354                         if (!strncasecmp(req->header[x], name, len) && 
2355                                         (req->header[x][len] == ':')) {
2356                                                 r = req->header[x] + len + 1;
2357                                                 while(*r && (*r < 33))
2358                                                                 r++;
2359                                                 *start = x+1;
2360                                                 return r;
2361                         }
2362                 }
2363         }
2364         /* Try aliases */
2365         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2366                 if (!strcasecmp(aliases[x].fullname, name))
2367                         return __get_header(req, aliases[x].shortname, start);
2368
2369         /* Don't return NULL, so get_header is always a valid pointer */
2370         return "";
2371 }
2372
2373 /*--- get_header: Get header from SIP request ---*/
2374 static char *get_header(struct sip_request *req, char *name)
2375 {
2376         int start = 0;
2377         return __get_header(req, name, &start);
2378 }
2379
2380 /*--- sip_rtp_read: Read RTP from network ---*/
2381 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2382 {
2383         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2384         struct ast_frame *f;
2385         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2386         switch(ast->fdno) {
2387         case 0:
2388                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2389                 break;
2390         case 1:
2391                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2392                 break;
2393         case 2:
2394                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2395                 break;
2396         case 3:
2397                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2398                 break;
2399         default:
2400                 f = &null_frame;
2401         }
2402         /* Don't send RFC2833 if we're not supposed to */
2403         if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2404                 return &null_frame;
2405         if (p->owner) {
2406                 /* We already hold the channel lock */
2407                 if (f->frametype == AST_FRAME_VOICE) {
2408                         if (f->subclass != p->owner->nativeformats) {
2409                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2410                                 p->owner->nativeformats = f->subclass;
2411                                 ast_set_read_format(p->owner, p->owner->readformat);
2412                                 ast_set_write_format(p->owner, p->owner->writeformat);
2413                         }
2414             if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2415                    f = ast_dsp_process(p->owner,p->vad,f);
2416                    if (f && (f->frametype == AST_FRAME_DTMF)) 
2417                         ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2418             }
2419                 }
2420         }
2421         return f;
2422 }
2423
2424 /*--- sip_read: Read SIP RTP from channel */
2425 static struct ast_frame *sip_read(struct ast_channel *ast)
2426 {
2427         struct ast_frame *fr;
2428         struct sip_pvt *p = ast->tech_pvt;
2429         ast_mutex_lock(&p->lock);
2430         fr = sip_rtp_read(ast, p);
2431         time(&p->lastrtprx);
2432         ast_mutex_unlock(&p->lock);
2433         return fr;
2434 }
2435
2436 /*--- build_callid: Build SIP CALLID header ---*/
2437 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2438 {
2439         int res;
2440         int val;
2441         int x;
2442         char iabuf[INET_ADDRSTRLEN];
2443         for (x=0;x<4;x++) {
2444                 val = rand();
2445                 res = snprintf(callid, len, "%08x", val);
2446                 len -= res;
2447                 callid += res;
2448         }
2449         if (!ast_strlen_zero(fromdomain))
2450                 snprintf(callid, len, "@%s", fromdomain);
2451         else
2452         /* It's not important that we really use our right IP here... */
2453                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2454 }
2455
2456 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2457 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2458 {
2459         struct sip_pvt *p;
2460
2461         p = malloc(sizeof(struct sip_pvt));
2462         if (!p)
2463                 return NULL;
2464         /* Keep track of stuff */
2465         memset(p, 0, sizeof(struct sip_pvt));
2466         ast_mutex_init(&p->lock);
2467
2468         p->initid = -1;
2469         p->autokillid = -1;
2470         p->stateid = -1;
2471         p->prefs = prefs;
2472 #ifdef OSP_SUPPORT
2473         p->osphandle = -1;
2474 #endif  
2475         if (sin) {
2476                 memcpy(&p->sa, sin, sizeof(p->sa));
2477                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2478                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2479         } else {
2480                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2481         }
2482         p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2483         if (videosupport)
2484                 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2485         p->branch = rand();     
2486         p->tag = rand();
2487         
2488         /* Start with 101 instead of 1 */
2489         p->ocseq = 101;
2490         if (!p->rtp) {
2491                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2492                 ast_mutex_destroy(&p->lock);
2493                 if(p->chanvars) {
2494                         ast_variables_destroy(p->chanvars);
2495                         p->chanvars = NULL;
2496                 }
2497                 free(p);
2498                 return NULL;
2499         }
2500         ast_rtp_settos(p->rtp, tos);
2501         if (p->vrtp)
2502                 ast_rtp_settos(p->vrtp, tos);
2503         if (useglobal_nat && sin) {
2504                 /* Setup NAT structure according to global settings if we have an address */
2505                 ast_copy_flags(p, &global_flags, SIP_NAT);
2506                 memcpy(&p->recv, sin, sizeof(p->recv));
2507                 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2508                 if (p->vrtp)
2509                         ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2510         }
2511
2512         strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2513         build_via(p, p->via, sizeof(p->via));
2514         if (!callid)
2515                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2516         else
2517                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2518         ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2519         /* Assign default music on hold class */
2520         strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2521         p->rtptimeout = global_rtptimeout;
2522         p->rtpholdtimeout = global_rtpholdtimeout;
2523         p->rtpkeepalive = global_rtpkeepalive;
2524         p->capability = global_capability;
2525         if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833)
2526                 p->noncodeccapability |= AST_RTP_DTMF;
2527         strncpy(p->context, default_context, sizeof(p->context) - 1);
2528         /* Add to list */
2529         ast_mutex_lock(&iflock);
2530         p->next = iflist;
2531         iflist = p;
2532         ast_mutex_unlock(&iflock);
2533         if (option_debug)
2534                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2535         return p;
2536 }
2537
2538 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2539 /*               Called by handle_request ,sipsock_read */
2540 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2541 {
2542         struct sip_pvt *p;
2543         char *callid;
2544         char tmp[256] = "";
2545         char iabuf[INET_ADDRSTRLEN];
2546         char *cmd;
2547         char *tag = "", *c;
2548
2549         callid = get_header(req, "Call-ID");
2550
2551         if (pedanticsipchecking) {
2552                 /* In principle Call-ID's uniquely identify a call, however some vendors
2553                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
2554                    tags in order to simplify billing.  The RFC does state that we have to
2555                    compare tags in addition to the call-id, but this generate substantially
2556                    more overhead which is totally unnecessary for the vast majority of sane
2557                    SIP implementations, and thus Asterisk does not enable this behavior
2558                    by default. Short version: You'll need this option to support conferencing
2559                    on the pingtel */
2560                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2561                 cmd = tmp;
2562                 c = strchr(tmp, ' ');
2563                 if (c)
2564                         *c = '\0';
2565                 if (!strcasecmp(cmd, "SIP/2.0"))
2566                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2567                 else
2568                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2569                 tag = strcasestr(tmp, "tag=");
2570                 if (tag) {
2571                         tag += 4;
2572                         c = strchr(tag, ';');
2573                         if (c)
2574                                 *c = '\0';
2575                 }
2576                         
2577         }
2578                 
2579         if (ast_strlen_zero(callid)) {
2580                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2581                 return NULL;
2582         }
2583         ast_mutex_lock(&iflock);
2584         p = iflist;
2585         while(p) {
2586                 if (!strcmp(p->callid, callid) && 
2587                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2588                         /* Found the call */
2589                         ast_mutex_lock(&p->lock);
2590                         ast_mutex_unlock(&iflock);
2591                         return p;
2592                 }
2593                 p = p->next;
2594         }
2595         ast_mutex_unlock(&iflock);
2596         p = sip_alloc(callid, sin, 1);
2597         if (p)
2598                 ast_mutex_lock(&p->lock);
2599         return p;
2600 }
2601
2602 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2603 static int sip_register(char *value, int lineno)
2604 {
2605         struct sip_registry *reg;
2606         char copy[256] = "";
2607         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2608         char *porta=NULL;
2609         char *contact=NULL;
2610         char *stringp=NULL;
2611         
2612         if (!value)
2613                 return -1;
2614         strncpy(copy, value, sizeof(copy)-1);
2615         stringp=copy;
2616         username = stringp;
2617         hostname = strrchr(stringp, '@');
2618         if (hostname) {
2619                 *hostname = '\0';
2620                 hostname++;
2621         }
2622         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2623                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2624                 return -1;
2625         }
2626         stringp=username;
2627         username = strsep(&stringp, ":");
2628         if (username) {
2629                 secret = strsep(&stringp, ":");
2630                 if (secret) 
2631                         authuser = strsep(&stringp, ":");
2632         }
2633         stringp = hostname;
2634         hostname = strsep(&stringp, "/");
2635         if (hostname) 
2636                 contact = strsep(&stringp, "/");
2637         if (!contact || ast_strlen_zero(contact))
2638                 contact = "s";
2639         stringp=hostname;
2640         hostname = strsep(&stringp, ":");
2641         porta = strsep(&stringp, ":");
2642         
2643         if (porta && !atoi(porta)) {
2644                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2645                 return -1;
2646         }
2647         reg = malloc(sizeof(struct sip_registry));
2648         if (reg) {
2649                 memset(reg, 0, sizeof(struct sip_registry));
2650                 regobjs++;
2651                 ASTOBJ_INIT(reg);
2652                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2653                 if (username)
2654                         strncpy(reg->username, username, sizeof(reg->username)-1);
2655                 if (hostname)
2656                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2657                 if (authuser)
2658                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2659                 if (secret)
2660                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2661                 reg->expire = -1;
2662                 reg->timeout =  -1;
2663                 reg->refresh = default_expiry;
2664                 reg->portno = porta ? atoi(porta) : 0;
2665                 reg->callid_valid = 0;
2666                 reg->ocseq = 101;
2667                 ASTOBJ_CONTAINER_LINK(&regl, reg);
2668                 ASTOBJ_UNREF(reg,sip_registry_destroy);
2669         } else {
2670                 ast_log(LOG_ERROR, "Out of memory\n");
2671                 return -1;
2672         }
2673         return 0;
2674 }
2675
2676 /*--- lws2sws: Parse multiline SIP headers into one header */
2677 /* This is enabled if pedanticsipchecking is enabled */
2678 static int lws2sws(char *msgbuf, int len) 
2679
2680         int h = 0, t = 0; 
2681         int lws = 0; 
2682
2683         for (; h < len;) { 
2684                 /* Eliminate all CRs */ 
2685                 if (msgbuf[h] == '\r') { 
2686                         h++; 
2687                         continue; 
2688                 } 
2689                 /* Check for end-of-line */ 
2690                 if (msgbuf[h] == '\n') { 
2691                         /* Check for end-of-message */ 
2692                         if (h + 1 == len) 
2693                                 break; 
2694                         /* Check for a continuation line */ 
2695                         if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') { 
2696                                 /* Merge continuation line */ 
2697                                 h++; 
2698                                 continue; 
2699                         } 
2700                         /* Propagate LF and start new line */ 
2701                         msgbuf[t++] = msgbuf[h++]; 
2702                         lws = 0;
2703                         continue; 
2704                 } 
2705                 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
2706                         if (lws) { 
2707                                 h++; 
2708                                 continue; 
2709                         } 
2710                         msgbuf[t++] = msgbuf[h++]; 
2711                         lws = 1; 
2712                         continue; 
2713                 } 
2714                 msgbuf[t++] = msgbuf[h++]; 
2715                 if (lws) 
2716                         lws = 0; 
2717         } 
2718         msgbuf[t] = '\0'; 
2719         return t; 
2720 }
2721
2722 /*--- parse: Parse a SIP message ----*/
2723 static void parse(struct sip_request *req)
2724 {
2725         /* Divide fields by NULL's */
2726         char *c;
2727         int f = 0;
2728         c = req->data;
2729
2730         /* First header starts immediately */
2731         req->header[f] = c;
2732         while(*c) {
2733                 if (*c == '\n') {
2734                         /* We've got a new header */
2735                         *c = 0;
2736
2737 #if 0
2738                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2739 #endif                  
2740                         if (ast_strlen_zero(req->header[f])) {
2741                                 /* Line by itself means we're now in content */
2742                                 c++;
2743                                 break;
2744                         }
2745                         if (f >= SIP_MAX_HEADERS - 1) {
2746                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2747                         } else
2748                                 f++;
2749                         req->header[f] = c + 1;
2750                 } else if (*c == '\r') {
2751                         /* Ignore but eliminate \r's */
2752                         *c = 0;
2753                 }
2754                 c++;
2755         }
2756         /* Check for last header */
2757         if (!ast_strlen_zero(req->header[f])) 
2758                 f++;
2759         req->headers = f;
2760         /* Now we process any mime content */
2761         f = 0;
2762         req->line[f] = c;
2763         while(*c) {
2764                 if (*c == '\n') {
2765                         /* We've got a new line */
2766                         *c = 0;
2767 #if 0
2768                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2769 #endif                  
2770                         if (f >= SIP_MAX_LINES - 1) {
2771                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2772                         } else
2773                                 f++;
2774                         req->line[f] = c + 1;
2775                 } else if (*c == '\r') {
2776                         /* Ignore and eliminate \r's */
2777                         *c = 0;
2778                 }
2779                 c++;
2780         }
2781         /* Check for last line */
2782         if (!ast_strlen_zero(req->line[f])) 
2783                 f++;
2784         req->lines = f;
2785         if (*c) 
2786                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2787 }
2788
2789 /*--- process_sdp: Process SIP SDP ---*/
2790 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2791 {
2792         char *m;
2793         char *c;
2794         char *a;
2795         char host[258];
2796         char iabuf[INET_ADDRSTRLEN];
2797         int len = -1;
2798         int portno=0;
2799         int vportno=0;
2800         int peercapability, peernoncodeccapability;
2801         int vpeercapability=0, vpeernoncodeccapability=0;
2802         struct sockaddr_in sin;
2803         char *codecs;
2804         struct hostent *hp;
2805         struct ast_hostent ahp;
2806         int codec;
2807         int destiterator = 0;
2808         int iterator;
2809         int sendonly = 0;
2810         int x,y;
2811         int debug=sip_debug_test_pvt(p);
2812
2813         /* Update our last rtprx when we receive an SDP, too */
2814         time(&p->lastrtprx);
2815         time(&p->lastrtptx);
2816
2817         /* Get codec and RTP info from SDP */
2818         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2819                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2820                 return -1;
2821         }
2822         m = get_sdp(req, "m");
2823         sdpLineNum_iterator_init(&destiterator);
2824         c = get_sdp_iterate(&destiterator, req, "c");
2825         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2826                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2827                 return -1;
2828         }
2829         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2830                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2831                 return -1;
2832         }
2833         /* XXX This could block for a long time, and block the main thread! XXX */
2834         hp = ast_gethostbyname(host, &ahp);
2835         if (!hp) {
2836                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2837                 return -1;
2838         }
2839         sdpLineNum_iterator_init(&iterator);
2840         ast_set_flag(p, SIP_NOVIDEO);   
2841         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2842                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
2843                     (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
2844                         portno = x;
2845                         /* Scan through the RTP payload types specified in a "m=" line: */
2846                         ast_rtp_pt_clear(p->rtp);
2847                         codecs = m + len;
2848                         while(!ast_strlen_zero(codecs)) {
2849                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2850                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2851                                         return -1;
2852                                 }
2853                                 if (debug)
2854                                         ast_verbose("Found RTP audio format %d\n", codec);
2855                                 ast_rtp_set_m_type(p->rtp, codec);
2856                                 codecs += len;
2857                                 /* Skip over any whitespace */
2858                                 while(*codecs && (*codecs < 33)) codecs++;
2859                         }
2860                 }
2861                 if (p->vrtp)
2862                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2863
2864                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2865                         ast_clear_flag(p, SIP_NOVIDEO); 
2866                         vportno = x;
2867                         /* Scan through the RTP payload types specified in a "m=" line: */
2868                         codecs = m + len;
2869                         while(!ast_strlen_zero(codecs)) {
2870                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2871                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2872                                         return -1;
2873                                 }
2874                                 if (debug)
2875                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2876                                 ast_rtp_set_m_type(p->vrtp, codec);
2877                                 codecs += len;
2878                                 /* Skip over any whitespace */
2879                                 while(*codecs && (*codecs < 33)) codecs++;
2880                         }
2881                 }
2882         }
2883         /* Check for Media-description-level-address for audio */
2884         if (pedanticsipchecking) {
2885                 c = get_sdp_iterate(&destiterator, req, "c");
2886                 if (!ast_strlen_zero(c)) {
2887                         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2888                                 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2889                         } else {
2890                                 /* XXX This could block for a long time, and block the main thread! XXX */
2891                                 hp = ast_gethostbyname(host, &ahp);
2892                                 if (!hp) {
2893                                         ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2894                                 }
2895                         }
2896                 }
2897         }
2898         /* RTP addresses and ports for audio and video */
2899         sin.sin_family = AF_INET;
2900         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2901
2902         /* Setup audio port number */
2903         sin.sin_port = htons(portno);
2904         if (p->rtp && sin.sin_port) {
2905                 ast_rtp_set_peer(p->rtp, &sin);
2906                 if (debug) {
2907                         ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2908                         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));
2909                 }
2910         }
2911         /* Check for Media-description-level-address for video */
2912         if (pedanticsipchecking) {
2913                 c = get_sdp_iterate(&destiterator, req, "c");
2914                 if (!ast_strlen_zero(c)) {
2915                         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2916                                 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2917                         } else {
2918                                 /* XXX This could block for a long time, and block the main thread! XXX */
2919                                 hp = ast_gethostbyname(host, &ahp);
2920                                 if (!hp) {
2921                                         ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2922                                 }
2923                         }
2924                 }
2925         }
2926         /* Setup video port number */
2927         sin.sin_port = htons(vportno);
2928         if (p->vrtp && sin.sin_port) {
2929                 ast_rtp_set_peer(p->vrtp, &sin);
2930                 if (debug) {
2931                         ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2932                         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));
2933                 }
2934         }
2935
2936         /* Next, scan through each "a=rtpmap:" line, noting each
2937          * specified RTP payload type (with corresponding MIME subtype):
2938          */
2939         sdpLineNum_iterator_init(&iterator);
2940         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2941       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2942           if (!strcasecmp(a, "sendonly")) {
2943                 sendonly=1;
2944                 continue;
2945           }
2946           if (!strcasecmp(a, "sendrecv")) {
2947                 sendonly=0;
2948           }
2949           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2950           if (debug)
2951                 ast_verbose("Found description format %s\n", mimeSubtype);
2952           /* Note: should really look at the 'freq' and '#chans' params too */
2953           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2954           if (p->vrtp)
2955                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2956         }
2957
2958         /* Now gather all of the codecs that were asked for: */
2959         ast_rtp_get_current_formats(p->rtp,
2960                                 &peercapability, &peernoncodeccapability);
2961         if (p->vrtp)
2962                 ast_rtp_get_current_formats(p->vrtp,
2963                                 &vpeercapability, &vpeernoncodeccapability);
2964         p->jointcapability = p->capability & (peercapability | vpeercapability);
2965         p->peercapability = (peercapability | vpeercapability);
2966         p->noncodeccapability = noncodeccapability & peernoncodeccapability;
2967         
2968         if (debug) {
2969                 /* shame on whoever coded this.... */
2970                 const unsigned slen=512;
2971                 char s1[slen], s2[slen], s3[slen], s4[slen];
2972
2973                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2974                         ast_getformatname_multiple(s1, slen, p->capability),
2975                         ast_getformatname_multiple(s2, slen, peercapability),
2976                         ast_getformatname_multiple(s3, slen, vpeercapability),
2977                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2978
2979                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2980                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2981                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2982                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2983         }
2984         if (!p->jointcapability) {
2985                 ast_log(LOG_NOTICE, "No compatible codecs!\n");
2986                 return -1;
2987         }
2988         if (p->owner) {
2989                 if (!(p->owner->nativeformats & p->jointcapability)) {
2990                         const unsigned slen=512;
2991                         char s1[slen], s2[slen];
2992                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n", 
2993                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2994                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2995                         p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1);
2996                         ast_set_read_format(p->owner, p->owner->readformat);
2997                         ast_set_write_format(p->owner, p->owner->writeformat);
2998                 }
2999                 if (ast_bridged_channel(p->owner)) {
3000                         /* Turn on/off music on hold if we are holding/unholding */
3001                         if (sin.sin_addr.s_addr && !sendonly) {
3002                                 ast_moh_stop(ast_bridged_channel(p->owner));
3003                                 if (callevents && ast_test_flag(p, SIP_CALL_ONHOLD)) {
3004                                         manager_event(EVENT_FLAG_CALL, "Unhold",
3005                                                 "Channel: %s\r\n"
3006                                                 "Uniqueid: %s\r\n",
3007                                                 p->owner->name, 
3008                                                 p->owner->uniqueid);
3009                                         ast_clear_flag(p, SIP_CALL_ONHOLD);
3010                                 }
3011                         } else {
3012                                 if (callevents && !ast_test_flag(p, SIP_CALL_ONHOLD)) {
3013                                         manager_event(EVENT_FLAG_CALL, "Hold",
3014                                                 "Channel: %s\r\n"
3015                                                 "Uniqueid: %s\r\n",
3016                                                 p->owner->name, 
3017                                                 p->owner->uniqueid);