2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2005, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
21 * Implementation of Session Initiation Protocol
30 #include <sys/socket.h>
31 #include <sys/ioctl.h>
38 #include <sys/signal.h>
39 #include <netinet/in.h>
40 #include <netinet/in_systm.h>
41 #include <arpa/inet.h>
42 #include <netinet/ip.h>
47 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
49 #include "asterisk/lock.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/config.h"
52 #include "asterisk/logger.h"
53 #include "asterisk/module.h"
54 #include "asterisk/pbx.h"
55 #include "asterisk/options.h"
56 #include "asterisk/lock.h"
57 #include "asterisk/sched.h"
58 #include "asterisk/io.h"
59 #include "asterisk/rtp.h"
60 #include "asterisk/acl.h"
61 #include "asterisk/manager.h"
62 #include "asterisk/callerid.h"
63 #include "asterisk/cli.h"
64 #include "asterisk/app.h"
65 #include "asterisk/musiconhold.h"
66 #include "asterisk/dsp.h"
67 #include "asterisk/features.h"
68 #include "asterisk/acl.h"
69 #include "asterisk/srv.h"
70 #include "asterisk/astdb.h"
71 #include "asterisk/causes.h"
72 #include "asterisk/utils.h"
73 #include "asterisk/file.h"
74 #include "asterisk/astobj.h"
75 #include "asterisk/dnsmgr.h"
76 #include "asterisk/devicestate.h"
77 #include "asterisk/linkedlists.h"
80 #include "asterisk/astosp.h"
83 #ifndef DEFAULT_USERAGENT
84 #define DEFAULT_USERAGENT "Asterisk PBX"
87 #define VIDEO_CODEC_MASK 0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
89 #define IPTOS_MINCOST 0x02
92 /* #define VOCAL_DATA_HACK */
95 #define DEFAULT_DEFAULT_EXPIRY 120
96 #define DEFAULT_MAX_EXPIRY 3600
97 #define DEFAULT_REGISTRATION_TIMEOUT 20
98 #define DEFAULT_REGATTEMPTS_MAX 10
100 /* guard limit must be larger than guard secs */
101 /* guard min must be < 1000, and should be >= 250 */
102 #define EXPIRY_GUARD_SECS 15 /* How long before expiry do we reregister */
103 #define EXPIRY_GUARD_LIMIT 30 /* Below here, we use EXPIRY_GUARD_PCT instead of
105 #define EXPIRY_GUARD_MIN 500 /* This is the minimum guard time applied. If
106 GUARD_PCT turns out to be lower than this, it
107 will use this time instead.
108 This is in milliseconds. */
109 #define EXPIRY_GUARD_PCT 0.20 /* Percentage of expires timeout to use when
110 below EXPIRY_GUARD_LIMIT */
112 static int max_expiry = DEFAULT_MAX_EXPIRY;
113 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
116 #define MAX(a,b) ((a) > (b) ? (a) : (b))
119 #define CALLERID_UNKNOWN "Unknown"
123 #define DEFAULT_MAXMS 2000 /* Must be faster than 2 seconds by default */
124 #define DEFAULT_FREQ_OK 60 * 1000 /* How often to check for the host to be up */
125 #define DEFAULT_FREQ_NOTOK 10 * 1000 /* How often to check, if the host is down... */
127 #define DEFAULT_RETRANS 1000 /* How frequently to retransmit */
128 /* 2 * 500 ms in RFC 3261 */
129 #define MAX_RETRANS 7 /* Try only 7 times for retransmissions */
130 #define MAX_AUTHTRIES 3 /* Try authentication three times, then fail */
133 #define DEBUG_READ 0 /* Recieved data */
134 #define DEBUG_SEND 1 /* Transmit data */
136 static const char desc[] = "Session Initiation Protocol (SIP)";
137 static const char channeltype[] = "SIP";
138 static const char config[] = "sip.conf";
139 static const char notify_config[] = "sip_notify.conf";
144 /* Do _NOT_ make any changes to this enum, or the array following it;
145 if you think you are doing the right thing, you are probably
146 not doing the right thing. If you think there are changes
147 needed, get someone else to review them first _before_
148 submitting a patch. If these two lists do not match properly
149 bad things will happen.
152 enum subscriptiontype {
161 static const struct cfsubscription_types {
162 enum subscriptiontype type;
163 const char * const event;
164 const char * const mediatype;
165 const char * const text;
166 } subscription_types[] = {
167 { NONE, "-", "unknown", "unknown" },
168 /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
169 { DIALOG_INFO_XML, "dialog", "application/dialog-info+xml", "dialog-info+xml" },
170 { CPIM_PIDF_XML, "presence", "application/cpim-pidf+xml", "cpim-pidf+xml" }, /* RFC 3863 */
171 { PIDF_XML, "presence", "application/pidf+xml", "pidf+xml" }, /* RFC 3863 */
172 { XPIDF_XML, "presence", "application/xpidf+xml", "xpidf+xml" } /* Pre-RFC 3863 with MS additions */
194 static const struct cfsip_methods {
196 int need_rtp; /* when this is the 'primary' use for a pvt structure, does it need RTP? */
199 { SIP_UNKNOWN, RTP, "-UNKNOWN-" },
200 { SIP_RESPONSE, NO_RTP, "SIP/2.0" },
201 { SIP_REGISTER, NO_RTP, "REGISTER" },
202 { SIP_OPTIONS, NO_RTP, "OPTIONS" },
203 { SIP_NOTIFY, NO_RTP, "NOTIFY" },
204 { SIP_INVITE, RTP, "INVITE" },
205 { SIP_ACK, NO_RTP, "ACK" },
206 { SIP_PRACK, NO_RTP, "PRACK" },
207 { SIP_BYE, NO_RTP, "BYE" },
208 { SIP_REFER, NO_RTP, "REFER" },
209 { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE" },
210 { SIP_MESSAGE, NO_RTP, "MESSAGE" },
211 { SIP_UPDATE, NO_RTP, "UPDATE" },
212 { SIP_INFO, NO_RTP, "INFO" },
213 { SIP_CANCEL, NO_RTP, "CANCEL" },
214 { SIP_PUBLISH, NO_RTP, "PUBLISH" }
217 /* Structure for conversion between compressed SIP and "normal" SIP */
218 static const struct cfalias {
219 char * const fullname;
220 char * const shortname;
222 { "Content-Type", "c" },
223 { "Content-Encoding", "e" },
227 { "Content-Length", "l" },
230 { "Supported", "k" },
232 { "Referred-By", "b" },
233 { "Allow-Events", "u" },
236 { "Accept-Contact", "a" },
237 { "Reject-Contact", "j" },
238 { "Request-Disposition", "d" },
239 { "Session-Expires", "x" },
242 /* Define SIP option tags, used in Require: and Supported: headers */
243 /* We need to be aware of these properties in the phones to use
244 the replace: header. We should not do that without knowing
245 that the other end supports it...
246 This is nothing we can configure, we learn by the dialog
247 Supported: header on the REGISTER (peer) or the INVITE
249 We are not using many of these today, but will in the future.
250 This is documented in RFC 3261
253 #define NOT_SUPPORTED 0
255 #define SIP_OPT_REPLACES (1 << 0)
256 #define SIP_OPT_100REL (1 << 1)
257 #define SIP_OPT_TIMER (1 << 2)
258 #define SIP_OPT_EARLY_SESSION (1 << 3)
259 #define SIP_OPT_JOIN (1 << 4)
260 #define SIP_OPT_PATH (1 << 5)
261 #define SIP_OPT_PREF (1 << 6)
262 #define SIP_OPT_PRECONDITION (1 << 7)
263 #define SIP_OPT_PRIVACY (1 << 8)
264 #define SIP_OPT_SDP_ANAT (1 << 9)
265 #define SIP_OPT_SEC_AGREE (1 << 10)
266 #define SIP_OPT_EVENTLIST (1 << 11)
267 #define SIP_OPT_GRUU (1 << 12)
268 #define SIP_OPT_TARGET_DIALOG (1 << 13)
270 /* List of well-known SIP options. If we get this in a require,
271 we should check the list and answer accordingly. */
272 static const struct cfsip_options {
273 int id; /* Bitmap ID */
274 int supported; /* Supported by Asterisk ? */
275 char * const text; /* Text id, as in standard */
277 /* Replaces: header for transfer */
278 { SIP_OPT_REPLACES, SUPPORTED, "replaces" },
279 /* RFC3262: PRACK 100% reliability */
280 { SIP_OPT_100REL, NOT_SUPPORTED, "100rel" },
281 /* SIP Session Timers */
282 { SIP_OPT_TIMER, NOT_SUPPORTED, "timer" },
283 /* RFC3959: SIP Early session support */
284 { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
285 /* SIP Join header support */
286 { SIP_OPT_JOIN, NOT_SUPPORTED, "join" },
287 /* RFC3327: Path support */
288 { SIP_OPT_PATH, NOT_SUPPORTED, "path" },
289 /* RFC3840: Callee preferences */
290 { SIP_OPT_PREF, NOT_SUPPORTED, "pref" },
291 /* RFC3312: Precondition support */
292 { SIP_OPT_PRECONDITION, NOT_SUPPORTED, "precondition" },
293 /* RFC3323: Privacy with proxies*/
294 { SIP_OPT_PRIVACY, NOT_SUPPORTED, "privacy" },
295 /* RFC4092: Usage of the SDP ANAT Semantics in the SIP */
296 { SIP_OPT_SDP_ANAT, NOT_SUPPORTED, "sdp-anat" },
297 /* RFC3329: Security agreement mechanism */
298 { SIP_OPT_SEC_AGREE, NOT_SUPPORTED, "sec_agree" },
299 /* SIMPLE events: draft-ietf-simple-event-list-07.txt */
300 { SIP_OPT_EVENTLIST, NOT_SUPPORTED, "eventlist" },
301 /* GRUU: Globally Routable User Agent URI's */
302 { SIP_OPT_GRUU, NOT_SUPPORTED, "gruu" },
303 /* Target-dialog: draft-ietf-sip-target-dialog-00.txt */
304 { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED, "target-dialog" },
308 /* SIP Methods we support */
309 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
311 /* SIP Extensions we support */
312 #define SUPPORTED_EXTENSIONS "replaces"
314 #define DEFAULT_SIP_PORT 5060 /* From RFC 3261 (former 2543) */
315 #define SIP_MAX_PACKET 4096 /* Also from RFC 3261 (2543), should sub headers tho */
317 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
319 #define DEFAULT_CONTEXT "default"
320 static char default_context[AST_MAX_CONTEXT] = DEFAULT_CONTEXT;
321 static char default_subscribecontext[AST_MAX_CONTEXT];
323 #define DEFAULT_VMEXTEN "asterisk"
324 static char global_vmexten[AST_MAX_EXTENSION] = DEFAULT_VMEXTEN;
326 static char default_language[MAX_LANGUAGE] = "";
328 #define DEFAULT_CALLERID "asterisk"
329 static char default_callerid[AST_MAX_EXTENSION] = DEFAULT_CALLERID;
331 static char default_fromdomain[AST_MAX_EXTENSION] = "";
333 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
334 static char default_notifymime[AST_MAX_EXTENSION] = DEFAULT_NOTIFYMIME;
336 static int global_notifyringing = 1; /* Send notifications on ringing */
338 static int default_qualify = 0; /* Default Qualify= setting */
340 static struct ast_flags global_flags = {0}; /* global SIP_ flags */
341 static struct ast_flags global_flags_page2 = {0}; /* more global SIP_ flags */
343 static int srvlookup = 0; /* SRV Lookup on or off. Default is off, RFC behavior is on */
345 static int pedanticsipchecking = 0; /* Extra checking ? Default off */
347 static int autocreatepeer = 0; /* Auto creation of peers at registration? Default off. */
349 static int relaxdtmf = 0;
351 static int global_rtptimeout = 0;
353 static int global_rtpholdtimeout = 0;
355 static int global_rtpkeepalive = 0;
357 static int global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
358 static int global_regattempts_max = DEFAULT_REGATTEMPTS_MAX;
360 /* Object counters */
361 static int suserobjs = 0;
362 static int ruserobjs = 0;
363 static int speerobjs = 0;
364 static int rpeerobjs = 0;
365 static int apeerobjs = 0;
366 static int regobjs = 0;
368 static int global_allowguest = 1; /* allow unauthenticated users/peers to connect? */
370 #define DEFAULT_MWITIME 10
371 static int global_mwitime = DEFAULT_MWITIME; /* Time between MWI checks for peers */
373 static int usecnt =0;
374 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
377 /* Protect the interface list (of sip_pvt's) */
378 AST_MUTEX_DEFINE_STATIC(iflock);
380 /* Protect the monitoring thread, so only one process can kill or start it, and not
381 when it's doing something critical. */
382 AST_MUTEX_DEFINE_STATIC(netlock);
384 AST_MUTEX_DEFINE_STATIC(monlock);
386 /* This is the thread for the monitor which checks for input on the channels
387 which are not currently in use. */
388 static pthread_t monitor_thread = AST_PTHREADT_NULL;
390 static int restart_monitor(void);
392 /* Codecs that we support by default: */
393 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
394 static int noncodeccapability = AST_RTP_DTMF;
396 static struct in_addr __ourip;
397 static struct sockaddr_in outboundproxyip;
400 #define SIP_DEBUG_CONFIG 1 << 0
401 #define SIP_DEBUG_CONSOLE 1 << 1
402 static int sipdebug = 0;
403 static struct sockaddr_in debugaddr;
407 static int videosupport = 0;
409 static int compactheaders = 0; /* send compact sip headers */
411 static int recordhistory = 0; /* Record SIP history. Off by default */
412 static int dumphistory = 0; /* Dump history to verbose before destroying SIP dialog */
414 static char global_musicclass[MAX_MUSICCLASS] = ""; /* Global music on hold class */
415 #define DEFAULT_REALM "asterisk"
416 static char global_realm[MAXHOSTNAMELEN] = DEFAULT_REALM; /* Default realm */
417 static char regcontext[AST_MAX_CONTEXT] = ""; /* Context for auto-extensions */
420 #define DEFAULT_EXPIRY 900
421 static int expiry = DEFAULT_EXPIRY;
423 static struct sched_context *sched;
424 static struct io_context *io;
425 /* The private structures of the sip channels are linked for
426 selecting outgoing channels */
428 #define SIP_MAX_HEADERS 64
429 #define SIP_MAX_LINES 64
431 #define DEC_CALL_LIMIT 0
432 #define INC_CALL_LIMIT 1
434 static struct ast_codec_pref prefs;
437 /* sip_request: The data grabbed from the UDP socket */
439 char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
440 char *rlPart2; /* The Request URI or Response Status */
441 int len; /* Length */
442 int headers; /* # of SIP Headers */
443 int method; /* Method of this request */
444 char *header[SIP_MAX_HEADERS];
445 int lines; /* SDP Content */
446 char *line[SIP_MAX_LINES];
447 char data[SIP_MAX_PACKET];
448 int debug; /* Debug flag for this packet */
453 /* Parameters to the transmit_invite function */
454 struct sip_invite_param {
455 char *distinctive_ring;
465 struct sip_route *next;
475 char domain[MAXHOSTNAMELEN];
476 char context[AST_MAX_EXTENSION];
477 enum domain_mode mode;
478 AST_LIST_ENTRY(domain) list;
481 static AST_LIST_HEAD_STATIC(domain_list, domain);
483 int allow_external_domains;
485 /* sip_history: Structure for saving transactions within a SIP dialog */
488 struct sip_history *next;
491 /* sip_auth: Creadentials for authentication to other SIP services */
493 char realm[AST_MAX_EXTENSION]; /* Realm in which these credentials are valid */
494 char username[256]; /* Username */
495 char secret[256]; /* Secret */
496 char md5secret[256]; /* MD5Secret */
497 struct sip_auth *next; /* Next auth structure in list */
500 #define SIP_ALREADYGONE (1 << 0) /* Whether or not we've already been destroyed by our peer */
501 #define SIP_NEEDDESTROY (1 << 1) /* if we need to be destroyed */
502 #define SIP_NOVIDEO (1 << 2) /* Didn't get video in invite, don't offer */
503 #define SIP_RINGING (1 << 3) /* Have sent 180 ringing */
504 #define SIP_PROGRESS_SENT (1 << 4) /* Have sent 183 message progress */
505 #define SIP_NEEDREINVITE (1 << 5) /* Do we need to send another reinvite? */
506 #define SIP_PENDINGBYE (1 << 6) /* Need to send bye after we ack? */
507 #define SIP_GOTREFER (1 << 7) /* Got a refer? */
508 #define SIP_PROMISCREDIR (1 << 8) /* Promiscuous redirection */
509 #define SIP_TRUSTRPID (1 << 9) /* Trust RPID headers? */
510 #define SIP_USEREQPHONE (1 << 10) /* Add user=phone to numeric URI. Default off */
511 #define SIP_REALTIME (1 << 11) /* Flag for realtime users */
512 #define SIP_USECLIENTCODE (1 << 12) /* Trust X-ClientCode info message */
513 #define SIP_OUTGOING (1 << 13) /* Is this an outgoing call? */
514 #define SIP_SELFDESTRUCT (1 << 14)
515 #define SIP_DYNAMIC (1 << 15) /* Is this a dynamic peer? */
516 /* --- Choices for DTMF support in SIP channel */
517 #define SIP_DTMF (3 << 16) /* three settings, uses two bits */
518 #define SIP_DTMF_RFC2833 (0 << 16) /* RTP DTMF */
519 #define SIP_DTMF_INBAND (1 << 16) /* Inband audio, only for ULAW/ALAW */
520 #define SIP_DTMF_INFO (2 << 16) /* SIP Info messages */
521 #define SIP_DTMF_AUTO (3 << 16) /* AUTO switch between rfc2833 and in-band DTMF */
523 #define SIP_NAT (3 << 18) /* four settings, uses two bits */
524 #define SIP_NAT_NEVER (0 << 18) /* No nat support */
525 #define SIP_NAT_RFC3581 (1 << 18)
526 #define SIP_NAT_ROUTE (2 << 18)
527 #define SIP_NAT_ALWAYS (3 << 18)
528 /* re-INVITE related settings */
529 #define SIP_REINVITE (3 << 20) /* two bits used */
530 #define SIP_CAN_REINVITE (1 << 20) /* allow peers to be reinvited to send media directly p2p */
531 #define SIP_REINVITE_UPDATE (2 << 20) /* use UPDATE (RFC3311) when reinviting this peer */
532 /* "insecure" settings */
533 #define SIP_INSECURE_PORT (1 << 22) /* don't require matching port for incoming requests */
534 #define SIP_INSECURE_INVITE (1 << 23) /* don't require authentication for incoming INVITEs */
535 /* Sending PROGRESS in-band settings */
536 #define SIP_PROG_INBAND (3 << 24) /* three settings, uses two bits */
537 #define SIP_PROG_INBAND_NEVER (0 << 24)
538 #define SIP_PROG_INBAND_NO (1 << 24)
539 #define SIP_PROG_INBAND_YES (2 << 24)
540 /* Open Settlement Protocol authentication */
541 #define SIP_OSPAUTH (3 << 26) /* four settings, uses two bits */
542 #define SIP_OSPAUTH_NO (0 << 26)
543 #define SIP_OSPAUTH_GATEWAY (1 << 26)
544 #define SIP_OSPAUTH_PROXY (2 << 26)
545 #define SIP_OSPAUTH_EXCLUSIVE (3 << 26)
547 #define SIP_CALL_ONHOLD (1 << 28)
548 #define SIP_CALL_LIMIT (1 << 29)
549 /* Remote Party-ID Support */
550 #define SIP_SENDRPID (1 << 30)
552 /* a new page of flags for peer */
553 #define SIP_PAGE2_RTCACHEFRIENDS (1 << 0)
554 #define SIP_PAGE2_RTUPDATE (1 << 1)
555 #define SIP_PAGE2_RTAUTOCLEAR (1 << 2)
556 #define SIP_PAGE2_RTIGNOREREGEXPIRE (1 << 3)
558 static int global_rtautoclear = 120;
560 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call */
561 static struct sip_pvt {
562 ast_mutex_t lock; /* Channel private lock */
563 int method; /* SIP method of this packet */
564 char callid[80]; /* Global CallID */
565 char randdata[80]; /* Random data */
566 struct ast_codec_pref prefs; /* codec prefs */
567 unsigned int ocseq; /* Current outgoing seqno */
568 unsigned int icseq; /* Current incoming seqno */
569 ast_group_t callgroup; /* Call group */
570 ast_group_t pickupgroup; /* Pickup group */
571 int lastinvite; /* Last Cseq of invite */
572 unsigned int flags; /* SIP_ flags */
573 int timer_t1; /* SIP timer T1, ms rtt */
574 unsigned int sipoptions; /* Supported SIP sipoptions on the other end */
575 int capability; /* Special capability (codec) */
576 int jointcapability; /* Supported capability at both ends (codecs ) */
577 int peercapability; /* Supported peer capability */
578 int prefcodec; /* Preferred codec (outbound only) */
579 int noncodeccapability;
580 int callingpres; /* Calling presentation */
581 int authtries; /* Times we've tried to authenticate */
582 int expiry; /* How long we take to expire */
583 int branch; /* One random number */
584 char tag[11]; /* Another random number */
585 int sessionid; /* SDP Session ID */
586 int sessionversion; /* SDP Session Version */
587 struct sockaddr_in sa; /* Our peer */
588 struct sockaddr_in redirip; /* Where our RTP should be going if not to us */
589 struct sockaddr_in vredirip; /* Where our Video RTP should be going if not to us */
590 int redircodecs; /* Redirect codecs */
591 struct sockaddr_in recv; /* Received as */
592 struct in_addr ourip; /* Our IP */
593 struct ast_channel *owner; /* Who owns us */
594 char exten[AST_MAX_EXTENSION]; /* Extension where to start */
595 char refer_to[AST_MAX_EXTENSION]; /* Place to store REFER-TO extension */
596 char referred_by[AST_MAX_EXTENSION]; /* Place to store REFERRED-BY extension */
597 char refer_contact[AST_MAX_EXTENSION]; /* Place to store Contact info from a REFER extension */
598 struct sip_pvt *refer_call; /* Call we are referring */
599 struct sip_route *route; /* Head of linked list of routing steps (fm Record-Route) */
600 int route_persistant; /* Is this the "real" route? */
601 char from[256]; /* The From: header */
602 char useragent[256]; /* User agent in SIP request */
603 char context[AST_MAX_CONTEXT]; /* Context for this call */
604 char subscribecontext[AST_MAX_CONTEXT]; /* Subscribecontext */
605 char fromdomain[MAXHOSTNAMELEN]; /* Domain to show in the from field */
606 char fromuser[AST_MAX_EXTENSION]; /* User to show in the user field */
607 char fromname[AST_MAX_EXTENSION]; /* Name to show in the user field */
608 char tohost[MAXHOSTNAMELEN]; /* Host we should put in the "to" field */
609 char language[MAX_LANGUAGE]; /* Default language for this call */
610 char musicclass[MAX_MUSICCLASS]; /* Music on Hold class */
611 char rdnis[256]; /* Referring DNIS */
612 char theirtag[256]; /* Their tag */
613 char username[256]; /* [user] name */
614 char peername[256]; /* [peer] name, not set if [user] */
615 char authname[256]; /* Who we use for authentication */
616 char uri[256]; /* Original requested URI */
617 char okcontacturi[256]; /* URI from the 200 OK on INVITE */
618 char peersecret[256]; /* Password */
619 char peermd5secret[256];
620 struct sip_auth *peerauth; /* Realm authentication */
621 char cid_num[256]; /* Caller*ID */
622 char cid_name[256]; /* Caller*ID */
623 char via[256]; /* Via: header */
624 char fullcontact[128]; /* The Contact: that the UA registers with us */
625 char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
626 char our_contact[256]; /* Our contact header */
627 char *rpid; /* Our RPID header */
628 char *rpid_from; /* Our RPID From header */
629 char realm[MAXHOSTNAMELEN]; /* Authorization realm */
630 char nonce[256]; /* Authorization nonce */
631 char opaque[256]; /* Opaque nonsense */
632 char qop[80]; /* Quality of Protection, since SIP wasn't complicated enough yet. */
633 char domain[MAXHOSTNAMELEN]; /* Authorization domain */
634 char lastmsg[256]; /* Last Message sent/received */
635 int amaflags; /* AMA Flags */
636 int pendinginvite; /* Any pending invite */
638 int osphandle; /* OSP Handle for call */
639 time_t ospstart; /* OSP Start time */
640 unsigned int osptimelimit; /* OSP call duration limit */
642 struct sip_request initreq; /* Initial request */
644 int maxtime; /* Max time for first response */
645 int maxforwards; /* keep the max-forwards info */
646 int initid; /* Auto-congest ID if appropriate */
647 int autokillid; /* Auto-kill ID */
648 time_t lastrtprx; /* Last RTP received */
649 time_t lastrtptx; /* Last RTP sent */
650 int rtptimeout; /* RTP timeout time */
651 int rtpholdtimeout; /* RTP timeout when on hold */
652 int rtpkeepalive; /* Send RTP packets for keepalive */
653 enum subscriptiontype subscribed; /* Is this call a subscription? */
655 int laststate; /* Last known extension state */
658 struct ast_dsp *vad; /* Voice Activation Detection dsp */
660 struct sip_peer *peerpoke; /* If this calls is to poke a peer, which one */
661 struct sip_registry *registry; /* If this is a REGISTER call, to which registry */
662 struct ast_rtp *rtp; /* RTP Session */
663 struct ast_rtp *vrtp; /* Video RTP session */
664 struct sip_pkt *packets; /* Packets scheduled for re-transmission */
665 struct sip_history *history; /* History of this SIP dialog */
666 struct ast_variable *chanvars; /* Channel variables to set for call */
667 struct sip_pvt *next; /* Next call in chain */
668 struct sip_invite_param *options; /* Options for INVITE */
671 #define FLAG_RESPONSE (1 << 0)
672 #define FLAG_FATAL (1 << 1)
674 /* sip packet - read in sipsock_read, transmitted in send_request */
676 struct sip_pkt *next; /* Next packet */
677 int retrans; /* Retransmission number */
678 int method; /* SIP method for this packet */
679 int seqno; /* Sequence number */
680 unsigned int flags; /* non-zero if this is a response packet (e.g. 200 OK) */
681 struct sip_pvt *owner; /* Owner call */
682 int retransid; /* Retransmission ID */
683 int timer_a; /* SIP timer A, retransmission timer */
684 int timer_t1; /* SIP Timer T1, estimated RTT or 500 ms */
685 int packetlen; /* Length of packet */
689 /* Structure for SIP user data. User's place calls to us */
691 /* Users who can access various contexts */
692 ASTOBJ_COMPONENTS(struct sip_user);
693 char secret[80]; /* Password */
694 char md5secret[80]; /* Password in md5 */
695 char context[AST_MAX_CONTEXT]; /* Default context for incoming calls */
696 char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
697 char cid_num[80]; /* Caller ID num */
698 char cid_name[80]; /* Caller ID name */
699 char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
700 char language[MAX_LANGUAGE]; /* Default language for this user */
701 char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
702 char useragent[256]; /* User agent in SIP request */
703 struct ast_codec_pref prefs; /* codec prefs */
704 ast_group_t callgroup; /* Call group */
705 ast_group_t pickupgroup; /* Pickup Group */
706 unsigned int flags; /* SIP flags */
707 unsigned int sipoptions; /* Supported SIP options */
708 struct ast_flags flags_page2; /* SIP_PAGE2 flags */
709 int amaflags; /* AMA flags for billing */
710 int callingpres; /* Calling id presentation */
711 int capability; /* Codec capability */
712 int inUse; /* Number of calls in use */
713 int call_limit; /* Limit of concurrent calls */
714 struct ast_ha *ha; /* ACL setting */
715 struct ast_variable *chanvars; /* Variables to set for channel created by user */
718 /* Structure for SIP peer data, we place calls to peers if registered or fixed IP address (host) */
720 ASTOBJ_COMPONENTS(struct sip_peer); /* name, refcount, objflags, object pointers */
721 /* peer->name is the unique name of this object */
722 char secret[80]; /* Password */
723 char md5secret[80]; /* Password in MD5 */
724 struct sip_auth *auth; /* Realm authentication list */
725 char context[AST_MAX_CONTEXT]; /* Default context for incoming calls */
726 char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
727 char username[80]; /* Temporary username until registration */
728 char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
729 int amaflags; /* AMA Flags (for billing) */
730 char tohost[MAXHOSTNAMELEN]; /* If not dynamic, IP address */
731 char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
732 char fromuser[80]; /* From: user when calling this peer */
733 char fromdomain[MAXHOSTNAMELEN]; /* From: domain when calling this peer */
734 char fullcontact[256]; /* Contact registered with us (not in sip.conf) */
735 char cid_num[80]; /* Caller ID num */
736 char cid_name[80]; /* Caller ID name */
737 int callingpres; /* Calling id presentation */
738 int inUse; /* Number of calls in use */
739 int call_limit; /* Limit of concurrent calls */
740 char vmexten[AST_MAX_EXTENSION]; /* Dialplan extension for MWI notify message*/
741 char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
742 char language[MAX_LANGUAGE]; /* Default language for prompts */
743 char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
744 char useragent[256]; /* User agent in SIP request (saved from registration) */
745 struct ast_codec_pref prefs; /* codec prefs */
747 time_t lastmsgcheck; /* Last time we checked for MWI */
748 unsigned int flags; /* SIP flags */
749 unsigned int sipoptions; /* Supported SIP options */
750 struct ast_flags flags_page2; /* SIP_PAGE2 flags */
751 int expire; /* When to expire this peer registration */
752 int capability; /* Codec capability */
753 int rtptimeout; /* RTP timeout */
754 int rtpholdtimeout; /* RTP Hold Timeout */
755 int rtpkeepalive; /* Send RTP packets for keepalive */
756 ast_group_t callgroup; /* Call group */
757 ast_group_t pickupgroup; /* Pickup group */
758 struct ast_dnsmgr_entry *dnsmgr;/* DNS refresh manager for peer */
759 struct sockaddr_in addr; /* IP address of peer */
762 struct sip_pvt *call; /* Call pointer */
763 int pokeexpire; /* When to expire poke (qualify= checking) */
764 int lastms; /* How long last response took (in ms), or -1 for no response */
765 int maxms; /* Max ms we will accept for the host to be up, 0 to not monitor */
766 struct timeval ps; /* Ping send time */
768 struct sockaddr_in defaddr; /* Default IP address, used until registration */
769 struct ast_ha *ha; /* Access control list */
770 struct ast_variable *chanvars; /* Variables to set for channel created by user */
774 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
775 static int sip_reloading = 0;
777 /* States for outbound registrations (with register= lines in sip.conf */
778 #define REG_STATE_UNREGISTERED 0
779 #define REG_STATE_REGSENT 1
780 #define REG_STATE_AUTHSENT 2
781 #define REG_STATE_REGISTERED 3
782 #define REG_STATE_REJECTED 4
783 #define REG_STATE_TIMEOUT 5
784 #define REG_STATE_NOAUTH 6
785 #define REG_STATE_FAILED 7
788 /* sip_registry: Registrations with other SIP proxies */
789 struct sip_registry {
790 ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
791 int portno; /* Optional port override */
792 char username[80]; /* Who we are registering as */
793 char authuser[80]; /* Who we *authenticate* as */
794 char hostname[MAXHOSTNAMELEN]; /* Domain or host we register to */
795 char secret[80]; /* Password or key name in []'s */
797 char contact[256]; /* Contact extension */
799 int expire; /* Sched ID of expiration */
800 int regattempts; /* Number of attempts (since the last success) */
801 int timeout; /* sched id of sip_reg_timeout */
802 int refresh; /* How often to refresh */
803 struct sip_pvt *call; /* create a sip_pvt structure for each outbound "registration call" in progress */
804 int regstate; /* Registration state (see above) */
805 int callid_valid; /* 0 means we haven't chosen callid for this registry yet. */
806 char callid[80]; /* Global CallID for this registry */
807 unsigned int ocseq; /* Sequence number we got to for REGISTERs for this registry */
808 struct sockaddr_in us; /* Who the server thinks we are */
811 char realm[MAXHOSTNAMELEN]; /* Authorization realm */
812 char nonce[256]; /* Authorization nonce */
813 char domain[MAXHOSTNAMELEN]; /* Authorization domain */
814 char opaque[256]; /* Opaque nonsense */
815 char qop[80]; /* Quality of Protection. */
817 char lastmsg[256]; /* Last Message sent/received */
820 /*--- The user list: Users and friends ---*/
821 static struct ast_user_list {
822 ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
825 /*--- The peer list: Peers and Friends ---*/
826 static struct ast_peer_list {
827 ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
830 /*--- The register list: Other SIP proxys we register with and call ---*/
831 static struct ast_register_list {
832 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
837 static int __sip_do_register(struct sip_registry *r);
839 static int sipsock = -1;
842 static struct sockaddr_in bindaddr;
843 static struct sockaddr_in externip;
844 static char externhost[MAXHOSTNAMELEN] = "";
845 static time_t externexpire = 0;
846 static int externrefresh = 10;
847 static struct ast_ha *localaddr;
849 /* The list of manual NOTIFY types we know how to send */
850 struct ast_config *notify_types;
852 static struct sip_auth *authl; /* Authentication list */
855 static struct ast_frame *sip_read(struct ast_channel *ast);
856 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
857 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
858 static int transmit_response_with_unsupported(struct sip_pvt *p, char *msg, struct sip_request *req, char *unsupported);
859 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header, int stale);
860 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, int reliable, int newbranch);
861 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int inc, int reliable, int newbranch);
862 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sendsdp, int init);
863 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
864 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
865 static int transmit_info_with_vidupdate(struct sip_pvt *p);
866 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
867 static int transmit_refer(struct sip_pvt *p, const char *dest);
868 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
869 static struct sip_peer *temp_peer(const char *name);
870 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
871 static void free_old_route(struct sip_route *route);
872 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
873 static int update_call_counter(struct sip_pvt *fup, int event);
874 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
875 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
876 static int sip_do_reload(void);
877 static int expire_register(void *data);
878 static int callevents = 0;
880 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
881 static int sip_devicestate(void *data);
882 static int sip_sendtext(struct ast_channel *ast, const char *text);
883 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
884 static int sip_hangup(struct ast_channel *ast);
885 static int sip_answer(struct ast_channel *ast);
886 static struct ast_frame *sip_read(struct ast_channel *ast);
887 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
888 static int sip_indicate(struct ast_channel *ast, int condition);
889 static int sip_transfer(struct ast_channel *ast, const char *dest);
890 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
891 static int sip_senddigit(struct ast_channel *ast, char digit);
892 static int clear_realm_authentication(struct sip_auth *authlist); /* Clear realm authentication list (at reload) */
893 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno); /* Add realm authentication in list */
894 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, char *realm); /* Find authentication for a specific realm */
895 static int check_sip_domain(const char *domain, char *context, size_t len); /* Check if domain is one of our local domains */
896 static void append_date(struct sip_request *req); /* Append date to SIP packet */
897 static int determine_firstline_parts(struct sip_request *req);
898 static void sip_dump_history(struct sip_pvt *dialog); /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
899 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
900 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int substate);
902 /* Definition of this channel for channel registration */
903 static const struct ast_channel_tech sip_tech = {
905 .description = "Session Initiation Protocol (SIP)",
906 .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
907 .properties = AST_CHAN_TP_WANTSJITTER,
908 .requester = sip_request_call,
909 .devicestate = sip_devicestate,
911 .hangup = sip_hangup,
912 .answer = sip_answer,
915 .write_video = sip_write,
916 .indicate = sip_indicate,
917 .transfer = sip_transfer,
919 .send_digit = sip_senddigit,
920 .bridge = ast_rtp_bridge,
921 .send_text = sip_sendtext,
924 /*--- find_sip_method: Find SIP method from header */
925 int find_sip_method(char *msg)
929 if (!msg || ast_strlen_zero(msg))
932 /* Strictly speaking, SIP methods are case SENSITIVE, but we don't check */
933 /* following Jon Postel's rule: Be gentle in what you accept, strict with what you send */
934 for (i = 1; (i < (sizeof(sip_methods) / sizeof(sip_methods[0]))) && !res; i++) {
935 if (!strcasecmp(sip_methods[i].text, msg))
936 res = sip_methods[i].id;
941 /*--- parse_sip_options: Parse supported header in incoming packet */
942 unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
946 char *temp = ast_strdupa(supported);
948 unsigned int profile = 0;
950 if (!supported || ast_strlen_zero(supported) )
953 if (option_debug > 2 && sipdebug)
954 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
959 if ( (sep = strchr(next, ',')) != NULL) {
963 while (*next == ' ') /* Skip spaces */
965 if (option_debug > 2 && sipdebug)
966 ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
967 for (i=0; (i < (sizeof(sip_options) / sizeof(sip_options[0]))) && !res; i++) {
968 if (!strcasecmp(next, sip_options[i].text)) {
969 profile |= sip_options[i].id;
971 if (option_debug > 2 && sipdebug)
972 ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
976 if (option_debug > 2 && sipdebug)
977 ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
981 pvt->sipoptions = profile;
983 ast_log(LOG_DEBUG, "* SIP extension value: %d for call %s\n", profile, pvt->callid);
988 /*--- sip_debug_test_addr: See if we pass debug IP filter */
989 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
993 if (debugaddr.sin_addr.s_addr) {
994 if (((ntohs(debugaddr.sin_port) != 0)
995 && (debugaddr.sin_port != addr->sin_port))
996 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
1002 /*--- sip_debug_test_pvt: Test PVT for debugging output */
1003 static inline int sip_debug_test_pvt(struct sip_pvt *p)
1007 return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
1011 /*--- __sip_xmit: Transmit SIP message ---*/
1012 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
1015 char iabuf[INET_ADDRSTRLEN];
1017 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1018 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
1020 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
1022 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));
1027 static void sip_destroy(struct sip_pvt *p);
1029 /*--- build_via: Build a Via header for a request ---*/
1030 static void build_via(struct sip_pvt *p, char *buf, int len)
1032 char iabuf[INET_ADDRSTRLEN];
1034 /* z9hG4bK is a magic cookie. See RFC 3261 section 8.1.1.7 */
1035 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_RFC3581)
1036 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
1037 else /* Work around buggy UNIDEN UIP200 firmware */
1038 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
1041 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
1042 /* Only used for outbound registrations */
1043 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1046 * Using the localaddr structure built up with localnet statements
1047 * apply it to their address to see if we need to substitute our
1048 * externip or can get away with our internal bindaddr
1050 struct sockaddr_in theirs;
1051 theirs.sin_addr = *them;
1052 if (localaddr && externip.sin_addr.s_addr &&
1053 ast_apply_ha(localaddr, &theirs)) {
1054 char iabuf[INET_ADDRSTRLEN];
1055 if (externexpire && (time(NULL) >= externexpire)) {
1056 struct ast_hostent ahp;
1058 time(&externexpire);
1059 externexpire += externrefresh;
1060 if ((hp = ast_gethostbyname(externhost, &ahp))) {
1061 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1063 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1065 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
1066 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1067 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1069 else if (bindaddr.sin_addr.s_addr)
1070 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
1072 return ast_ouraddrfor(them, us);
1076 /*--- append_history: Append to SIP dialog history */
1077 /* Always returns 0 */
1078 static int append_history(struct sip_pvt *p, const char *event, const char *data)
1080 struct sip_history *hist, *prev;
1083 if (!recordhistory || !p)
1085 if(!(hist = malloc(sizeof(struct sip_history)))) {
1086 ast_log(LOG_WARNING, "Can't allocate memory for history");
1089 memset(hist, 0, sizeof(struct sip_history));
1090 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
1091 /* Trim up nicely */
1094 if ((*c == '\r') || (*c == '\n')) {
1100 /* Enqueue into history */
1112 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
1113 static int retrans_pkt(void *data)
1115 struct sip_pkt *pkt=data, *prev, *cur = NULL;
1116 char iabuf[INET_ADDRSTRLEN];
1117 int reschedule = DEFAULT_RETRANS;
1120 ast_mutex_lock(&pkt->owner->lock);
1122 if (pkt->retrans < MAX_RETRANS) {
1126 if (!pkt->timer_t1) { /* Re-schedule using timer_a and timer_t1 */
1127 if (sipdebug && option_debug > 3)
1128 ast_log(LOG_DEBUG, "SIP TIMER: Not rescheduling id #%d:%s (Method %d) (No timer T1)\n", pkt->retransid, sip_methods[pkt->method].text, pkt->method);
1132 if (sipdebug && option_debug > 3)
1133 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1137 pkt->timer_a = 2 * pkt->timer_a;
1139 /* For non-invites, a maximum of 4 secs */
1140 if (pkt->method != SIP_INVITE && pkt->timer_a > 4000)
1141 pkt->timer_a = 4000;
1142 siptimer_a = pkt->timer_t1 * pkt->timer_a; /* Double each time */
1144 /* Reschedule re-transmit */
1145 reschedule = siptimer_a;
1146 if (option_debug > 3)
1147 ast_log(LOG_DEBUG, "** SIP timers: Rescheduling retransmission %d to %d ms (t1 %d ms (Retrans id #%d)) \n", pkt->retrans +1, siptimer_a, pkt->timer_t1, pkt->retransid);
1150 if (pkt->owner && sip_debug_test_pvt(pkt->owner)) {
1151 if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
1152 ast_verbose("Retransmitting #%d (NAT) to %s:%d:\n%s\n---\n", pkt->retrans, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port), pkt->data);
1154 ast_verbose("Retransmitting #%d (no NAT) to %s:%d:\n%s\n---\n", pkt->retrans, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port), pkt->data);
1156 snprintf(buf, sizeof(buf), "ReTx %d", reschedule);
1158 append_history(pkt->owner, buf, pkt->data);
1159 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1160 ast_mutex_unlock(&pkt->owner->lock);
1163 /* Too many retries */
1164 if (pkt->owner && pkt->method != SIP_OPTIONS) {
1165 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1166 ast_log(LOG_WARNING, "Maximum retries exceeded on transmission %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response" : "Request");
1168 if (pkt->method == SIP_OPTIONS && sipdebug)
1169 ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1171 append_history(pkt->owner, "MaxRetries", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1173 pkt->retransid = -1;
1175 if (ast_test_flag(pkt, FLAG_FATAL)) {
1176 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
1177 ast_mutex_unlock(&pkt->owner->lock);
1179 ast_mutex_lock(&pkt->owner->lock);
1181 if (pkt->owner->owner) {
1182 ast_set_flag(pkt->owner, SIP_ALREADYGONE);
1183 ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1184 ast_queue_hangup(pkt->owner->owner);
1185 ast_mutex_unlock(&pkt->owner->owner->lock);
1187 /* If no channel owner, destroy now */
1188 ast_set_flag(pkt->owner, SIP_NEEDDESTROY);
1191 /* In any case, go ahead and remove the packet */
1193 cur = pkt->owner->packets;
1202 prev->next = cur->next;
1204 pkt->owner->packets = cur->next;
1205 ast_mutex_unlock(&pkt->owner->lock);
1209 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1211 ast_mutex_unlock(&pkt->owner->lock);
1215 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
1216 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1218 struct sip_pkt *pkt;
1219 int siptimer_a = DEFAULT_RETRANS;
1221 pkt = malloc(sizeof(struct sip_pkt) + len + 1);
1224 memset(pkt, 0, sizeof(struct sip_pkt));
1225 memcpy(pkt->data, data, len);
1226 pkt->method = sipmethod;
1227 pkt->packetlen = len;
1228 pkt->next = p->packets;
1232 pkt->data[len] = '\0';
1233 pkt->timer_t1 = p->timer_t1; /* Set SIP timer T1 */
1235 ast_set_flag(pkt, FLAG_FATAL);
1237 siptimer_a = pkt->timer_t1 * 2;
1239 /* Schedule retransmission */
1240 pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1241 if (option_debug > 3 && sipdebug)
1242 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id #%d\n", pkt->retransid);
1243 pkt->next = p->packets;
1246 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen); /* Send packet */
1247 if (sipmethod == SIP_INVITE) {
1248 /* Note this is a pending invite */
1249 p->pendinginvite = seqno;
1254 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
1255 static int __sip_autodestruct(void *data)
1257 struct sip_pvt *p = data;
1261 /* If this is a subscription, tell the phone that we got a timeout */
1262 if (p->subscribed) {
1263 p->subscribed = TIMEOUT;
1264 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, 1); /* Send first notification */
1265 p->subscribed = NONE;
1266 append_history(p, "Subscribestatus", "timeout");
1267 return 10000; /* Reschedule this destruction so that we know that it's gone */
1269 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1270 append_history(p, "AutoDestroy", "");
1272 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
1273 ast_queue_hangup(p->owner);
1280 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
1281 static int sip_scheddestroy(struct sip_pvt *p, int ms)
1284 if (sip_debug_test_pvt(p))
1285 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
1286 if (recordhistory) {
1287 snprintf(tmp, sizeof(tmp), "%d ms", ms);
1288 append_history(p, "SchedDestroy", tmp);
1291 if (p->autokillid > -1)
1292 ast_sched_del(sched, p->autokillid);
1293 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1297 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
1298 static int sip_cancel_destroy(struct sip_pvt *p)
1300 if (p->autokillid > -1)
1301 ast_sched_del(sched, p->autokillid);
1302 append_history(p, "CancelDestroy", "");
1307 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
1308 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1310 struct sip_pkt *cur, *prev = NULL;
1312 int resetinvite = 0;
1313 /* Just in case... */
1316 msg = sip_methods[sipmethod].text;
1320 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1321 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
1322 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1323 ast_mutex_lock(&p->lock);
1324 if (!resp && (seqno == p->pendinginvite)) {
1325 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1326 p->pendinginvite = 0;
1329 /* this is our baby */
1331 prev->next = cur->next;
1333 p->packets = cur->next;
1334 if (cur->retransid > -1) {
1335 if (sipdebug && option_debug > 3)
1336 ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1337 ast_sched_del(sched, cur->retransid);
1340 ast_mutex_unlock(&p->lock);
1347 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1351 /* Pretend to ack all packets */
1352 static int __sip_pretend_ack(struct sip_pvt *p)
1354 struct sip_pkt *cur=NULL;
1357 if (cur == p->packets) {
1358 ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1363 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), cur->method);
1364 else { /* Unknown packet type */
1367 ast_copy_string(method, p->packets->data, sizeof(method));
1368 c = ast_skip_blanks(method); /* XXX what ? */
1370 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), find_sip_method(method));
1376 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
1377 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1379 struct sip_pkt *cur;
1381 char *msg = sip_methods[sipmethod].text;
1385 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1386 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
1387 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1388 /* this is our baby */
1389 if (cur->retransid > -1) {
1390 if (option_debug > 3 && sipdebug)
1391 ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, msg);
1392 ast_sched_del(sched, cur->retransid);
1394 cur->retransid = -1;
1400 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");
1404 static void parse_request(struct sip_request *req);
1405 static char *get_header(struct sip_request *req, char *name);
1406 static void copy_request(struct sip_request *dst,struct sip_request *src);
1408 /*--- parse_copy: Copy SIP request, parse it */
1409 static void parse_copy(struct sip_request *dst, struct sip_request *src)
1411 memset(dst, 0, sizeof(*dst));
1412 memcpy(dst->data, src->data, sizeof(dst->data));
1413 dst->len = src->len;
1417 /*--- send_response: Transmit response on SIP request---*/
1418 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1421 char iabuf[INET_ADDRSTRLEN];
1422 struct sip_request tmp;
1425 if (sip_debug_test_pvt(p)) {
1426 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1427 ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
1429 ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
1432 if (recordhistory) {
1433 parse_copy(&tmp, req);
1434 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1435 append_history(p, "TxRespRel", tmpmsg);
1437 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1), req->method);
1439 if (recordhistory) {
1440 parse_copy(&tmp, req);
1441 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1442 append_history(p, "TxResp", tmpmsg);
1444 res = __sip_xmit(p, req->data, req->len);
1451 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
1452 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1455 char iabuf[INET_ADDRSTRLEN];
1456 struct sip_request tmp;
1459 if (sip_debug_test_pvt(p)) {
1460 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1461 ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
1463 ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
1466 if (recordhistory) {
1467 parse_copy(&tmp, req);
1468 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1469 append_history(p, "TxReqRel", tmpmsg);
1471 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method);
1473 if (recordhistory) {
1474 parse_copy(&tmp, req);
1475 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1476 append_history(p, "TxReq", tmpmsg);
1478 res = __sip_xmit(p, req->data, req->len);
1483 /*--- get_in_brackets: Pick out text in brackets from character string ---*/
1484 /* returns pointer to terminated stripped string. modifies input string. */
1485 static char *get_in_brackets(char *tmp)
1489 char *first_bracket;
1490 char *second_bracket;
1495 first_quote = strchr(parse, '"');
1496 first_bracket = strchr(parse, '<');
1497 if (first_quote && first_bracket && (first_quote < first_bracket)) {
1499 for (parse = first_quote + 1; *parse; parse++) {
1500 if ((*parse == '"') && (last_char != '\\'))
1505 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
1511 if (first_bracket) {
1512 second_bracket = strchr(first_bracket + 1, '>');
1513 if (second_bracket) {
1514 *second_bracket = '\0';
1515 return first_bracket + 1;
1517 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1525 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
1526 /* Called from PBX core text message functions */
1527 static int sip_sendtext(struct ast_channel *ast, const char *text)
1529 struct sip_pvt *p = ast->tech_pvt;
1530 int debug=sip_debug_test_pvt(p);
1533 ast_verbose("Sending text %s on %s\n", text, ast->name);
1536 if (!text || ast_strlen_zero(text))
1539 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1540 transmit_message_with_text(p, text);
1544 /*--- realtime_update_peer: Update peer object in realtime storage ---*/
1545 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
1549 char regseconds[20] = "0";
1551 if (expirey) { /* Registration */
1555 snprintf(regseconds, sizeof(regseconds), "%ld", nowtime); /* Expiration time */
1556 ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1557 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1559 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1562 /*--- register_peer_exten: Automatically add peer extension to dial plan ---*/
1563 static void register_peer_exten(struct sip_peer *peer, int onoff)
1566 char *stringp, *ext;
1567 if (!ast_strlen_zero(regcontext)) {
1568 ast_copy_string(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi));
1570 while((ext = strsep(&stringp, "&"))) {
1572 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, channeltype);
1574 ast_context_remove_extension(regcontext, ext, 1, NULL);
1579 /*--- sip_destroy_peer: Destroy peer object from memory */
1580 static void sip_destroy_peer(struct sip_peer *peer)
1582 /* Delete it, it needs to disappear */
1584 sip_destroy(peer->call);
1585 if (peer->chanvars) {
1586 ast_variables_destroy(peer->chanvars);
1587 peer->chanvars = NULL;
1589 if (peer->expire > -1)
1590 ast_sched_del(sched, peer->expire);
1591 if (peer->pokeexpire > -1)
1592 ast_sched_del(sched, peer->pokeexpire);
1593 register_peer_exten(peer, 0);
1594 ast_free_ha(peer->ha);
1595 if (ast_test_flag(peer, SIP_SELFDESTRUCT))
1597 else if (ast_test_flag(peer, SIP_REALTIME))
1601 clear_realm_authentication(peer->auth);
1602 peer->auth = (struct sip_auth *) NULL;
1604 ast_dnsmgr_release(peer->dnsmgr);
1608 /*--- update_peer: Update peer data in database (if used) ---*/
1609 static void update_peer(struct sip_peer *p, int expiry)
1611 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTUPDATE) &&
1612 (ast_test_flag(p, SIP_REALTIME) ||
1613 ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS))) {
1614 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1619 /*--- realtime_peer: Get peer from realtime storage ---*/
1620 /* Checks the "sippeers" realtime family from extconfig.conf */
1621 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1623 struct sip_peer *peer=NULL;
1624 struct ast_variable *var;
1625 struct ast_variable *tmp;
1626 char *newpeername = (char *) peername;
1629 /* First check on peer name */
1631 var = ast_load_realtime("sippeers", "name", peername, NULL);
1632 else if (sin) { /* Then check on IP address */
1633 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1634 var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);
1642 /* If this is type=user, then skip this object. */
1644 if (!strcasecmp(tmp->name, "type") &&
1645 !strcasecmp(tmp->value, "user")) {
1646 ast_variables_destroy(var);
1648 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
1649 newpeername = tmp->value;
1654 if (!newpeername) { /* Did not find peer in realtime */
1655 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
1656 ast_variables_destroy(var);
1657 return (struct sip_peer *) NULL;
1660 /* Peer found in realtime, now build it in memory */
1661 peer = build_peer(newpeername, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1664 ast_variables_destroy(var);
1665 return (struct sip_peer *) NULL;
1667 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1669 ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1670 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR)) {
1671 if (peer->expire > -1) {
1672 ast_sched_del(sched, peer->expire);
1674 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1676 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1678 ast_set_flag(peer, SIP_REALTIME);
1680 ast_variables_destroy(var);
1684 /*--- sip_addrcmp: Support routine for find_peer ---*/
1685 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1687 /* We know name is the first field, so we can cast */
1688 struct sip_peer *p = (struct sip_peer *)name;
1689 return !(!inaddrcmp(&p->addr, sin) ||
1690 (ast_test_flag(p, SIP_INSECURE_PORT) &&
1691 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1694 /*--- find_peer: Locate peer by name or ip address */
1695 /* This is used on incoming SIP message to find matching peer on ip
1696 or outgoing message to find matching peer on name */
1697 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1699 struct sip_peer *p = NULL;
1702 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1704 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1706 if (!p && realtime) {
1707 p = realtime_peer(peer, sin);
1713 /*--- sip_destroy_user: Remove user object from in-memory storage ---*/
1714 static void sip_destroy_user(struct sip_user *user)
1716 ast_free_ha(user->ha);
1717 if (user->chanvars) {
1718 ast_variables_destroy(user->chanvars);
1719 user->chanvars = NULL;
1721 if (ast_test_flag(user, SIP_REALTIME))
1728 /*--- realtime_user: Load user from realtime storage ---*/
1729 /* Loads user from "sipusers" category in realtime (extconfig.conf) */
1730 /* Users are matched on From: user name (the domain in skipped) */
1731 static struct sip_user *realtime_user(const char *username)
1733 struct ast_variable *var;
1734 struct ast_variable *tmp;
1735 struct sip_user *user = NULL;
1737 var = ast_load_realtime("sipusers", "name", username, NULL);
1744 if (!strcasecmp(tmp->name, "type") &&
1745 !strcasecmp(tmp->value, "peer")) {
1746 ast_variables_destroy(var);
1754 user = build_user(username, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1756 if (!user) { /* No user found */
1757 ast_variables_destroy(var);
1761 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1762 ast_set_flag((&user->flags_page2), SIP_PAGE2_RTCACHEFRIENDS);
1764 ASTOBJ_CONTAINER_LINK(&userl,user);
1766 /* Move counter from s to r... */
1769 ast_set_flag(user, SIP_REALTIME);
1771 ast_variables_destroy(var);
1775 /*--- find_user: Locate user by name ---*/
1776 /* Locates user by name (From: sip uri user name part) first
1777 from in-memory list (static configuration) then from
1778 realtime storage (defined in extconfig.conf) */
1779 static struct sip_user *find_user(const char *name, int realtime)
1781 struct sip_user *u = NULL;
1782 u = ASTOBJ_CONTAINER_FIND(&userl,name);
1783 if (!u && realtime) {
1784 u = realtime_user(name);
1789 /*--- create_addr_from_peer: create address structure from peer reference ---*/
1790 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
1794 if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
1795 (!peer->maxms || ((peer->lastms >= 0) && (peer->lastms <= peer->maxms)))) {
1796 if (peer->addr.sin_addr.s_addr) {
1797 r->sa.sin_family = peer->addr.sin_family;
1798 r->sa.sin_addr = peer->addr.sin_addr;
1799 r->sa.sin_port = peer->addr.sin_port;
1801 r->sa.sin_family = peer->defaddr.sin_family;
1802 r->sa.sin_addr = peer->defaddr.sin_addr;
1803 r->sa.sin_port = peer->defaddr.sin_port;
1805 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1810 ast_copy_flags(r, peer,
1811 SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE |
1812 SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
1813 r->capability = peer->capability;
1814 r->prefs = peer->prefs;
1816 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1817 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1820 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1821 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1823 ast_copy_string(r->peername, peer->username, sizeof(r->peername));
1824 ast_copy_string(r->authname, peer->username, sizeof(r->authname));
1825 ast_copy_string(r->username, peer->username, sizeof(r->username));
1826 ast_copy_string(r->peersecret, peer->secret, sizeof(r->peersecret));
1827 ast_copy_string(r->peermd5secret, peer->md5secret, sizeof(r->peermd5secret));
1828 ast_copy_string(r->tohost, peer->tohost, sizeof(r->tohost));
1829 ast_copy_string(r->fullcontact, peer->fullcontact, sizeof(r->fullcontact));
1830 if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
1831 if ((callhost = strchr(r->callid, '@'))) {
1832 strncpy(callhost + 1, peer->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1835 if (ast_strlen_zero(r->tohost)) {
1836 if (peer->addr.sin_addr.s_addr)
1837 ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->addr.sin_addr);
1839 ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->defaddr.sin_addr);
1841 if (!ast_strlen_zero(peer->fromdomain))
1842 ast_copy_string(r->fromdomain, peer->fromdomain, sizeof(r->fromdomain));
1843 if (!ast_strlen_zero(peer->fromuser))
1844 ast_copy_string(r->fromuser, peer->fromuser, sizeof(r->fromuser));
1845 r->maxtime = peer->maxms;
1846 r->callgroup = peer->callgroup;
1847 r->pickupgroup = peer->pickupgroup;
1848 /* Set timer T1 to RTT for this peer (if known by qualify=) */
1849 if (peer->maxms && peer->lastms)
1850 r->timer_t1 = peer->lastms;
1851 if ((ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_AUTO))
1852 r->noncodeccapability |= AST_RTP_DTMF;
1854 r->noncodeccapability &= ~AST_RTP_DTMF;
1855 ast_copy_string(r->context, peer->context,sizeof(r->context));
1856 r->rtptimeout = peer->rtptimeout;
1857 r->rtpholdtimeout = peer->rtpholdtimeout;
1858 r->rtpkeepalive = peer->rtpkeepalive;
1859 if (peer->call_limit)
1860 ast_set_flag(r, SIP_CALL_LIMIT);
1865 /*--- create_addr: create address structure from peer name ---*/
1866 /* Or, if peer not found, find it in the global DNS */
1867 /* returns TRUE (-1) on failure, FALSE on success */
1868 static int create_addr(struct sip_pvt *dialog, char *opeer)
1871 struct ast_hostent ahp;
1876 char host[MAXHOSTNAMELEN], *hostn;
1879 ast_copy_string(peer, opeer, sizeof(peer));
1880 port = strchr(peer, ':');
1885 dialog->sa.sin_family = AF_INET;
1886 dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
1887 p = find_peer(peer, NULL, 1);
1891 if (create_addr_from_peer(dialog, p))
1892 ASTOBJ_UNREF(p, sip_destroy_peer);
1900 portno = atoi(port);
1902 portno = DEFAULT_SIP_PORT;
1904 char service[MAXHOSTNAMELEN];
1907 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1908 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1914 hp = ast_gethostbyname(hostn, &ahp);
1916 ast_copy_string(dialog->tohost, peer, sizeof(dialog->tohost));
1917 memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
1918 dialog->sa.sin_port = htons(portno);
1919 memcpy(&dialog->recv, &dialog->sa, sizeof(dialog->recv));
1922 ast_log(LOG_WARNING, "No such host: %s\n", peer);
1926 ASTOBJ_UNREF(p, sip_destroy_peer);
1931 /*--- auto_congest: Scheduled congestion on a call ---*/
1932 static int auto_congest(void *nothing)
1934 struct sip_pvt *p = nothing;
1935 ast_mutex_lock(&p->lock);
1938 if (!ast_mutex_trylock(&p->owner->lock)) {
1939 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1940 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1941 ast_mutex_unlock(&p->owner->lock);
1944 ast_mutex_unlock(&p->lock);
1951 /*--- sip_call: Initiate SIP call from PBX ---*/
1952 /* used from the dial() application */
1953 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1958 char *osphandle = NULL;
1960 struct varshead *headp;
1961 struct ast_var_t *current;
1966 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1967 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1972 /* Check whether there is vxml_url, distinctive ring variables */
1974 headp=&ast->varshead;
1975 AST_LIST_TRAVERSE(headp,current,entries) {
1976 /* Check whether there is a VXML_URL variable */
1977 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
1978 p->options->vxml_url = ast_var_value(current);
1979 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
1980 p->options->uri_options = ast_var_value(current);
1981 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
1982 /* Check whether there is a ALERT_INFO variable */
1983 p->options->distinctive_ring = ast_var_value(current);
1984 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
1985 /* Check whether there is a variable with a name starting with SIPADDHEADER */
1986 p->options->addsipheaders = 1;
1991 else if (!p->options->osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1992 p->options->osptoken = ast_var_value(current);
1993 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1994 osphandle = ast_var_value(current);
2000 ast_set_flag(p, SIP_OUTGOING);
2002 if (!p->options->osptoken || !osphandle || (sscanf(osphandle, "%d", &p->osphandle) != 1)) {
2003 /* Force Disable OSP support */
2004 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", p->options->osptoken, osphandle);
2005 p->options->osptoken = NULL;
2010 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
2011 res = update_call_counter(p, INC_CALL_LIMIT);
2013 p->callingpres = ast->cid.cid_pres;
2014 p->jointcapability = p->capability;
2015 transmit_invite(p, SIP_INVITE, 1, 2);
2017 /* Initialize auto-congest time */
2018 p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2024 /*--- sip_registry_destroy: Destroy registry object ---*/
2025 /* Objects created with the register= statement in static configuration */
2026 static void sip_registry_destroy(struct sip_registry *reg)
2030 /* Clear registry before destroying to ensure
2031 we don't get reentered trying to grab the registry lock */
2032 reg->call->registry = NULL;
2033 sip_destroy(reg->call);
2035 if (reg->expire > -1)
2036 ast_sched_del(sched, reg->expire);
2037 if (reg->timeout > -1)
2038 ast_sched_del(sched, reg->timeout);
2044 /*--- __sip_destroy: Execute destrucion of call structure, release memory---*/
2045 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2047 struct sip_pvt *cur, *prev = NULL;
2049 struct sip_history *hist;
2051 if (sip_debug_test_pvt(p))
2052 ast_verbose("Destroying call '%s'\n", p->callid);
2055 sip_dump_history(p);
2060 if (p->stateid > -1)
2061 ast_extension_state_del(p->stateid, NULL);
2063 ast_sched_del(sched, p->initid);
2064 if (p->autokillid > -1)
2065 ast_sched_del(sched, p->autokillid);
2068 ast_rtp_destroy(p->rtp);
2071 ast_rtp_destroy(p->vrtp);
2074 free_old_route(p->route);
2078 if (p->registry->call == p)
2079 p->registry->call = NULL;
2080 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
2086 if (p->rpid_from && (p->rpid_from != p->from))
2089 /* Unlink us from the owner if we have one */
2092 ast_mutex_lock(&p->owner->lock);
2093 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2094 p->owner->tech_pvt = NULL;
2096 ast_mutex_unlock(&p->owner->lock);
2101 p->history = p->history->next;
2109 prev->next = cur->next;
2118 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2122 ast_sched_del(sched, p->initid);
2124 while((cp = p->packets)) {
2125 p->packets = p->packets->next;
2126 if (cp->retransid > -1) {
2127 ast_sched_del(sched, cp->retransid);
2132 ast_variables_destroy(p->chanvars);
2135 ast_mutex_destroy(&p->lock);
2139 /*--- update_call_counter: Handle call_limit for SIP users ---*/
2140 /* Note: This is going to be replaced by app_groupcount */
2141 /* Thought: For realtime, we should propably update storage with inuse counter... */
2142 static int update_call_counter(struct sip_pvt *fup, int event)
2145 int *inuse, *call_limit;
2146 int outgoing = ast_test_flag(fup, SIP_OUTGOING);
2147 struct sip_user *u = NULL;
2148 struct sip_peer *p = NULL;
2150 if (option_debug > 2)
2151 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2152 /* Test if we need to check call limits, in order to avoid
2153 realtime lookups if we do not need it */
2154 if (!ast_test_flag(fup, SIP_CALL_LIMIT))
2157 ast_copy_string(name, fup->username, sizeof(name));
2159 /* Check the list of users */
2160 u = find_user(name, 1);
2163 call_limit = &u->call_limit;
2166 /* Try to find peer */
2168 p = find_peer(fup->peername, NULL, 1);
2171 call_limit = &p->call_limit;
2172 ast_copy_string(name, fup->peername, sizeof(name));
2174 if (option_debug > 1)
2175 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2180 /* incoming and outgoing affects the inUse counter */
2181 case DEC_CALL_LIMIT:
2187 if (option_debug > 1 || sipdebug) {
2188 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2191 case INC_CALL_LIMIT:
2192 if (*call_limit > 0 ) {
2193 if (*inuse >= *call_limit) {
2194 ast_log(LOG_ERROR, "Call %s %s '%s' rejected due to usage limit of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2195 /* inc inUse as well */
2196 if ( event == INC_CALL_LIMIT ) {
2200 ASTOBJ_UNREF(u,sip_destroy_user);
2202 ASTOBJ_UNREF(p,sip_destroy_peer);
2207 if (option_debug > 1 || sipdebug) {
2208 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2212 ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2215 ASTOBJ_UNREF(u,sip_destroy_user);
2217 ASTOBJ_UNREF(p,sip_destroy_peer);
2221 /*--- sip_destroy: Destroy SIP call structure ---*/
2222 static void sip_destroy(struct sip_pvt *p)
2224 ast_mutex_lock(&iflock);
2225 __sip_destroy(p, 1);
2226 ast_mutex_unlock(&iflock);
2230 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
2232 /*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
2233 static int hangup_sip2cause(int cause)
2235 /* Possible values taken from causes.h */
2238 case 403: /* Not found */
2239 return AST_CAUSE_CALL_REJECTED;
2240 case 404: /* Not found */
2241 return AST_CAUSE_UNALLOCATED;
2242 case 408: /* No reaction */
2243 return AST_CAUSE_NO_USER_RESPONSE;
2244 case 480: /* No answer */
2245 return AST_CAUSE_FAILURE;
2246 case 483: /* Too many hops */
2247 return AST_CAUSE_NO_ANSWER;
2248 case 486: /* Busy everywhere */
2249 return AST_CAUSE_BUSY;
2250 case 488: /* No codecs approved */
2251 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2252 case 500: /* Server internal failure */
2253 return AST_CAUSE_FAILURE;
2254 case 501: /* Call rejected */
2255 return AST_CAUSE_FACILITY_REJECTED;
2257 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2258 case 503: /* Service unavailable */
2259 return AST_CAUSE_CONGESTION;
2261 return AST_CAUSE_NORMAL;
2268 /*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
2269 /* Possible values from causes.h
2270 AST_CAUSE_NOTDEFINED AST_CAUSE_NORMAL AST_CAUSE_BUSY
2271 AST_CAUSE_FAILURE AST_CAUSE_CONGESTION AST_CAUSE_UNALLOCATED
2273 In addition to these, a lot of PRI codes is defined in causes.h
2274 ...should we take care of them too ?
2278 ISUP Cause value SIP response
2279 ---------------- ------------
2280 1 unallocated number 404 Not Found
2281 2 no route to network 404 Not found
2282 3 no route to destination 404 Not found
2283 16 normal call clearing --- (*)
2284 17 user busy 486 Busy here
2285 18 no user responding 408 Request Timeout
2286 19 no answer from the user 480 Temporarily unavailable
2287 20 subscriber absent 480 Temporarily unavailable
2288 21 call rejected 403 Forbidden (+)
2289 22 number changed (w/o diagnostic) 410 Gone
2290 22 number changed (w/ diagnostic) 301 Moved Permanently
2291 23 redirection to new destination 410 Gone
2292 26 non-selected user clearing 404 Not Found (=)
2293 27 destination out of order 502 Bad Gateway
2294 28 address incomplete 484 Address incomplete
2295 29 facility rejected 501 Not implemented
2296 31 normal unspecified 480 Temporarily unavailable
2298 static char *hangup_cause2sip(int cause)
2302 case AST_CAUSE_UNALLOCATED: /* 1 */
2303 case AST_CAUSE_NO_ROUTE_DESTINATION: /* 3 IAX2: Can't find extension in context */
2304 case AST_CAUSE_NO_ROUTE_TRANSIT_NET: /* 2 */
2305 return "404 Not Found";
2306 case AST_CAUSE_CONGESTION: /* 34 */
2307 case AST_CAUSE_SWITCH_CONGESTION: /* 42 */
2308 return "503 Service Unavailable";
2309 case AST_CAUSE_NO_USER_RESPONSE: /* 18 */
2310 return "408 Request Timeout";
2311 case AST_CAUSE_NO_ANSWER: /* 19 */
2312 return "480 Temporarily unavailable";
2313 case AST_CAUSE_CALL_REJECTED: /* 21 */
2314 return "403 Forbidden";
2315 case AST_CAUSE_NUMBER_CHANGED: /* 22 */
2317 case AST_CAUSE_NORMAL_UNSPECIFIED: /* 31 */
2318 return "480 Temporarily unavailable";
2319 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2320 return "484 Address incomplete";
2321 case AST_CAUSE_USER_BUSY:
2322 return "486 Busy here";
2323 case AST_CAUSE_FAILURE:
2324 return "500 Server internal failure";
2325 case AST_CAUSE_FACILITY_REJECTED: /* 29 */
2326 return "501 Not Implemented";
2327 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2328 return "503 Service Unavailable";
2329 /* Used in chan_iax2 */
2330 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2331 return "502 Bad Gateway";
2332 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL: /* Can't find codec to connect to host */
2333 return "488 Not Acceptable Here";
2335 case AST_CAUSE_NOTDEFINED:
2337 ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2346 /*--- sip_hangup: Hangup SIP call ---*/
2347 /* Part of PBX interface */
2348 static int sip_hangup(struct ast_channel *ast)
2350 struct sip_pvt *p = ast->tech_pvt;
2352 struct ast_flags locflags = {0};
2355 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
2359 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2361 ast_mutex_lock(&p->lock);
2363 if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
2364 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
2367 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter\n", p->username);
2368 update_call_counter(p, DEC_CALL_LIMIT);
2369 /* Determine how to disconnect */
2370 if (p->owner != ast) {
2371 ast_log(LOG_WARNING, "Huh? We aren't the owner? Can't hangup call.\n");
2372 ast_mutex_unlock(&p->lock);
2375 /* If the call is not UP, we need to send CANCEL instead of BYE */
2376 if (ast->_state != AST_STATE_UP)
2382 ast_dsp_free(p->vad);
2385 ast->tech_pvt = NULL;
2387 ast_mutex_lock(&usecnt_lock);
2389 ast_mutex_unlock(&usecnt_lock);
2390 ast_update_use_count();
2392 ast_set_flag(&locflags, SIP_NEEDDESTROY);
2394 /* Start the process if it's not already started */
2395 if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2396 if (needcancel) { /* Outgoing call, not up */
2397 if (ast_test_flag(p, SIP_OUTGOING)) {
2398 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, 1, 0);
2399 /* Actually don't destroy us yet, wait for the 487 on our original
2400 INVITE, but do set an autodestruct just in case we never get it. */
2401 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2402 sip_scheddestroy(p, 15000);
2403 /* stop retransmitting an INVITE that has not received a response */
2404 __sip_pretend_ack(p);
2405 if ( p->initid != -1 ) {
2406 /* channel still up - reverse dec of inUse counter
2407 only if the channel is not auto-congested */
2408 update_call_counter(p, INC_CALL_LIMIT);
2410 } else { /* Incoming call, not up */
2412 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
2413 transmit_response_reliable(p, res, &p->initreq, 1);
2415 transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
2417 } else { /* Call is in UP state, send BYE */
2418 if (!p->pendinginvite) {
2420 transmit_request_with_auth(p, SIP_BYE, 0, 1, 1);
2422 /* Note we will need a BYE when this all settles out
2423 but we can't send one while we have "INVITE" outstanding. */
2424 ast_set_flag(p, SIP_PENDINGBYE);
2425 ast_clear_flag(p, SIP_NEEDREINVITE);
2429 ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);
2430 ast_mutex_unlock(&p->lock);
2434 /*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
2435 /* Part of PBX interface */
2436 static int sip_answer(struct ast_channel *ast)
2440 struct sip_pvt *p = ast->tech_pvt;
2442 ast_mutex_lock(&p->lock);
2443 if (ast->_state != AST_STATE_UP) {
2448 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
2450 fmt=ast_getformatbyname(codec);
2452 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
2453 if (p->jointcapability & fmt) {
2454 p->jointcapability &= fmt;
2455 p->capability &= fmt;
2457 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2458 } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
2461 ast_setstate(ast, AST_STATE_UP);
2463 ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
2464 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
2466 ast_mutex_unlock(&p->lock);
2470 /*--- sip_write: Send frame to media channel (rtp) ---*/
2471 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2473 struct sip_pvt *p = ast->tech_pvt;
2475 switch (frame->frametype) {
2476 case AST_FRAME_VOICE:
2477 if (!(frame->subclass & ast->nativeformats)) {
2478 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2479 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2483 ast_mutex_lock(&p->lock);
2485 /* If channel is not up, activate early media session */
2486 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2487 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2488 ast_set_flag(p, SIP_PROGRESS_SENT);
2490 time(&p->lastrtptx);
2491 res = ast_rtp_write(p->rtp, frame);
2493 ast_mutex_unlock(&p->lock);
2496 case AST_FRAME_VIDEO:
2498 ast_mutex_lock(&p->lock);
2500 /* Activate video early media */
2501 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2502 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2503 ast_set_flag(p, SIP_PROGRESS_SENT);
2505 time(&p->lastrtptx);
2506 res = ast_rtp_write(p->vrtp, frame);
2508 ast_mutex_unlock(&p->lock);
2511 case AST_FRAME_IMAGE:
2515 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2522 /*--- sip_fixup: Fix up a channel: If a channel is consumed, this is called.
2523 Basically update any ->owner links ----*/
2524 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2526 struct sip_pvt *p = newchan->tech_pvt;
2527 ast_mutex_lock(&p->lock);
2528 if (p->owner != oldchan) {
2529 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2530 ast_mutex_unlock(&p->lock);
2534 ast_mutex_unlock(&p->lock);
2538 /*--- sip_senddigit: Send DTMF character on SIP channel */
2539 /* within one call, we're able to transmit in many methods simultaneously */
2540 static int sip_senddigit(struct ast_channel *ast, char digit)
2542 struct sip_pvt *p = ast->tech_pvt;
2544 ast_mutex_lock(&p->lock);
2545 switch (ast_test_flag(p, SIP_DTMF)) {
2547 transmit_info_with_digit(p, digit);
2549 case SIP_DTMF_RFC2833:
2551 ast_rtp_senddigit(p->rtp, digit);
2553 case SIP_DTMF_INBAND:
2557 ast_mutex_unlock(&p->lock);
2561 #define DEFAULT_MAX_FORWARDS 70
2564 /*--- sip_transfer: Transfer SIP call */
2565 static int sip_transfer(struct ast_channel *ast, const char *dest)
2567 struct sip_pvt *p = ast->tech_pvt;
2570 ast_mutex_lock(&p->lock);
2571 if (ast->_state == AST_STATE_RING)
2572 res = sip_sipredirect(p, dest);
2574 res = transmit_refer(p, dest);
2575 ast_mutex_unlock(&p->lock);
2579 /*--- sip_indicate: Play indication to user */
2580 /* With SIP a lot of indications is sent as messages, letting the device play
2581 the indication - busy signal, congestion etc */
2582 static int sip_indicate(struct ast_channel *ast, int condition)
2584 struct sip_pvt *p = ast->tech_pvt;
2587 ast_mutex_lock(&p->lock);
2589 case AST_CONTROL_RINGING:
2590 if (ast->_state == AST_STATE_RING) {
2591 if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2592 (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2593 /* Send 180 ringing if out-of-band seems reasonable */
2594 transmit_response(p, "180 Ringing", &p->initreq);
2595 ast_set_flag(p, SIP_RINGING);
2596 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2599 /* Well, if it's not reasonable, just send in-band */
2604 case AST_CONTROL_BUSY:
2605 if (ast->_state != AST_STATE_UP) {
2606 transmit_response(p, "486 Busy Here", &p->initreq);
2607 ast_set_flag(p, SIP_ALREADYGONE);
2608 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2613 case AST_CONTROL_CONGESTION:
2614 if (ast->_state != AST_STATE_UP) {
2615 transmit_response(p, "503 Service Unavailable", &p->initreq);
2616 ast_set_flag(p, SIP_ALREADYGONE);
2617 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2622 case AST_CONTROL_PROGRESS:
2623 case AST_CONTROL_PROCEEDING:
2624 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2625 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2626 ast_set_flag(p, SIP_PROGRESS_SENT);
2631 case AST_CONTROL_HOLD: /* The other part of the bridge are put on hold */
2633 ast_log(LOG_DEBUG, "Bridged channel now on hold%s\n", p->callid);
2636 case AST_CONTROL_UNHOLD: /* The other part of the bridge are back from hold */
2638 ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2641 case AST_CONTROL_VIDUPDATE: /* Request a video frame update */
2642 if (p->vrtp && !ast_test_flag(p, SIP_NOVIDEO)) {
2643 transmit_info_with_vidupdate(p);
2652 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2656 ast_mutex_unlock(&p->lock);
2662 /*--- sip_new: Initiate a call in the SIP channel */
2663 /* called from sip_request_call (calls from the pbx ) */
2664 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2666 struct ast_channel *tmp;
2667 struct ast_variable *v = NULL;
2670 char iabuf[INET_ADDRSTRLEN];
2671 char peer[MAXHOSTNAMELEN];
2674 ast_mutex_unlock(&i->lock);
2675 /* Don't hold a sip pvt lock while we allocate a channel */
2676 tmp = ast_channel_alloc(1);
2677 ast_mutex_lock(&i->lock);
2679 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2682 tmp->tech = &sip_tech;
2683 /* Select our native format based on codec preference until we receive
2684 something from another device to the contrary. */
2685 ast_mutex_lock(&i->lock);
2686 if (i->jointcapability)
2687 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2688 else if (i->capability)
2689 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2691 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2692 ast_mutex_unlock(&i->lock);
2693 fmt = ast_best_codec(tmp->nativeformats);
2696 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2697 else if (strchr(i->fromdomain,':'))
2698 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2700 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2702 tmp->type = channeltype;
2703 if (ast_test_flag(i, SIP_DTMF) == SIP_DTMF_INBAND) {
2704 i->vad = ast_dsp_new();
2705 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2707 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2710 tmp->fds[0] = ast_rtp_fd(i->rtp);
2711 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2714 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2715 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2717 if (state == AST_STATE_RING)
2719 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2720 tmp->writeformat = fmt;
2721 tmp->rawwriteformat = fmt;
2722 tmp->readformat = fmt;
2723 tmp->rawreadformat = fmt;
2726 tmp->callgroup = i->callgroup;
2727 tmp->pickupgroup = i->pickupgroup;
2728 tmp->cid.cid_pres = i->callingpres;
2729 if (!ast_strlen_zero(i->accountcode))
2730 ast_copy_string(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode));
2732 tmp->amaflags = i->amaflags;
2733 if (!ast_strlen_zero(i->language))
2734 ast_copy_string(tmp->language, i->language, sizeof(tmp->language));
2735 if (!ast_strlen_zero(i->musicclass))
2736 ast_copy_string(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass));
2738 ast_mutex_lock(&usecnt_lock);
2740 ast_mutex_unlock(&usecnt_lock);
2741 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
2742 ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
2743 if (!ast_strlen_zero(i->cid_num))
2744 tmp->cid.cid_num = strdup(i->cid_num);
2745 if (!ast_strlen_zero(i->cid_name))
2746 tmp->cid.cid_name = strdup(i->cid_name);
2747 if (!ast_strlen_zero(i->rdnis))
2748 tmp->cid.cid_rdnis = strdup(i->rdnis);
2749 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2750 tmp->cid.cid_dnid = strdup(i->exten);
2752 if (!ast_strlen_zero(i->uri)) {
2753 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2755 if (!ast_strlen_zero(i->domain)) {
2756 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2758 if (!ast_strlen_zero(i->useragent)) {
2759 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2761 if (!ast_strlen_zero(i->callid)) {
2762 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2765 snprintf(peer, sizeof(peer), "[%s]:%d", ast_inet_ntoa(iabuf, sizeof(iabuf), i->sa.sin_addr), ntohs(i->sa.sin_port));
2766 pbx_builtin_setvar_helper(tmp, "OSPPEER", peer);
2768 ast_setstate(tmp, state);
2769 if (state != AST_STATE_DOWN) {
2770 if (ast_pbx_start(tmp)) {
2771 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2776 /* Set channel variables for this call from configuration */
2777 for (v = i->chanvars ; v ; v = v->next)
2778 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2783 /*--- get_sdp_by_line: Reads one line of SIP message body */
2784 static char* get_sdp_by_line(char* line, char *name, int nameLen)
2786 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2787 return ast_skip_blanks(line + nameLen + 1);
2792 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2793 but the name wrongly applies _only_ sdp */
2794 static char *get_sdp(struct sip_request *req, char *name)
2797 int len = strlen(name);
2800 for (x=0; x<req->lines; x++) {
2801 r = get_sdp_by_line(req->line[x], name, len);
2809 static void sdpLineNum_iterator_init(int* iterator)
2814 static char* get_sdp_iterate(int* iterator,
2815 struct sip_request *req, char *name)
2817 int len = strlen(name);
2820 while (*iterator < req->lines) {
2821 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2828 static char *find_alias(const char *name, char *_default)
2831 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2832 if (!strcasecmp(aliases[x].fullname, name))
2833 return aliases[x].shortname;
2837 static char *__get_header(struct sip_request *req, char *name, int *start)
2842 * Technically you can place arbitrary whitespace both before and after the ':' in
2843 * a header, although RFC3261 clearly says you shouldn't before, and place just
2844 * one afterwards. If you shouldn't do it, what absolute idiot decided it was
2845 * a good idea to say you can do it, and if you can do it, why in the hell would.
2846 * you say you shouldn't.
2847 * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
2848 * and we always allow spaces after that for compatibility.
2850 for (pass = 0; name && pass < 2;pass++) {
2851 int x, len = strlen(name);
2852 for (x=*start; x<req->headers; x++) {
2853 if (!strncasecmp(req->header[x], name, len)) {
2854 char *r = req->header[x] + len; /* skip name */
2855 if (pedanticsipchecking)
2856 r = ast_skip_blanks(r);
2860 return ast_skip_blanks(r+1);
2864 if (pass == 0) /* Try aliases */
2865 name = find_alias(name, NULL);
2868 /* Don't return NULL, so get_header is always a valid pointer */
2872 /*--- get_header: Get header from SIP request ---*/
2873 static char *get_header(struct sip_request *req, char *name)
2876 return __get_header(req, name, &start);
2879 /*--- sip_rtp_read: Read RTP from network ---*/
2880 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2882 /* Retrieve audio/etc from channel. Assumes p->lock is already held. */
2883 struct ast_frame *f;
2884 static struct ast_frame null_frame = { AST_FRAME_NULL, };
2887 /* We have no RTP allocated for this channel */
2893 f = ast_rtp_read(p->rtp); /* RTP Audio */
2896 f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
2899 f = ast_rtp_read(p->vrtp); /* RTP Video */
2902 f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */
2907 /* Don't forward RFC2833 if we're not supposed to */
2908 if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2911 /* We already hold the channel lock */
2912 if (f->frametype == AST_FRAME_VOICE) {
2913 if (f->subclass != p->owner->nativeformats) {
2914 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2915 p->owner->nativeformats = f->subclass;
2916 ast_set_read_format(p->owner, p->owner->readformat);
2917 ast_set_write_format(p->owner, p->owner->writeformat);
2919 if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2920 f = ast_dsp_process(p->owner, p->vad, f);
2921 if (f && (f->frametype == AST_FRAME_DTMF))
2922 ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
2929 /*--- sip_read: Read SIP RTP from channel */
2930 static struct ast_frame *sip_read(struct ast_channel *ast)
2932 struct ast_frame *fr;
2933 struct sip_pvt *p = ast->tech_pvt;
2934 ast_mutex_lock(&p->lock);
2935 fr = sip_rtp_read(ast, p);
2936 time(&p->lastrtprx);
2937 ast_mutex_unlock(&p->lock);
2941 /*--- build_callid: Build SIP CALLID header ---*/
2942 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2947 char iabuf[INET_ADDRSTRLEN];
2948 for (x=0; x<4; x++) {
2950 res = snprintf(callid, len, "%08x", val);
2954 if (!ast_strlen_zero(fromdomain))
2955 snprintf(callid, len, "@%s", fromdomain);
2957 /* It's not important that we really use our right IP here... */
2958 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2961 static void make_our_tag(char *tagbuf, size_t len)
2963 snprintf(tagbuf, len, "as%08x", rand());
2966 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2967 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
2971 if (!(p = calloc(1, sizeof(*p))))
2974 ast_mutex_init(&p->lock);
2976 p->method = intended_method;
2979 p->subscribed = NONE;
2982 if (intended_method != SIP_OPTIONS) /* Peerpoke has it's own system */
2983 p->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
2986 p->osptimelimit = 0;
2989 memcpy(&p->sa, sin, sizeof(p->sa));
2990 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2991 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2993 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2997 make_our_tag(p->tag, sizeof(p->tag));
2998 /* Start with 101 instead of 1 */
3001 if (sip_methods[intended_method].need_rtp) {
3002 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3004 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
3005 if (!p->rtp || (videosupport && !p->vrtp)) {
3006 ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n", videosupport ? "and video" : "", strerror(errno));
3007 ast_mutex_destroy(&p->lock);
3009 ast_variables_destroy(p->chanvars);
3015 ast_rtp_settos(p->rtp, tos);
3017 ast_rtp_settos(p->vrtp, tos);
3018 p->rtptimeout = global_rtptimeout;
3019 p->rtpholdtimeout = global_rtpholdtimeout;
3020 p->rtpkeepalive = global_rtpkeepalive;
3023 if (useglobal_nat && sin) {
3024 /* Setup NAT structure according to global settings if we have an address */
3025 ast_copy_flags(p, &global_flags, SIP_NAT);
3026 memcpy(&p->recv, sin, sizeof(p->recv));
3028 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
3030 ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
3033 if (p->method != SIP_REGISTER)
3034 ast_copy_string(p->fromdomain, default_fromdomain, sizeof(p->fromdomain));
3035 build_via(p, p->via, sizeof(p->via));
3037 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
3039 ast_copy_string(p->callid, callid, sizeof(p->callid));
3040 ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
3041 /* Assign default music on hold class */
3042 strcpy(p->musicclass, global_musicclass);
3043 p->capability = global_capability;
3044 if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_AUTO))
3045 p->noncodeccapability |= AST_RTP_DTMF;
3046 strcpy(p->context, default_context);
3048 /* Add to active dialog list */
3049 ast_mutex_lock(&iflock);
3052 ast_mutex_unlock(&iflock);
3054 ast_log(LOG_DEBUG, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : "(No Call-ID)", sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
3058 /*--- find_call: Connect incoming SIP message to current dialog or create new dialog structure */
3059 /* Called by handle_request ,sipsock_read */
3060 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
3067 callid = get_header(req, "Call-ID");
3069 if (pedanticsipchecking) {
3070 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3071 we need more to identify a branch - so we have to check branch, from
3072 and to tags to identify a call leg.
3073 For Asterisk to behave correctly, you need to turn on pedanticsipchecking
projects / asterisk/asterisk.git / blob