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