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