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