2 * Asterisk -- A telephony toolkit for Linux.
4 * Implementation of Session Initiation Protocol
6 * Copyright (C) 2004, Digium, Inc.
8 * Mark Spencer <markster@digium.com>
10 * This program is free software, distributed under the terms of
11 * the GNU General Public License
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/features.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>
44 #include <asterisk/astosp.h>
46 #include <sys/socket.h>
47 #include <sys/ioctl.h>
54 #include <arpa/inet.h>
56 #include <sys/signal.h>
57 #include <netinet/in_systm.h>
58 #include <netinet/ip.h>
60 #ifdef SIP_MYSQL_FRIENDS
62 #include <mysql/mysql.h>
65 #ifndef DEFAULT_USERAGENT
66 #define DEFAULT_USERAGENT "Asterisk PBX"
69 #define VIDEO_CODEC_MASK 0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
71 #define IPTOS_MINCOST 0x02
74 /* #define VOCAL_DATA_HACK */
77 #define DEFAULT_DEFAULT_EXPIRY 120
78 #define DEFAULT_MAX_EXPIRY 3600
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
87 #define EXPIRY_GUARD_PCT 0.20 /* Percentage of expires timeout to use when below EXPIRY_GUARD_LIMIT */
90 #define MAX(a,b) ((a) > (b) ? (a) : (b))
93 #define CALLERID_UNKNOWN "Unknown"
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)
100 static int max_expiry = DEFAULT_MAX_EXPIRY;
101 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
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... */
107 #define DEFAULT_RETRANS 1000 /* How frequently to retransmit */
108 #define MAX_RETRANS 5 /* Try only 5 times for retransmissions */
110 /* MYSQL_FRIENDS: Check if peer exists in database and read some configuration
111 from databse (not all options supported though) */
113 AST_MUTEX_DEFINE_STATIC(mysqllock);
115 static char mydbuser[80];
116 static char mydbpass[80];
117 static char mydbhost[80];
118 static char mydbname[80];
122 #define DEBUG_READ 0 /* Recieved data */
123 #define DEBUG_SEND 1 /* Transmit data */
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";
130 #define DEFAULT_SIP_PORT 5060 /* From RFC 2543 */
131 #define SIP_MAX_PACKET 1500 /* Also from RFC 2543, should sub headers tho */
133 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
135 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
137 static char default_context[AST_MAX_EXTENSION] = "default";
139 static char default_language[MAX_LANGUAGE] = "";
141 static char default_callerid[AST_MAX_EXTENSION] = "asterisk";
143 static char default_fromdomain[AST_MAX_EXTENSION] = "";
145 static char notifymime[AST_MAX_EXTENSION] = "application/simple-message-summary";
147 static int srvlookup = 0;
149 static int pedanticsipchecking = 0;
151 static int autocreatepeer = 0;
153 static int relaxdtmf = 0;
155 static int global_rtptimeout = 0;
157 static int global_rtpholdtimeout = 0;
159 static int global_trustrpid = 0;
161 static int global_progressinband = 0;
164 static int global_ospauth = 0;
167 static int usecnt =0;
168 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
170 /* Protect the interface list (of sip_pvt's) */
171 AST_MUTEX_DEFINE_STATIC(iflock);
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);
177 AST_MUTEX_DEFINE_STATIC(monlock);
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;
183 static int restart_monitor(void);
185 /* Codecs that we support by default: */
186 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
187 static int noncodeccapability = AST_RTP_DTMF;
189 static char ourhost[256];
190 static struct in_addr __ourip;
193 static int sipdebug = 0;
194 static struct sockaddr_in debugaddr;
198 static int videosupport = 0;
200 static int global_dtmfmode = SIP_DTMF_RFC2833; /* DTMF mode default */
201 static int recordhistory = 0;
202 static int global_promiscredir;
204 static char global_musicclass[MAX_LANGUAGE] = ""; /* Global music on hold class */
205 static char global_realm[AST_MAX_EXTENSION] = "asterisk"; /* Default realm */
208 static int expiry = 900;
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 */
215 #define SIP_MAX_HEADERS 64
216 #define SIP_MAX_LINES 64
220 #define DEC_OUT_USE 2
221 #define INC_OUT_USE 3
223 static struct sip_codec_pref {
225 struct sip_codec_pref *next;
228 /* sip_request: The data grabbed from the UDP socket */
230 char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
231 char *rlPart2; /* The Request URI or Response Status */
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];
243 struct sip_route *next;
249 struct sip_history *next;
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 novideo; /* Didn't get video in invite, don't offer */
266 int jointcapability; /* Supported capability at both ends (codecs ) */
267 int peercapability; /* Supported peer capability */
268 int prefcodec; /* Preferred codec (outbound only) */
269 int noncodeccapability;
270 int outgoing; /* Outgoing or incoming call? */
271 int authtries; /* Times we've tried to authenticate */
272 int insecure; /* Don't check source port/ip */
273 int expiry; /* How long we take to expire */
274 int branch; /* One random number */
275 int canreinvite; /* Do we support reinvite */
276 int ringing; /* Have sent 180 ringing */
277 int progress; /* Have sent 183 message progress */
278 int tag; /* Another random number */
279 int nat; /* Whether to try to support NAT */
280 int sessionid; /* SDP Session ID */
281 int sessionversion; /* SDP Session Version */
282 struct sockaddr_in sa; /* Our peer */
283 struct sockaddr_in redirip; /* Where our RTP should be going if not to us */
284 struct sockaddr_in vredirip; /* Where our Video RTP should be going if not to us */
285 int redircodecs; /* Redirect codecs */
286 struct sockaddr_in recv; /* Received as */
287 struct in_addr ourip; /* Our IP */
288 struct ast_channel *owner; /* Who owns us */
289 char exten[AST_MAX_EXTENSION]; /* Extension where to start */
290 char refer_to[AST_MAX_EXTENSION]; /* Place to store REFER-TO extension */
291 char referred_by[AST_MAX_EXTENSION]; /* Place to store REFERRED-BY extension */
292 char refer_contact[AST_MAX_EXTENSION]; /* Place to store Contact info from a REFER extension */
293 struct sip_pvt *refer_call; /* Call we are referring */
294 struct sip_route *route; /* Head of linked list of routing steps (fm Record-Route) */
295 int route_persistant; /* Is this the "real" route? */
296 char from[256]; /* The From: header */
297 char useragent[256]; /* User agent in SIP request */
298 char context[AST_MAX_EXTENSION]; /* Context for this call */
299 char fromdomain[AST_MAX_EXTENSION]; /* Domain to show in the from field */
300 char fromuser[AST_MAX_EXTENSION]; /* Domain to show in the user field */
301 char tohost[AST_MAX_EXTENSION]; /* Host we should put in the "to" field */
302 char language[MAX_LANGUAGE]; /* Default language for this call */
303 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
304 char rdnis[256]; /* Referring DNIS */
305 char theirtag[256]; /* Their tag */
308 char authname[256]; /* Who we use for authentication */
309 char uri[256]; /* Original requested URI */
310 char peersecret[256];
311 char peermd5secret[256];
312 char callerid[256]; /* Caller*ID */
313 int restrictcid; /* hide presentation from remote user */
315 char fullcontact[128]; /* Extra parameters to go in the "To" header */
316 char accountcode[20]; /* Account code */
317 char our_contact[256]; /* Our contact header */
318 char realm[256]; /* Authorization realm */
319 char nonce[256]; /* Authorization nonce */
320 char opaque[256]; /* Opaque nonsense */
321 char qop[80]; /* Quality of Protection, since SIP wasn't complicated enough yet. */
322 char domain[256]; /* Authorization nonce */
323 char lastmsg[256]; /* Last Message sent/received */
324 int amaflags; /* AMA Flags */
325 int pendinginvite; /* Any pending invite */
326 int needreinvite; /* Do we need to send another reinvite? */
327 int pendingbye; /* Need to send bye after we ack? */
328 int gotrefer; /* Got a refer? */
330 int ospauth; /* Allow OSP Authentication */
331 int osphandle; /* OSP Handle for call */
332 time_t ospstart; /* OSP Start time */
334 struct sip_request initreq; /* Initial request */
336 int maxtime; /* Max time for first response */
337 int initid; /* Auto-congest ID if appropriate */
338 int autokillid; /* Auto-kill ID */
339 time_t lastrtprx; /* Last RTP received */
340 int rtptimeout; /* RTP timeout time */
341 int rtpholdtimeout; /* RTP timeout when on hold */
346 int promiscredir; /* Promiscuous redirection */
354 struct sip_peer *peerpoke; /* If this calls is to poke a peer, which one */
355 struct sip_registry *registry; /* If this is a REGISTER call, to which registry */
356 struct ast_rtp *rtp; /* RTP Session */
357 struct ast_rtp *vrtp; /* Video RTP session */
358 struct sip_pkt *packets; /* Packets scheduled for re-transmission */
359 struct sip_history *history; /* History of this SIP dialog */
360 struct sip_pvt *next; /* Next call in chain */
363 #define FLAG_RESPONSE (1 << 0)
364 #define FLAG_FATAL (1 << 1)
366 /* sip packet - read in sipsock_read, transmitted in send_request */
368 struct sip_pkt *next; /* Next packet */
369 int retrans; /* Retransmission number */
370 int seqno; /* Sequence number */
371 int flags; /* non-zero if this is a response packet (e.g. 200 OK) */
372 struct sip_pvt *owner; /* Owner call */
373 int retransid; /* Retransmission ID */
374 int packetlen; /* Length of packet */
378 /* Structure for SIP user data. User's place calls to us */
380 /* Users who can access various contexts */
386 char accountcode[20];
387 char language[MAX_LANGUAGE];
388 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
389 char useragent[256]; /* User agent in SIP request */
390 unsigned int callgroup;
391 unsigned int pickupgroup;
399 int ospauth; /* Allow OSP Authentication */
413 #endif /* MYSQL_FRIENDS */
414 struct sip_user *next;
417 /* Structure for SIP peer data, we place calls to peers if registred or fixed IP address (host) */
422 char context[80]; /* JK02: peers need context too to allow parking etc */
427 char fullcontact[128];
428 char mailbox[AST_MAX_EXTENSION];
429 char language[MAX_LANGUAGE];
430 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
431 char useragent[256]; /* User agent in SIP request */
442 int ospauth; /* Allow OSP Authentication */
446 unsigned int callgroup;
447 unsigned int pickupgroup;
452 struct sockaddr_in addr;
456 struct sip_pvt *call; /* Call pointer */
457 int pokeexpire; /* When to expire poke */
458 int lastms; /* How long last response took (in ms), or -1 for no response */
459 int maxms; /* Max ms we will accept for the host to be up, 0 to not monitor */
460 struct timeval ps; /* Ping send time */
462 struct sockaddr_in defaddr;
468 struct sip_peer *next;
471 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
472 static int sip_reloading = 0;
474 #define REG_STATE_UNREGISTERED 0
475 #define REG_STATE_REGSENT 1
476 #define REG_STATE_AUTHSENT 2
477 #define REG_STATE_REGISTERED 3
478 #define REG_STATE_REJECTED 4
479 #define REG_STATE_TIMEOUT 5
480 #define REG_STATE_NOAUTH 6
482 #define SIP_NAT_NEVER 0
483 #define SIP_NAT_RFC3581 (1 << 0)
484 #define SIP_NAT_ROUTE (1 << 2)
485 #define SIP_NAT_ALWAYS (SIP_NAT_ROUTE | SIP_NAT_RFC3581)
487 /* sip_registry: Registrations with other SIP proxies */
488 struct sip_registry {
489 int portno; /* Optional port override */
490 char username[80]; /* Who we are registering as */
491 char authuser[80]; /* Who we *authenticate* as */
493 char secret[80]; /* Password or key name in []'s */
495 char contact[80]; /* Contact extension */
497 int expire; /* Sched ID of expiration */
498 int timeout; /* sched id of sip_reg_timeout */
499 int refresh; /* How often to refresh */
500 struct sip_pvt *call; /* create a sip_pvt structure for each outbound "registration call" in progress */
502 int callid_valid; /* 0 means we haven't chosen callid for this registry yet. */
503 char callid[80]; /* Global CallID for this registry */
504 unsigned int ocseq; /* Sequence number we got to for REGISTERs for this registry */
505 struct sockaddr_in us; /* Who the server thinks we are */
506 struct sip_registry *next;
509 /*--- The user list: Users and friends ---*/
510 static struct ast_user_list {
511 struct sip_user *users;
515 /*--- The peer list: Peers and Friends ---*/
516 static struct ast_peer_list {
517 struct sip_peer *peers;
521 /*--- The register list: Other SIP proxys we register with and call ---*/
522 static struct ast_register_list {
523 struct sip_registry *registrations;
529 #define REINVITE_INVITE 1
530 #define REINVITE_UPDATE 2
532 static int __sip_do_register(struct sip_registry *r);
534 static int sipsock = -1;
535 static int global_nat = SIP_NAT_RFC3581;
536 static int global_canreinvite = REINVITE_INVITE;
539 static struct sockaddr_in bindaddr;
540 static struct sockaddr_in externip;
541 static struct ast_ha *localaddr;
543 static struct ast_frame *sip_read(struct ast_channel *ast);
544 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
545 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
546 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
547 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
548 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
549 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);
550 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
551 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
552 static int transmit_message_with_text(struct sip_pvt *p, char *text);
553 static int transmit_refer(struct sip_pvt *p, char *dest);
554 static struct sip_peer *temp_peer(char *name);
555 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
556 static void free_old_route(struct sip_route *route);
557 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
558 static int update_user_counter(struct sip_pvt *fup, int event);
559 static void prune_peers(void);
560 static int sip_do_reload(void);
563 /*--- sip_debug_test_addr: See if we pass debug IP filter */
564 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
568 if (debugaddr.sin_addr.s_addr) {
569 if (((ntohs(debugaddr.sin_port) != 0)
570 && (debugaddr.sin_port != addr->sin_port))
571 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
577 static inline int sip_debug_test_pvt(struct sip_pvt *p)
581 return sip_debug_test_addr(((p->nat & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
585 /*--- __sip_xmit: Transmit SIP message ---*/
586 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
589 char iabuf[INET_ADDRSTRLEN];
590 if (p->nat & SIP_NAT_ROUTE)
591 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
593 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
595 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));
600 static void sip_destroy(struct sip_pvt *p);
602 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
603 /* Only used for outbound registrations */
604 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
607 * Using the localaddr structure built up with localnet statements
608 * apply it to their address to see if we need to substitute our
609 * externip or can get away with our internal bindaddr
611 struct sockaddr_in theirs;
612 theirs.sin_addr = *them;
613 if (localaddr && externip.sin_addr.s_addr &&
614 ast_apply_ha(localaddr, &theirs)) {
615 char iabuf[INET_ADDRSTRLEN];
616 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
617 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
618 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
620 else if (bindaddr.sin_addr.s_addr)
621 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
623 return ast_ouraddrfor(them, us);
627 static int append_history(struct sip_pvt *p, char *event, char *data)
629 struct sip_history *hist, *prev;
633 hist = malloc(sizeof(struct sip_history));
635 memset(hist, 0, sizeof(struct sip_history));
636 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
640 if ((*c == '\r') || (*c == '\n')) {
646 /* Enqueue into history */
659 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
660 static int retrans_pkt(void *data)
662 struct sip_pkt *pkt=data, *prev, *cur;
664 char iabuf[INET_ADDRSTRLEN];
665 ast_mutex_lock(&pkt->owner->lock);
666 if (pkt->retrans < MAX_RETRANS) {
668 if (sip_debug_test_pvt(pkt->owner)) {
669 if (pkt->owner->nat & SIP_NAT_ROUTE)
670 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));
672 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));
674 append_history(pkt->owner, "ReTx", pkt->data);
675 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
678 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");
679 append_history(pkt->owner, "MaxRetries", pkt->flags & FLAG_FATAL ? "(Critical)" : "(Non-critical)");
681 if (pkt->flags & FLAG_FATAL) {
682 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
683 ast_mutex_unlock(&pkt->owner->lock);
685 ast_mutex_lock(&pkt->owner->lock);
687 if (pkt->owner->owner) {
688 ast_queue_hangup(pkt->owner->owner);
689 ast_mutex_unlock(&pkt->owner->owner->lock);
691 /* If no owner, destroy now */
692 pkt->owner->needdestroy = 1;
695 /* In any case, go ahead and remove the packet */
697 cur = pkt->owner->packets;
706 prev->next = cur->next;
708 pkt->owner->packets = cur->next;
709 ast_mutex_unlock(&pkt->owner->lock);
713 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
716 ast_mutex_unlock(&pkt->owner->lock);
720 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
721 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
724 pkt = malloc(sizeof(struct sip_pkt) + len + 1);
727 memset(pkt, 0, sizeof(struct sip_pkt));
728 memcpy(pkt->data, data, len);
729 pkt->packetlen = len;
730 pkt->next = p->packets;
734 pkt->data[len] = '\0';
736 pkt->flags |= FLAG_FATAL;
737 /* Schedule retransmission */
738 pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
739 pkt->next = p->packets;
741 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
742 if (!strncasecmp(pkt->data, "INVITE", 6)) {
743 /* Note this is a pending invite */
744 p->pendinginvite = seqno;
749 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
750 static int __sip_autodestruct(void *data)
752 struct sip_pvt *p = data;
754 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
755 append_history(p, "AutoDestroy", "");
757 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
758 ast_queue_hangup(p->owner);
765 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
766 static int sip_scheddestroy(struct sip_pvt *p, int ms)
769 if (sip_debug_test_pvt(p))
770 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
772 snprintf(tmp, sizeof(tmp), "%d ms", ms);
773 append_history(p, "SchedDestroy", tmp);
775 if (p->autokillid > -1)
776 ast_sched_del(sched, p->autokillid);
777 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
781 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
782 static int sip_cancel_destroy(struct sip_pvt *p)
784 if (p->autokillid > -1)
785 ast_sched_del(sched, p->autokillid);
786 append_history(p, "CancelDestroy", "");
791 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
792 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
794 struct sip_pkt *cur, *prev = NULL;
797 /* Just in case... */
798 if (!msg) msg = "___NEVER___";
801 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp) &&
802 ((cur->flags & FLAG_RESPONSE) ||
803 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
804 if (!resp && (seqno == p->pendinginvite)) {
805 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
806 p->pendinginvite = 0;
809 /* this is our baby */
811 prev->next = cur->next;
813 p->packets = cur->next;
814 if (cur->retransid > -1)
815 ast_sched_del(sched, cur->retransid);
823 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
827 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
828 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
834 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp) &&
835 ((cur->flags & FLAG_RESPONSE) ||
836 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
837 /* this is our baby */
838 if (cur->retransid > -1)
839 ast_sched_del(sched, cur->retransid);
846 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");
850 static void parse(struct sip_request *req);
851 static char *get_header(struct sip_request *req, char *name);
852 static void copy_request(struct sip_request *dst,struct sip_request *src);
854 static void parse_copy(struct sip_request *dst, struct sip_request *src)
856 memset(dst, 0, sizeof(*dst));
857 memcpy(dst->data, src->data, sizeof(dst->data));
861 /*--- send_response: Transmit response on SIP request---*/
862 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
865 char iabuf[INET_ADDRSTRLEN];
866 struct sip_request tmp;
868 if (sip_debug_test_pvt(p)) {
869 if (p->nat & SIP_NAT_ROUTE)
870 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));
872 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));
876 parse_copy(&tmp, req);
877 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
878 append_history(p, "TxRespRel", tmpmsg);
880 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1));
883 parse_copy(&tmp, req);
884 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
885 append_history(p, "TxResp", tmpmsg);
887 res = __sip_xmit(p, req->data, req->len);
894 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
895 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
898 char iabuf[INET_ADDRSTRLEN];
899 struct sip_request tmp;
901 if (sip_debug_test_pvt(p)) {
902 if (p->nat & SIP_NAT_ROUTE)
903 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));
905 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));
909 parse_copy(&tmp, req);
910 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
911 append_history(p, "TxReqRel", tmpmsg);
913 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1));
916 parse_copy(&tmp, req);
917 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
918 append_history(p, "TxReq", tmpmsg);
920 res = __sip_xmit(p, req->data, req->len);
925 /*--- url_decode: Decode SIP URL ---*/
926 static void url_decode(char *s)
934 if (sscanf(s + 1, "%2x", &tmp) == 1) {
936 s += 2; /* Will be incremented once more when we break out */
940 /* Fall through if something wasn't right with the formatting */
950 /*--- ditch_braces: Pick out text in braces from character string ---*/
951 static char *ditch_braces(char *tmp)
956 if ((q = strchr(tmp, '"')) ) {
958 if ((q = strchr(c, '"')) )
961 ast_log(LOG_WARNING, "No closing quote in '%s'\n", tmp);
965 if ((n = strchr(c, '<')) ) {
967 while(*c && *c != '>') c++;
969 ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
978 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
979 /* Called from PBX core text message functions */
980 static int sip_sendtext(struct ast_channel *ast, char *text)
982 struct sip_pvt *p = ast->pvt->pvt;
983 int debug=sip_debug_test_pvt(p);
986 ast_verbose("Sending text %s on %s\n", text, ast->name);
989 if (!text || ast_strlen_zero(text))
992 ast_verbose("Really sending text %s on %s\n", text, ast->name);
993 transmit_message_with_text(p, text);
999 /* Ehud Gavron 08-Jun-2004: */
1000 /* The Mysql stuff works great for peers but not for users. */
1001 /* Unfortunately multi-line phones (e.g. cisco 7960) and many */
1002 /* SIP users behind the same NAT gateway need users. So.... */
1004 /* mysql_update_user is not needed */
1005 /*--- mysql_host: Get user from database ---*/
1006 static struct sip_user *mysql_user(char *user)
1010 u = malloc(sizeof(struct sip_user));
1011 memset(u, 0, sizeof(struct sip_user));
1012 if (mysql && (!user || (strlen(user) < 128))) {
1016 time_t regseconds, nowtime;
1018 MYSQL_FIELD *fields;
1021 name = alloca(strlen(user) * 2 + 1);
1022 mysql_real_escape_string(mysql, name, user, strlen(user));
1025 snprintf(query, sizeof(query), "SELECT name, secret, context, username, ipaddr, port, regseconds, callerid, restrictcid FROM sipfriends WHERE name=\"%s\"", name);
1027 ast_mutex_lock(&mysqllock);
1028 mysql_query(mysql, query);
1029 if ((result = mysql_store_result(mysql))) {
1031 if ((rowval = mysql_fetch_row(result))) {
1032 numfields = mysql_num_fields(result);
1033 fields = mysql_fetch_fields(result);
1035 for (x=0;x<numfields;x++) {
1037 if (!strcasecmp(fields[x].name, "secret")) {
1038 strncpy(u->secret, rowval[x], sizeof(u->secret) - 1);
1039 } else if (!strcasecmp(fields[x].name, "name")) {
1040 strncpy(u->name, rowval[x], sizeof(u->name) - 1);
1041 } else if (!strcasecmp(fields[x].name, "context")) {
1042 strncpy(u->context, rowval[x], sizeof(u->context) - 1);
1043 } else if (!strcasecmp(fields[x].name, "username")) {
1044 strncpy(u->name, rowval[x], sizeof(u->name) - 1);
1045 } else if (!strcasecmp(fields[x].name, "regseconds")) {
1046 if (sscanf(rowval[x], "%li", ®seconds) != 1)
1048 } else if (!strcasecmp(fields[x].name, "restrictcid")) {
1050 } else if (!strcasecmp(fields[x].name, "callerid")) {
1051 strncpy(u->callerid, rowval[x], sizeof(u->callerid) - 1);
1058 mysql_free_result(result);
1061 ast_mutex_unlock(&mysqllock);
1067 u->capability = global_capability;
1068 u->nat = global_nat;
1069 u->dtmfmode = global_dtmfmode;
1075 #endif /* MYSQL_USERS */
1077 #ifdef MYSQL_FRIENDS
1078 /*--- mysql_update_peer: Update peer from database ---*/
1079 /* This function adds registration state to database */
1080 static void mysql_update_peer(char *peer, struct sockaddr_in *sin, char *username, int expiry)
1082 if (mysql && (strlen(peer) < 128)) {
1086 char iabuf[INET_ADDRSTRLEN];
1088 name = alloca(strlen(peer) * 2 + 1);
1089 uname = alloca(strlen(username) * 2 + 1);
1091 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1092 mysql_real_escape_string(mysql, uname, username, strlen(username));
1093 snprintf(query, sizeof(query), "UPDATE sipfriends SET ipaddr=\"%s\", port=\"%d\", regseconds=\"%ld\", username=\"%s\" WHERE name=\"%s\"",
1094 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr), ntohs(sin->sin_port), nowtime + expiry, uname, name);
1095 ast_mutex_lock(&mysqllock);
1096 if (mysql_real_query(mysql, query, strlen(query)))
1097 ast_log(LOG_WARNING, "Unable to update database\n");
1099 ast_mutex_unlock(&mysqllock);
1103 /*--- mysql_peer: Get peer from database ---*/
1104 static struct sip_peer *mysql_peer(char *peer, struct sockaddr_in *sin)
1109 p = malloc(sizeof(struct sip_peer));
1110 memset(p, 0, sizeof(struct sip_peer));
1111 if (mysql && (!peer || (strlen(peer) < 128))) {
1116 char iabuf[INET_ADDRSTRLEN];
1117 time_t regseconds, nowtime;
1119 MYSQL_FIELD *fields;
1122 name = alloca(strlen(peer) * 2 + 1);
1123 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1126 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));
1128 snprintf(query, sizeof(query), "SELECT name, secret, context, username, ipaddr, port, regseconds FROM sipfriends WHERE name=\"%s\"", name);
1129 ast_mutex_lock(&mysqllock);
1130 mysql_query(mysql, query);
1131 if ((result = mysql_store_result(mysql))) {
1132 if ((rowval = mysql_fetch_row(result))) {
1133 numfields = mysql_num_fields(result);
1134 fields = mysql_fetch_fields(result);
1136 p->addr.sin_family = AF_INET;
1137 for (x=0;x<numfields;x++) {
1139 if (!strcasecmp(fields[x].name, "secret")) {
1140 strncpy(p->secret, rowval[x], sizeof(p->secret) - 1);
1141 } else if (!strcasecmp(fields[x].name, "name")) {
1142 strncpy(p->name, rowval[x], sizeof(p->name) - 1);
1143 } else if (!strcasecmp(fields[x].name, "context")) {
1144 strncpy(p->context, rowval[x], sizeof(p->context) - 1);
1145 } else if (!strcasecmp(fields[x].name, "username")) {
1146 strncpy(p->username, rowval[x], sizeof(p->username) - 1);
1147 } else if (!strcasecmp(fields[x].name, "ipaddr")) {
1148 inet_aton(rowval[x], &p->addr.sin_addr);
1149 } else if (!strcasecmp(fields[x].name, "port")) {
1150 if (sscanf(rowval[x], "%i", &port) != 1)
1152 p->addr.sin_port = htons(port);
1153 } else if (!strcasecmp(fields[x].name, "regseconds")) {
1154 if (sscanf(rowval[x], "%li", ®seconds) != 1)
1160 if (nowtime > regseconds)
1161 memset(&p->addr, 0, sizeof(p->addr));
1163 mysql_free_result(result);
1166 ast_mutex_unlock(&mysqllock);
1173 p->capability = global_capability;
1174 p->nat = global_nat;
1175 p->dtmfmode = global_dtmfmode;
1176 p->promiscredir = global_promiscredir;
1184 #endif /* MYSQL_FRIENDS */
1186 /*--- update_peer: Update peer data in database (if used) ---*/
1187 static void update_peer(struct sip_peer *p, int expiry)
1189 #ifdef MYSQL_FRIENDS
1191 mysql_update_peer(p->name, &p->addr, p->username, expiry);
1196 /*--- find_peer: Locate peer by name or ip address */
1197 static struct sip_peer *find_peer(char *peer, struct sockaddr_in *sin)
1199 struct sip_peer *p = NULL;
1203 /* Find by peer name */
1205 if (!strcasecmp(p->name, peer)) {
1214 if (!inaddrcmp(&p->addr, sin) ||
1216 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr))) {
1223 #ifdef MYSQL_FRIENDS
1225 p = mysql_peer(peer, sin);
1232 /*--- find_user: Locate user by name */
1233 static struct sip_user *find_user(char *name)
1235 struct sip_user *u = NULL;
1239 if (!strcasecmp(u->name, name)) {
1246 u = mysql_user(name);
1248 #endif /* MYSQL_USERS */
1252 /*--- create_addr: create address structure from peer definition ---*/
1253 /* Or, if peer not found, find it in the global DNS */
1254 /* returns TRUE on failure, FALSE on success */
1255 static int create_addr(struct sip_pvt *r, char *opeer)
1258 struct ast_hostent ahp;
1263 char host[256], *hostn;
1266 strncpy(peer, opeer, sizeof(peer) - 1);
1267 port = strchr(peer, ':');
1272 r->sa.sin_family = AF_INET;
1273 ast_mutex_lock(&peerl.lock);
1274 p = find_peer(peer, NULL);
1278 r->capability = p->capability;
1281 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (r->nat & SIP_NAT_ROUTE));
1282 ast_rtp_setnat(r->rtp, (r->nat & SIP_NAT_ROUTE));
1285 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (r->nat & SIP_NAT_ROUTE));
1286 ast_rtp_setnat(r->vrtp, (r->nat & SIP_NAT_ROUTE));
1288 strncpy(r->peername, p->username, sizeof(r->peername)-1);
1289 strncpy(r->authname, p->username, sizeof(r->authname)-1);
1290 strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1291 strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1292 strncpy(r->username, p->username, sizeof(r->username)-1);
1293 strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1294 strncpy(r->fullcontact, p->fullcontact, sizeof(r->fullcontact)-1);
1295 if (ast_strlen_zero(r->tohost)) {
1296 if (p->addr.sin_addr.s_addr)
1297 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->addr.sin_addr);
1299 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->defaddr.sin_addr);
1301 if (!ast_strlen_zero(p->fromdomain))
1302 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1303 if (!ast_strlen_zero(p->fromuser))
1304 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1305 r->insecure = p->insecure;
1306 r->canreinvite = p->canreinvite;
1307 r->maxtime = p->maxms;
1308 r->callgroup = p->callgroup;
1309 r->pickupgroup = p->pickupgroup;
1311 r->dtmfmode = p->dtmfmode;
1312 if (r->dtmfmode & SIP_DTMF_RFC2833)
1313 r->noncodeccapability |= AST_RTP_DTMF;
1315 r->noncodeccapability &= ~AST_RTP_DTMF;
1317 r->promiscredir = p->promiscredir;
1318 strncpy(r->context, p->context,sizeof(r->context)-1);
1319 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1320 (!p->maxms || ((p->lastms > 0) && (p->lastms <= p->maxms)))) {
1321 if (p->addr.sin_addr.s_addr) {
1322 r->sa.sin_addr = p->addr.sin_addr;
1323 r->sa.sin_port = p->addr.sin_port;
1325 r->sa.sin_addr = p->defaddr.sin_addr;
1326 r->sa.sin_port = p->defaddr.sin_port;
1328 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1339 ast_mutex_unlock(&peerl.lock);
1343 portno = atoi(port);
1345 portno = DEFAULT_SIP_PORT;
1350 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1351 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1357 hp = ast_gethostbyname(hostn, &ahp);
1359 strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1360 memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1361 r->sa.sin_port = htons(portno);
1362 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1365 ast_log(LOG_WARNING, "No such host: %s\n", peer);
1381 /*--- auto_congest: Scheduled congestion on a call ---*/
1382 static int auto_congest(void *nothing)
1384 struct sip_pvt *p = nothing;
1385 ast_mutex_lock(&p->lock);
1388 if (!ast_mutex_trylock(&p->owner->lock)) {
1389 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1390 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1391 ast_mutex_unlock(&p->owner->lock);
1394 ast_mutex_unlock(&p->lock);
1398 /*--- sip_prefs_free: Free codec list in preference structure ---*/
1399 static void sip_prefs_free(void)
1401 struct sip_codec_pref *cur, *next;
1411 /*--- sip_pref_remove: Remove codec from pref list ---*/
1412 static void sip_pref_remove(int format)
1414 struct sip_codec_pref *cur, *prev=NULL;
1417 if (cur->codec == format) {
1419 prev->next = cur->next;
1430 /*--- sip_pref_append: Append codec to list ---*/
1431 static int sip_pref_append(int format)
1433 struct sip_codec_pref *cur, *tmp;
1434 sip_pref_remove(format);
1435 tmp = (struct sip_codec_pref *)malloc(sizeof(struct sip_codec_pref));
1438 memset(tmp, 0, sizeof(struct sip_codec_pref));
1439 tmp->codec = format;
1450 /*--- sip_codec_choose: Pick a codec ---*/
1451 static int sip_codec_choose(int formats)
1453 struct sip_codec_pref *cur;
1454 formats &= ((AST_FORMAT_MAX_AUDIO << 1) - 1);
1457 if (formats & cur->codec)
1461 return ast_best_codec(formats);
1464 /*--- sip_call: Initiate SIP call from PBX ---*/
1465 /* used from the dial() application */
1466 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1470 char *vxml_url = NULL;
1471 char *distinctive_ring = NULL;
1472 char *osptoken = NULL;
1474 char *osphandle = NULL;
1476 struct varshead *headp;
1477 struct ast_var_t *current;
1480 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1481 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1484 /* Check whether there is vxml_url, distinctive ring variables */
1486 headp=&ast->varshead;
1487 AST_LIST_TRAVERSE(headp,current,entries) {
1488 /* Check whether there is a VXML_URL variable */
1489 if (strcasecmp(ast_var_name(current),"VXML_URL")==0)
1491 vxml_url = ast_var_value(current);
1493 /* Check whether there is a ALERT_INFO variable */
1494 if (strcasecmp(ast_var_name(current),"ALERT_INFO")==0)
1496 distinctive_ring = ast_var_value(current);
1499 else if (!strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1500 osptoken = ast_var_value(current);
1501 } else if (!strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1502 osphandle = ast_var_value(current);
1510 if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1511 /* Force Disable OSP support */
1517 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1518 res = update_user_counter(p,INC_OUT_USE);
1520 p->restrictcid = ast->restrictcid;
1521 p->jointcapability = p->capability;
1522 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, 1);
1524 /* Initialize auto-congest time */
1525 p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1531 /*--- __sip_destroy: Execute destrucion of call structure, release memory---*/
1532 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1534 struct sip_pvt *cur, *prev = NULL;
1536 struct sip_history *hist;
1538 if (sip_debug_test_pvt(p))
1539 ast_verbose("Destroying call '%s'\n", p->callid);
1540 if (p->stateid > -1)
1541 ast_extension_state_del(p->stateid, NULL);
1543 ast_sched_del(sched, p->initid);
1544 if (p->autokillid > -1)
1545 ast_sched_del(sched, p->autokillid);
1548 ast_rtp_destroy(p->rtp);
1551 ast_rtp_destroy(p->vrtp);
1554 free_old_route(p->route);
1558 /* Carefully unlink from registry */
1559 struct sip_registry *reg;
1560 ast_mutex_lock(®l.lock);
1561 reg = regl.registrations;
1563 if ((reg == p->registry) && (p->registry->call == p))
1564 p->registry->call=NULL;
1567 ast_mutex_unlock(®l.lock);
1569 /* Unlink us from the owner if we have one */
1572 ast_mutex_lock(&p->owner->lock);
1573 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1574 p->owner->pvt->pvt = NULL;
1576 ast_mutex_unlock(&p->owner->lock);
1581 p->history = p->history->next;
1588 prev->next = cur->next;
1597 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1600 ast_sched_del(sched, p->initid);
1601 while((cp = p->packets)) {
1602 p->packets = p->packets->next;
1603 if (cp->retransid > -1)
1604 ast_sched_del(sched, cp->retransid);
1607 ast_mutex_destroy(&p->lock);
1612 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1613 /* Note: This is going to be replaced by app_groupcount */
1614 static int update_user_counter(struct sip_pvt *fup, int event)
1616 char name[256] = "";
1618 strncpy(name, fup->username, sizeof(name) - 1);
1619 ast_mutex_lock(&userl.lock);
1620 u = find_user(name);
1622 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1623 ast_mutex_unlock(&userl.lock);
1627 /* incoming and outgoing affects the inUse counter */
1630 if ( u->inUse > 0 ) {
1638 if (u->incominglimit > 0 ) {
1639 if (u->inUse >= u->incominglimit) {
1640 ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1641 /* inc inUse as well */
1642 if ( event == INC_OUT_USE ) {
1645 ast_mutex_unlock(&userl.lock);
1650 ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1652 /* we don't use these anymore
1654 if ( u->outUse > 0 ) {
1661 if ( u->outgoinglimit > 0 ) {
1662 if ( u->outUse >= u->outgoinglimit ) {
1663 ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1664 ast_mutex_unlock(&userl.lock);
1672 ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1674 ast_mutex_unlock(&userl.lock);
1678 /*--- sip_destroy: Destroy SIP call structure ---*/
1679 static void sip_destroy(struct sip_pvt *p)
1681 ast_mutex_lock(&iflock);
1682 __sip_destroy(p, 1);
1683 ast_mutex_unlock(&iflock);
1687 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1689 static int hangup_sip2cause(int cause)
1691 /* Possible values from causes.h
1692 AST_CAUSE_NOTDEFINED AST_CAUSE_NORMAL AST_CAUSE_BUSY
1693 AST_CAUSE_FAILURE AST_CAUSE_CONGESTION AST_CAUSE_UNALLOCATED
1697 case 404: /* Not found */
1698 return AST_CAUSE_UNALLOCATED;
1699 case 483: /* Too many hops */
1700 return AST_CAUSE_FAILURE;
1702 return AST_CAUSE_BUSY;
1704 return AST_CAUSE_NORMAL;
1710 static char *hangup_cause2sip(int cause)
1714 case AST_CAUSE_FAILURE:
1715 return "500 Server internal failure";
1716 case AST_CAUSE_CONGESTION:
1717 return "503 Service Unavailable";
1718 case AST_CAUSE_BUSY:
1727 /*--- sip_hangup: Hangup SIP call */
1728 static int sip_hangup(struct ast_channel *ast)
1730 struct sip_pvt *p = ast->pvt->pvt;
1732 int needdestroy = 0;
1734 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1735 if (!ast->pvt->pvt) {
1736 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1739 ast_mutex_lock(&p->lock);
1741 if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1742 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1745 if ( p->outgoing ) {
1746 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1747 update_user_counter(p, DEC_OUT_USE);
1749 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1750 update_user_counter(p, DEC_IN_USE);
1752 /* Determine how to disconnect */
1753 if (p->owner != ast) {
1754 ast_log(LOG_WARNING, "Huh? We aren't the owner?\n");
1755 ast_mutex_unlock(&p->lock);
1758 if (!ast || (ast->_state != AST_STATE_UP))
1763 ast_dsp_free(p->vad);
1766 ast->pvt->pvt = NULL;
1768 ast_mutex_lock(&usecnt_lock);
1770 ast_mutex_unlock(&usecnt_lock);
1771 ast_update_use_count();
1774 /* Start the process if it's not already started */
1775 if (!p->alreadygone && !ast_strlen_zero(p->initreq.data)) {
1778 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1779 /* Actually don't destroy us yet, wait for the 487 on our original
1780 INVITE, but do set an autodestruct just in case we never get it. */
1782 sip_scheddestroy(p, 15000);
1783 if ( p->initid != -1 ) {
1784 /* channel still up - reverse dec of inUse counter
1785 only if the channel is not auto-congested */
1786 if ( p->outgoing ) {
1787 update_user_counter(p, INC_OUT_USE);
1790 update_user_counter(p, INC_IN_USE);
1795 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1796 transmit_response_reliable(p, res, &p->initreq, 1);
1798 transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1801 if (!p->pendinginvite) {
1803 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1805 /* Note we will need a BYE when this all settles out
1806 but we can't send one while we have "INVITE" outstanding. */
1808 p->needreinvite = 0;
1812 p->needdestroy = needdestroy;
1813 ast_mutex_unlock(&p->lock);
1817 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1818 static int sip_answer(struct ast_channel *ast)
1822 struct sip_pvt *p = ast->pvt->pvt;
1824 ast_mutex_lock(&p->lock);
1825 if (ast->_state != AST_STATE_UP) {
1830 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1832 fmt=ast_getformatbyname(codec);
1834 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1835 p->jointcapability=fmt;
1836 } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1839 ast_setstate(ast, AST_STATE_UP);
1841 ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1842 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1844 ast_mutex_unlock(&p->lock);
1848 /*--- sip_write: Send response, support audio media ---*/
1849 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1851 struct sip_pvt *p = ast->pvt->pvt;
1853 if (frame->frametype == AST_FRAME_VOICE) {
1854 if (!(frame->subclass & ast->nativeformats)) {
1855 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1856 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1860 ast_mutex_lock(&p->lock);
1862 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1863 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1866 res = ast_rtp_write(p->rtp, frame);
1868 ast_mutex_unlock(&p->lock);
1870 } else if (frame->frametype == AST_FRAME_VIDEO) {
1872 ast_mutex_lock(&p->lock);
1874 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1875 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1878 res = ast_rtp_write(p->vrtp, frame);
1880 ast_mutex_unlock(&p->lock);
1882 } else if (frame->frametype == AST_FRAME_IMAGE) {
1885 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1892 /*--- sip_fixup: Fix up a channel: If a channel is consumed, this is called.
1893 Basically update any ->owner links ----*/
1894 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1896 struct sip_pvt *p = newchan->pvt->pvt;
1897 ast_mutex_lock(&p->lock);
1898 if (p->owner != oldchan) {
1899 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1900 ast_mutex_unlock(&p->lock);
1904 ast_mutex_unlock(&p->lock);
1908 /*--- sip_senddigit: Send DTMF character on SIP channel */
1909 /* within one call, we're able to transmit in many methods simultaneously */
1910 static int sip_senddigit(struct ast_channel *ast, char digit)
1912 struct sip_pvt *p = ast->pvt->pvt;
1913 if (p && (p->dtmfmode & SIP_DTMF_INFO)) {
1914 transmit_info_with_digit(p, digit);
1916 if (p && p->rtp && (p->dtmfmode & SIP_DTMF_RFC2833)) {
1917 ast_rtp_senddigit(p->rtp, digit);
1919 /* If in-band DTMF is desired, send that */
1920 if (p->dtmfmode & SIP_DTMF_INBAND)
1926 /*--- sip_transfer: Transfer SIP call */
1927 static int sip_transfer(struct ast_channel *ast, char *dest)
1929 struct sip_pvt *p = ast->pvt->pvt;
1931 res = transmit_refer(p, dest);
1935 /*--- sip_indicate: Play indication to user */
1936 /* With SIP a lot of indications is sent as messages, letting the device play
1937 the indication - busy signal, congestion etc */
1938 static int sip_indicate(struct ast_channel *ast, int condition)
1940 struct sip_pvt *p = ast->pvt->pvt;
1942 case AST_CONTROL_RINGING:
1943 if (ast->_state == AST_STATE_RING) {
1945 transmit_response(p, "180 Ringing", &p->initreq);
1947 if (!p->progressinband)
1950 /* Oops, we've sent progress tones. Let Asterisk do it instead */
1954 case AST_CONTROL_BUSY:
1955 if (ast->_state != AST_STATE_UP) {
1956 transmit_response(p, "486 Busy Here", &p->initreq);
1958 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1962 case AST_CONTROL_CONGESTION:
1963 if (ast->_state != AST_STATE_UP) {
1964 transmit_response(p, "503 Service Unavailable", &p->initreq);
1966 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1970 case AST_CONTROL_PROGRESS:
1971 case AST_CONTROL_PROCEEDING:
1972 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1973 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1981 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1989 /*--- sip_new: Initiate a call in the SIP channel */
1990 /* called from sip_request_call (calls from the pbx ) */
1991 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1993 struct ast_channel *tmp;
1995 ast_mutex_unlock(&i->lock);
1996 /* Don't hold a sip pvt lock while we allocate a channel */
1997 tmp = ast_channel_alloc(1);
1998 ast_mutex_lock(&i->lock);
2000 /* Select our native format based on codec preference until we receive
2001 something from another device to the contrary. */
2002 if (i->jointcapability)
2003 tmp->nativeformats = sip_codec_choose(i->jointcapability);
2004 else if (i->capability)
2005 tmp->nativeformats = sip_codec_choose(i->capability);
2007 tmp->nativeformats = sip_codec_choose(global_capability);
2008 fmt = ast_best_codec(tmp->nativeformats);
2010 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2012 if (strchr(i->fromdomain,':'))
2014 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2018 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2021 if (i->dtmfmode & SIP_DTMF_INBAND) {
2022 i->vad = ast_dsp_new();
2023 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2025 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2027 tmp->fds[0] = ast_rtp_fd(i->rtp);
2028 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2030 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2031 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2033 if (state == AST_STATE_RING)
2035 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2036 tmp->writeformat = fmt;
2037 tmp->pvt->rawwriteformat = fmt;
2038 tmp->readformat = fmt;
2039 tmp->pvt->rawreadformat = fmt;
2041 tmp->pvt->send_text = sip_sendtext;
2042 tmp->pvt->call = sip_call;
2043 tmp->pvt->hangup = sip_hangup;
2044 tmp->pvt->answer = sip_answer;
2045 tmp->pvt->read = sip_read;
2046 tmp->pvt->write = sip_write;
2047 tmp->pvt->write_video = sip_write;
2048 tmp->pvt->indicate = sip_indicate;
2049 tmp->pvt->transfer = sip_transfer;
2050 tmp->pvt->fixup = sip_fixup;
2051 tmp->pvt->send_digit = sip_senddigit;
2053 tmp->pvt->bridge = ast_rtp_bridge;
2055 tmp->callgroup = i->callgroup;
2056 tmp->pickupgroup = i->pickupgroup;
2057 tmp->restrictcid = i->restrictcid;
2058 if (!ast_strlen_zero(i->accountcode))
2059 strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2061 tmp->amaflags = i->amaflags;
2062 if (!ast_strlen_zero(i->language))
2063 strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2064 if (!ast_strlen_zero(i->musicclass))
2065 strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2067 ast_mutex_lock(&usecnt_lock);
2069 ast_mutex_unlock(&usecnt_lock);
2070 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2071 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2072 if (!ast_strlen_zero(i->callerid))
2073 tmp->callerid = strdup(i->callerid);
2074 if (!ast_strlen_zero(i->rdnis))
2075 tmp->rdnis = strdup(i->rdnis);
2076 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2077 tmp->dnid = strdup(i->exten);
2079 if (!ast_strlen_zero(i->domain)) {
2080 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2082 if (!ast_strlen_zero(i->useragent)) {
2083 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2085 if (!ast_strlen_zero(i->callid)) {
2086 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2088 ast_setstate(tmp, state);
2089 if (state != AST_STATE_DOWN) {
2090 if (ast_pbx_start(tmp)) {
2091 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2097 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2101 static struct cfalias {
2105 { "Content-Type", "c" },
2106 { "Content-Encoding", "e" },
2110 { "Content-Length", "l" },
2113 { "Supported", "k" },
2114 { "Refer-To", "r" },
2115 { "Allow-Events", "u" },
2120 /*--- get_sdp_by_line: Reads one line of SIP message body */
2121 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2122 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2123 char* r = line + nameLen + 1;
2124 while (*r && (*r < 33)) ++r;
2131 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2132 but the name wrongly applies _only_ sdp */
2133 static char *get_sdp(struct sip_request *req, char *name) {
2135 int len = strlen(name);
2138 for (x=0; x<req->lines; x++) {
2139 r = get_sdp_by_line(req->line[x], name, len);
2140 if (r[0] != '\0') return r;
2146 static void sdpLineNum_iterator_init(int* iterator) {
2150 static char* get_sdp_iterate(int* iterator,
2151 struct sip_request *req, char *name) {
2152 int len = strlen(name);
2154 while (*iterator < req->lines) {
2155 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2156 if (r[0] != '\0') return r;
2161 static char *__get_header(struct sip_request *req, char *name, int *start)
2164 int len = strlen(name);
2166 for (x=*start;x<req->headers;x++) {
2167 if (!strncasecmp(req->header[x], name, len) &&
2168 (req->header[x][len] == ':')) {
2169 r = req->header[x] + len + 1;
2170 while(*r && (*r < 33))
2177 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2178 if (!strcasecmp(aliases[x].fullname, name))
2179 return __get_header(req, aliases[x].shortname, start);
2181 /* Don't return NULL, so get_header is always a valid pointer */
2185 /*--- get_header: Get header from SIP request ---*/
2186 static char *get_header(struct sip_request *req, char *name)
2189 return __get_header(req, name, &start);
2192 /*--- sip_rtp_read: Read RTP from network ---*/
2193 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2195 /* Retrieve audio/etc from channel. Assumes p->lock is already held. */
2196 struct ast_frame *f;
2197 static struct ast_frame null_frame = { AST_FRAME_NULL, };
2200 f = ast_rtp_read(p->rtp); /* RTP Audio */
2203 f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
2206 f = ast_rtp_read(p->vrtp); /* RTP Video */
2209 f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */
2214 /* Don't send RFC2833 if we're not supposed to */
2215 if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & SIP_DTMF_RFC2833))
2218 /* We already hold the channel lock */
2219 if (f->frametype == AST_FRAME_VOICE) {
2220 if (f->subclass != p->owner->nativeformats) {
2221 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2222 p->owner->nativeformats = f->subclass;
2223 ast_set_read_format(p->owner, p->owner->readformat);
2224 ast_set_write_format(p->owner, p->owner->writeformat);
2226 if ((p->dtmfmode & SIP_DTMF_INBAND) && p->vad) {
2227 f = ast_dsp_process(p->owner,p->vad,f);
2228 if (f && (f->frametype == AST_FRAME_DTMF))
2229 ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2236 /*--- sip_read: Read SIP RTP from channel */
2237 static struct ast_frame *sip_read(struct ast_channel *ast)
2239 struct ast_frame *fr;
2240 struct sip_pvt *p = ast->pvt->pvt;
2241 ast_mutex_lock(&p->lock);
2242 fr = sip_rtp_read(ast, p);
2243 time(&p->lastrtprx);
2244 ast_mutex_unlock(&p->lock);
2248 /*--- build_callid: Build SIP CALLID header ---*/
2249 static void build_callid(char *callid, int len, struct in_addr ourip)
2254 char iabuf[INET_ADDRSTRLEN];
2257 res = snprintf(callid, len, "%08x", val);
2261 /* It's not important that we really use our right IP here... */
2262 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2265 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2266 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2269 char iabuf[INET_ADDRSTRLEN];
2271 p = malloc(sizeof(struct sip_pvt));
2274 /* Keep track of stuff */
2275 memset(p, 0, sizeof(struct sip_pvt));
2276 ast_mutex_init(&p->lock);
2284 memcpy(&p->sa, sin, sizeof(p->sa));
2285 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2286 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2288 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2290 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2292 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2296 /* Start with 101 instead of 1 */
2299 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2300 ast_mutex_destroy(&p->lock);
2304 ast_rtp_settos(p->rtp, tos);
2306 ast_rtp_settos(p->vrtp, tos);
2307 if (useglobal_nat && sin) {
2308 /* Setup NAT structure according to global settings if we have an address */
2309 p->nat = global_nat;
2310 memcpy(&p->recv, sin, sizeof(p->recv));
2311 ast_rtp_setnat(p->rtp, (p->nat & SIP_NAT_ROUTE));
2313 ast_rtp_setnat(p->vrtp, (p->nat & SIP_NAT_ROUTE));
2316 /* z9hG4bK is a magic cookie. See RFC 3261 section 8.1.1.7 */
2317 if (p->nat != SIP_NAT_NEVER)
2318 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);
2320 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);
2322 build_callid(p->callid, sizeof(p->callid), p->ourip);
2324 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2325 /* Assume reinvite OK and via INVITE */
2326 p->canreinvite = global_canreinvite;
2327 /* Assign default music on hold class */
2328 strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2329 p->dtmfmode = global_dtmfmode;
2330 p->promiscredir = global_promiscredir;
2331 p->trustrpid = global_trustrpid;
2332 p->progressinband = global_progressinband;
2334 p->ospauth = global_ospauth;
2336 p->rtptimeout = global_rtptimeout;
2337 p->rtpholdtimeout = global_rtpholdtimeout;
2338 p->capability = global_capability;
2339 if (p->dtmfmode & SIP_DTMF_RFC2833)
2340 p->noncodeccapability |= AST_RTP_DTMF;
2341 strncpy(p->context, default_context, sizeof(p->context) - 1);
2342 strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2344 ast_mutex_lock(&iflock);
2347 ast_mutex_unlock(&iflock);
2349 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2353 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2354 /* Called by handle_request ,sipsock_read */
2355 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2360 char iabuf[INET_ADDRSTRLEN];
2364 callid = get_header(req, "Call-ID");
2366 if (pedanticsipchecking) {
2367 /* In principle Call-ID's uniquely identify a call, however some vendors
2368 (i.e. Pingtel) send multiple calls with the same Call-ID and different
2369 tags in order to simplify billing. The RFC does state that we have to
2370 compare tags in addition to the call-id, but this generate substantially
2371 more overhead which is totally unnecessary for the vast majority of sane
2372 SIP implementations, and thus Asterisk does not enable this behavior
2373 by default. Short version: You'll need this option to support conferencing
2375 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2377 c = strchr(tmp, ' ');
2380 if (!strcasecmp(cmd, "SIP/2.0")) {
2386 strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2388 strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2389 tag = strstr(tmp, "tag=");
2392 c = strchr(tag, ';');
2399 if (ast_strlen_zero(callid)) {
2400 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2403 ast_mutex_lock(&iflock);
2406 if (!strcmp(p->callid, callid) &&
2407 (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2408 /* Found the call */
2409 ast_mutex_lock(&p->lock);
2410 ast_mutex_unlock(&iflock);
2415 ast_mutex_unlock(&iflock);
2416 p = sip_alloc(callid, sin, 1);
2418 ast_mutex_lock(&p->lock);
2422 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2423 static int sip_register(char *value, int lineno)
2425 struct sip_registry *reg;
2426 char copy[256] = "";
2427 char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2434 strncpy(copy, value, sizeof(copy)-1);
2437 hostname = strrchr(stringp, '@');
2442 if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2443 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2447 username = strsep(&stringp, ":");
2449 secret = strsep(&stringp, ":");
2451 authuser = strsep(&stringp, ":");
2454 hostname = strsep(&stringp, "/");
2456 contact = strsep(&stringp, "/");
2457 if (!contact || ast_strlen_zero(contact))
2460 hostname = strsep(&stringp, ":");
2461 porta = strsep(&stringp, ":");
2463 if (porta && !atoi(porta)) {
2464 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2467 reg = malloc(sizeof(struct sip_registry));
2469 memset(reg, 0, sizeof(struct sip_registry));
2470 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2472 strncpy(reg->username, username, sizeof(reg->username)-1);
2474 strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2476 strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2478 strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2481 reg->refresh = default_expiry;
2482 reg->portno = porta ? atoi(porta) : 0;
2483 reg->callid_valid = 0;
2485 ast_mutex_lock(®l.lock);
2486 reg->next = regl.registrations;
2487 regl.registrations = reg;
2488 ast_mutex_unlock(®l.lock);
2490 ast_log(LOG_ERROR, "Out of memory\n");
2496 /*--- lws2sws: Parse multiline SIP headers into one header */
2497 /* This is enabled if pedanticsipchecking is enabled */
2498 static int lws2sws(char *msgbuf, int len)
2504 /* Eliminate all CRs */
2505 if (msgbuf[h] == '\r') {
2509 /* Check for end-of-line */
2510 if (msgbuf[h] == '\n') {
2511 /* Check for end-of-message */
2514 /* Check for a continuation line */
2515 if (msgbuf[h + 1] == ' ') {
2516 /* Merge continuation line */
2520 /* Propagate LF and start new line */
2521 msgbuf[t++] = msgbuf[h++];
2526 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
2531 msgbuf[t++] = msgbuf[h++];
2535 msgbuf[t++] = msgbuf[h++];
2543 /*--- parse: Parse a SIP message ----*/
2544 static void parse(struct sip_request *req)
2546 /* Divide fields by NULL's */
2551 /* First header starts immediately */
2555 /* We've got a new header */
2559 printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2561 if (ast_strlen_zero(req->header[f])) {
2562 /* Line by itself means we're now in content */
2566 if (f >= SIP_MAX_HEADERS - 1) {
2567 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2570 req->header[f] = c + 1;
2571 } else if (*c == '\r') {
2572 /* Ignore but eliminate \r's */
2577 /* Check for last header */
2578 if (!ast_strlen_zero(req->header[f]))
2581 /* Now we process any mime content */
2586 /* We've got a new line */
2589 printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2591 if (f >= SIP_MAX_LINES - 1) {
2592 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2595 req->line[f] = c + 1;
2596 } else if (*c == '\r') {
2597 /* Ignore and eliminate \r's */
2602 /* Check for last line */
2603 if (!ast_strlen_zero(req->line[f]))
2607 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2610 /*--- process_sdp: Process SIP SDP ---*/
2611 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2617 char iabuf[INET_ADDRSTRLEN];
2621 int peercapability, peernoncodeccapability;
2622 int vpeercapability=0, vpeernoncodeccapability=0;
2623 struct sockaddr_in sin;
2626 struct ast_hostent ahp;
2631 int debug=sip_debug_test_pvt(p);
2633 /* Update our last rtprx when we receive an SDP, too */
2634 time(&p->lastrtprx);
2636 /* Get codec and RTP info from SDP */
2637 if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2638 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2641 m = get_sdp(req, "m");
2642 c = get_sdp(req, "c");
2643 if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2644 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2647 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2648 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2651 /* XXX This could block for a long time, and block the main thread! XXX */
2652 hp = ast_gethostbyname(host, &ahp);
2654 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2657 sdpLineNum_iterator_init(&iterator);
2659 while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2660 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
2662 /* Scan through the RTP payload types specified in a "m=" line: */
2663 ast_rtp_pt_clear(p->rtp);
2665 while(!ast_strlen_zero(codecs)) {
2666 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2667 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2671 ast_verbose("Found RTP audio format %d\n", codec);
2672 ast_rtp_set_m_type(p->rtp, codec);
2674 /* Skip over any whitespace */
2675 while(*codecs && (*codecs < 33)) codecs++;
2679 ast_rtp_pt_clear(p->vrtp); /* Must be cleared in case no m=video line exists */
2681 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2684 /* Scan through the RTP payload types specified in a "m=" line: */
2686 while(!ast_strlen_zero(codecs)) {
2687 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2688 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2692 ast_verbose("Found video format %s\n", ast_getformatname(codec));
2693 ast_rtp_set_m_type(p->vrtp, codec);
2695 /* Skip over any whitespace */
2696 while(*codecs && (*codecs < 33)) codecs++;
2701 /* RTP addresses and ports for audio and video */
2702 sin.sin_family = AF_INET;
2703 memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2705 /* Setup audio port number */
2706 sin.sin_port = htons(portno);
2707 if (p->rtp && sin.sin_port) {
2708 ast_rtp_set_peer(p->rtp, &sin);
2710 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2711 ast_log(LOG_DEBUG,"Peer audio RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2714 /* Setup video port number */
2715 sin.sin_port = htons(vportno);
2716 if (p->vrtp && sin.sin_port) {
2717 ast_rtp_set_peer(p->vrtp, &sin);
2719 ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2720 ast_log(LOG_DEBUG,"Peer video RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2724 /* Next, scan through each "a=rtpmap:" line, noting each
2725 * specified RTP payload type (with corresponding MIME subtype):
2727 sdpLineNum_iterator_init(&iterator);
2728 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2729 char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2730 if (!strcasecmp(a, "sendonly")) {
2734 if (!strcasecmp(a, "sendrecv")) {
2737 if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2739 ast_verbose("Found description format %s\n", mimeSubtype);
2740 /* Note: should really look at the 'freq' and '#chans' params too */
2741 ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2743 ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2746 /* Now gather all of the codecs that were asked for: */
2747 ast_rtp_get_current_formats(p->rtp,
2748 &peercapability, &peernoncodeccapability);
2750 ast_rtp_get_current_formats(p->vrtp,
2751 &vpeercapability, &vpeernoncodeccapability);
2752 p->jointcapability = p->capability & (peercapability | vpeercapability);
2753 p->peercapability = (peercapability | vpeercapability);
2754 p->noncodeccapability = noncodeccapability & p->peercapability;
2757 const unsigned slen=80;
2758 char s1[slen], s2[slen], s3[slen], s4[slen];
2760 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2761 ast_getformatname_multiple(s1, slen, p->capability),
2762 ast_getformatname_multiple(s2, slen, peercapability),
2763 ast_getformatname_multiple(s3, slen, vpeercapability),
2764 ast_getformatname_multiple(s4, slen, p->jointcapability));
2766 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2767 ast_getformatname_multiple(s1, slen, noncodeccapability),
2768 ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2769 ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2771 if (!p->jointcapability) {
2772 ast_log(LOG_WARNING, "No compatible codecs!\n");
2776 if (!(p->owner->nativeformats & p->jointcapability)) {
2777 const unsigned slen=80;
2778 char s1[slen], s2[slen];
2779 ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n",
2780 ast_getformatname_multiple(s1, slen, p->jointcapability),
2781 ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2782 p->owner->nativeformats = sip_codec_choose(p->jointcapability);
2783 ast_set_read_format(p->owner, p->owner->readformat);
2784 ast_set_write_format(p->owner, p->owner->writeformat);
2786 if (p->owner->bridge) {
2787 /* Turn on/off music on hold if we are holding/unholding */
2788 if (sin.sin_addr.s_addr && !sendonly) {
2789 ast_moh_stop(p->owner->bridge);
2791 ast_moh_start(p->owner->bridge, NULL);
2799 /*--- add_header: Add header to SIP message */
2800 static int add_header(struct sip_request *req, char *var, char *value)
2802 if (req->len >= sizeof(req->data) - 4) {
2803 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2807 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2810 req->header[req->headers] = req->data + req->len;
2811 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2812 req->len += strlen(req->header[req->headers]);
2813 if (req->headers < SIP_MAX_HEADERS)
2816 ast_log(LOG_WARNING, "Out of header space\n");
2822 /*--- add_blank_header: Add blank header to SIP message */
2823 static int add_blank_header(struct sip_request *req)
2825 if (req->len >= sizeof(req->data) - 4) {
2826 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2830 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2833 req->header[req->headers] = req->data + req->len;
2834 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2835 req->len += strlen(req->header[req->headers]);
2836 if (req->headers < SIP_MAX_HEADERS)
2839 ast_log(LOG_WARNING, "Out of header space\n");
2845 /*--- add_line: Add content (not header) to SIP message */
2846 static int add_line(struct sip_request *req, char *line)
2848 if (req->len >= sizeof(req->data) - 4) {
2849 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2853 /* Add extra empty return */
2854 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2855 req->len += strlen(req->data + req->len);
2857 req->line[req->lines] = req->data + req->len;
2858 snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2859 req->len += strlen(req->line[req->lines]);
2860 if (req->lines < SIP_MAX_LINES)
2863 ast_log(LOG_WARNING, "Out of line space\n");
2869 /*--- copy_header: Copy one header field from one request to another */
2870 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2873 tmp = get_header(orig, field);
2874 if (!ast_strlen_zero(tmp)) {
2875 /* Add what we're responding to */
2876 return add_header(req, field, tmp);
2878 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2882 /*--- copy_all_header: Copy all headers from one request to another ---*/
2883 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2889 tmp = __get_header(orig, field, &start);
2890 if (!ast_strlen_zero(tmp)) {
2891 /* Add what we're responding to */
2892 add_header(req, field, tmp);
2897 return copied ? 0 : -1;
2900 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2901 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2903 char tmp[256]="", *oh, *end;
2907 char iabuf[INET_ADDRSTRLEN];
2909 oh = __get_header(orig, field, &start);
2910 if (!ast_strlen_zero(oh)) {
2912 strncpy(tmp, oh, sizeof(tmp) - 1);
2913 oh = strstr(tmp, ";rport");
2915 end = strchr(oh + 1, ';');
2917 memmove(oh, end, strlen(end) + 1);
2921 if (!copied && (p->nat == SIP_NAT_ALWAYS)) {
2922 /* Whoo hoo! Now we can indicate port address translation too! Just
2923 another RFC (RFC3581). I'll leave the original comments in for
2925 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));
2926 add_header(req, field, new);
2928 /* Add what we're responding to */
2929 add_header(req, field, tmp);
2936 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2942 /*--- add_route: Add route header into request per learned route ---*/
2943 static void add_route(struct sip_request *req, struct sip_route *route)
2946 int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2952 n = strlen(route->hop);
2953 if ((n+3)>rem) break;
2959 strncpy(p, route->hop, rem); p += n;
2962 route = route->next;
2965 add_header(req, "Route", r);
2968 /*--- set_destination: Set destination from SIP URI ---*/
2969 static void set_destination(struct sip_pvt *p, char *uri)
2971 char *h, *maddr, hostname[256] = "";
2972 char iabuf[INET_ADDRSTRLEN];
2975 struct ast_hostent ahp;
2976 int debug=sip_debug_test_pvt(p);
2978 /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2979 /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2982 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2984 /* Find and parse hostname */
2985 h = strchr(uri, '@');
2990 if (strncmp(h, "sip:", 4) == 0)
2992 else if (strncmp(h, "sips:", 5) == 0)
2995 hn = strcspn(h, ":;>");
2996 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
2997 strncpy(hostname, h, hn); hostname[hn] = '\0'; /* safe */
3000 /* Is "port" present? if not default to 5060 */
3004 port = strtol(h, &h, 10);
3009 /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
3010 maddr = strstr(h, "maddr=");
3013 hn = strspn(maddr, "0123456789.");
3014 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
3015 strncpy(hostname, maddr, hn); hostname[hn] = '\0'; /* safe */
3018 hp = ast_gethostbyname(hostname, &ahp);
3020 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
3023 p->sa.sin_family = AF_INET;
3024 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
3025 p->sa.sin_port = htons(port);
3027 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), port);
3030 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
3031 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)