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"
78 #include "asterisk/astosp.h"
81 #ifndef DEFAULT_USERAGENT
82 #define DEFAULT_USERAGENT "Asterisk PBX"
85 #define VIDEO_CODEC_MASK 0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
87 #define IPTOS_MINCOST 0x02
90 /* #define VOCAL_DATA_HACK */
93 #define DEFAULT_DEFAULT_EXPIRY 120
94 #define DEFAULT_MAX_EXPIRY 3600
95 #define DEFAULT_REGISTRATION_TIMEOUT 20
96 #define DEFAULT_REGATTEMPTS_MAX 10
98 /* guard limit must be larger than guard secs */
99 /* guard min must be < 1000, and should be >= 250 */
100 #define EXPIRY_GUARD_SECS 15 /* How long before expiry do we reregister */
101 #define EXPIRY_GUARD_LIMIT 30 /* Below here, we use EXPIRY_GUARD_PCT instead of
103 #define EXPIRY_GUARD_MIN 500 /* This is the minimum guard time applied. If
104 GUARD_PCT turns out to be lower than this, it
105 will use this time instead.
106 This is in milliseconds. */
107 #define EXPIRY_GUARD_PCT 0.20 /* Percentage of expires timeout to use when
108 below EXPIRY_GUARD_LIMIT */
110 static int max_expiry = DEFAULT_MAX_EXPIRY;
111 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
114 #define MAX(a,b) ((a) > (b) ? (a) : (b))
117 #define CALLERID_UNKNOWN "Unknown"
121 #define DEFAULT_MAXMS 2000 /* Must be faster than 2 seconds by default */
122 #define DEFAULT_FREQ_OK 60 * 1000 /* How often to check for the host to be up */
123 #define DEFAULT_FREQ_NOTOK 10 * 1000 /* How often to check, if the host is down... */
125 #define DEFAULT_RETRANS 1000 /* How frequently to retransmit */
126 /* 2 * 500 ms in RFC 3261 */
127 #define MAX_RETRANS 7 /* Try only 7 times for retransmissions */
128 #define MAX_AUTHTRIES 3 /* Try authentication three times, then fail */
131 #define DEBUG_READ 0 /* Recieved data */
132 #define DEBUG_SEND 1 /* Transmit data */
134 static const char desc[] = "Session Initiation Protocol (SIP)";
135 static const char channeltype[] = "SIP";
136 static const char config[] = "sip.conf";
137 static const char notify_config[] = "sip_notify.conf";
142 /* Do _NOT_ make any changes to this enum, or the array following it;
143 if you think you are doing the right thing, you are probably
144 not doing the right thing. If you think there are changes
145 needed, get someone else to review them first _before_
146 submitting a patch. If these two lists do not match properly
147 bad things will happen.
150 enum subscriptiontype {
159 static const struct cfsubscription_types {
160 enum subscriptiontype type;
161 const char * const event;
162 const char * const mediatype;
163 const char * const text;
164 } subscription_types[] = {
165 { NONE, "-", "unknown", "unknown" },
166 /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
167 { DIALOG_INFO_XML, "dialog", "application/dialog-info+xml", "dialog-info+xml" },
168 { CPIM_PIDF_XML, "presence", "application/cpim-pidf+xml", "cpim-pidf+xml" }, /* RFC 3863 */
169 { PIDF_XML, "presence", "application/pidf+xml", "pidf+xml" }, /* RFC 3863 */
170 { XPIDF_XML, "presence", "application/xpidf+xml", "xpidf+xml" } /* Pre-RFC 3863 with MS additions */
192 static const struct cfsip_methods {
194 int need_rtp; /* when this is the 'primary' use for a pvt structure, does it need RTP? */
197 { SIP_UNKNOWN, RTP, "-UNKNOWN-" },
198 { SIP_RESPONSE, NO_RTP, "SIP/2.0" },
199 { SIP_REGISTER, NO_RTP, "REGISTER" },
200 { SIP_OPTIONS, NO_RTP, "OPTIONS" },
201 { SIP_NOTIFY, NO_RTP, "NOTIFY" },
202 { SIP_INVITE, RTP, "INVITE" },
203 { SIP_ACK, NO_RTP, "ACK" },
204 { SIP_PRACK, NO_RTP, "PRACK" },
205 { SIP_BYE, NO_RTP, "BYE" },
206 { SIP_REFER, NO_RTP, "REFER" },
207 { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE" },
208 { SIP_MESSAGE, NO_RTP, "MESSAGE" },
209 { SIP_UPDATE, NO_RTP, "UPDATE" },
210 { SIP_INFO, NO_RTP, "INFO" },
211 { SIP_CANCEL, NO_RTP, "CANCEL" },
212 { SIP_PUBLISH, NO_RTP, "PUBLISH" }
215 /* Structure for conversion between compressed SIP and "normal" SIP */
216 static const struct cfalias {
217 char * const fullname;
218 char * const shortname;
220 { "Content-Type", "c" },
221 { "Content-Encoding", "e" },
225 { "Content-Length", "l" },
228 { "Supported", "k" },
230 { "Referred-By", "b" },
231 { "Allow-Events", "u" },
234 { "Accept-Contact", "a" },
235 { "Reject-Contact", "j" },
236 { "Request-Disposition", "d" },
237 { "Session-Expires", "x" },
240 /* Define SIP option tags, used in Require: and Supported: headers */
241 /* We need to be aware of these properties in the phones to use
242 the replace: header. We should not do that without knowing
243 that the other end supports it...
244 This is nothing we can configure, we learn by the dialog
245 Supported: header on the REGISTER (peer) or the INVITE
247 We are not using many of these today, but will in the future.
248 This is documented in RFC 3261
251 #define NOT_SUPPORTED 0
253 #define SIP_OPT_REPLACES (1 << 0)
254 #define SIP_OPT_100REL (1 << 1)
255 #define SIP_OPT_TIMER (1 << 2)
256 #define SIP_OPT_EARLY_SESSION (1 << 3)
257 #define SIP_OPT_JOIN (1 << 4)
258 #define SIP_OPT_PATH (1 << 5)
259 #define SIP_OPT_PREF (1 << 6)
260 #define SIP_OPT_PRECONDITION (1 << 7)
261 #define SIP_OPT_PRIVACY (1 << 8)
262 #define SIP_OPT_SDP_ANAT (1 << 9)
263 #define SIP_OPT_SEC_AGREE (1 << 10)
264 #define SIP_OPT_EVENTLIST (1 << 11)
265 #define SIP_OPT_GRUU (1 << 12)
266 #define SIP_OPT_TARGET_DIALOG (1 << 13)
268 /* List of well-known SIP options. If we get this in a require,
269 we should check the list and answer accordingly. */
270 static const struct cfsip_options {
271 int id; /* Bitmap ID */
272 int supported; /* Supported by Asterisk ? */
273 char * const text; /* Text id, as in standard */
275 /* Replaces: header for transfer */
276 { SIP_OPT_REPLACES, SUPPORTED, "replaces" },
277 /* RFC3262: PRACK 100% reliability */
278 { SIP_OPT_100REL, NOT_SUPPORTED, "100rel" },
279 /* SIP Session Timers */
280 { SIP_OPT_TIMER, NOT_SUPPORTED, "timer" },
281 /* RFC3959: SIP Early session support */
282 { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
283 /* SIP Join header support */
284 { SIP_OPT_JOIN, NOT_SUPPORTED, "join" },
285 /* RFC3327: Path support */
286 { SIP_OPT_PATH, NOT_SUPPORTED, "path" },
287 /* RFC3840: Callee preferences */
288 { SIP_OPT_PREF, NOT_SUPPORTED, "pref" },
289 /* RFC3312: Precondition support */
290 { SIP_OPT_PRECONDITION, NOT_SUPPORTED, "precondition" },
291 /* RFC3323: Privacy with proxies*/
292 { SIP_OPT_PRIVACY, NOT_SUPPORTED, "privacy" },
293 /* RFC4092: Usage of the SDP ANAT Semantics in the SIP */
294 { SIP_OPT_SDP_ANAT, NOT_SUPPORTED, "sdp-anat" },
295 /* RFC3329: Security agreement mechanism */
296 { SIP_OPT_SEC_AGREE, NOT_SUPPORTED, "sec_agree" },
297 /* SIMPLE events: draft-ietf-simple-event-list-07.txt */
298 { SIP_OPT_EVENTLIST, NOT_SUPPORTED, "eventlist" },
299 /* GRUU: Globally Routable User Agent URI's */
300 { SIP_OPT_GRUU, NOT_SUPPORTED, "gruu" },
301 /* Target-dialog: draft-ietf-sip-target-dialog-00.txt */
302 { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED, "target-dialog" },
306 /* SIP Methods we support */
307 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
309 /* SIP Extensions we support */
310 #define SUPPORTED_EXTENSIONS "replaces"
312 #define DEFAULT_SIP_PORT 5060 /* From RFC 3261 (former 2543) */
313 #define SIP_MAX_PACKET 4096 /* Also from RFC 3261 (2543), should sub headers tho */
315 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
317 #define DEFAULT_CONTEXT "default"
318 static char default_context[AST_MAX_CONTEXT] = DEFAULT_CONTEXT;
319 static char default_subscribecontext[AST_MAX_CONTEXT];
321 #define DEFAULT_VMEXTEN "asterisk"
322 static char global_vmexten[AST_MAX_EXTENSION] = DEFAULT_VMEXTEN;
324 static char default_language[MAX_LANGUAGE] = "";
326 #define DEFAULT_CALLERID "asterisk"
327 static char default_callerid[AST_MAX_EXTENSION] = DEFAULT_CALLERID;
329 static char default_fromdomain[AST_MAX_EXTENSION] = "";
331 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
332 static char default_notifymime[AST_MAX_EXTENSION] = DEFAULT_NOTIFYMIME;
334 static int global_notifyringing = 1; /* Send notifications on ringing */
336 static int default_qualify = 0; /* Default Qualify= setting */
338 static struct ast_flags global_flags = {0}; /* global SIP_ flags */
339 static struct ast_flags global_flags_page2 = {0}; /* more global SIP_ flags */
341 static int srvlookup = 0; /* SRV Lookup on or off. Default is off, RFC behavior is on */
343 static int pedanticsipchecking = 0; /* Extra checking ? Default off */
345 static int autocreatepeer = 0; /* Auto creation of peers at registration? Default off. */
347 static int relaxdtmf = 0;
349 static int global_rtptimeout = 0;
351 static int global_rtpholdtimeout = 0;
353 static int global_rtpkeepalive = 0;
355 static int global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
356 static int global_regattempts_max = DEFAULT_REGATTEMPTS_MAX;
358 /* Object counters */
359 static int suserobjs = 0;
360 static int ruserobjs = 0;
361 static int speerobjs = 0;
362 static int rpeerobjs = 0;
363 static int apeerobjs = 0;
364 static int regobjs = 0;
366 static int global_allowguest = 1; /* allow unauthenticated users/peers to connect? */
368 #define DEFAULT_MWITIME 10
369 static int global_mwitime = DEFAULT_MWITIME; /* Time between MWI checks for peers */
371 static int usecnt =0;
372 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
375 /* Protect the interface list (of sip_pvt's) */
376 AST_MUTEX_DEFINE_STATIC(iflock);
378 /* Protect the monitoring thread, so only one process can kill or start it, and not
379 when it's doing something critical. */
380 AST_MUTEX_DEFINE_STATIC(netlock);
382 AST_MUTEX_DEFINE_STATIC(monlock);
384 /* This is the thread for the monitor which checks for input on the channels
385 which are not currently in use. */
386 static pthread_t monitor_thread = AST_PTHREADT_NULL;
388 static int restart_monitor(void);
390 /* Codecs that we support by default: */
391 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
392 static int noncodeccapability = AST_RTP_DTMF;
394 static struct in_addr __ourip;
395 static struct sockaddr_in outboundproxyip;
398 #define SIP_DEBUG_CONFIG 1 << 0
399 #define SIP_DEBUG_CONSOLE 1 << 1
400 static int sipdebug = 0;
401 static struct sockaddr_in debugaddr;
405 static int videosupport = 0;
407 static int compactheaders = 0; /* send compact sip headers */
409 static int recordhistory = 0; /* Record SIP history. Off by default */
410 static int dumphistory = 0; /* Dump history to verbose before destroying SIP dialog */
412 static char global_musicclass[MAX_MUSICCLASS] = ""; /* Global music on hold class */
413 #define DEFAULT_REALM "asterisk"
414 static char global_realm[MAXHOSTNAMELEN] = DEFAULT_REALM; /* Default realm */
415 static char regcontext[AST_MAX_CONTEXT] = ""; /* Context for auto-extensions */
418 #define DEFAULT_EXPIRY 900
419 static int expiry = DEFAULT_EXPIRY;
421 static struct sched_context *sched;
422 static struct io_context *io;
423 /* The private structures of the sip channels are linked for
424 selecting outgoing channels */
426 #define SIP_MAX_HEADERS 64
427 #define SIP_MAX_LINES 64
429 #define DEC_CALL_LIMIT 0
430 #define INC_CALL_LIMIT 1
432 static struct ast_codec_pref prefs;
435 /* sip_request: The data grabbed from the UDP socket */
437 char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
438 char *rlPart2; /* The Request URI or Response Status */
439 int len; /* Length */
440 int headers; /* # of SIP Headers */
441 int method; /* Method of this request */
442 char *header[SIP_MAX_HEADERS];
443 int lines; /* SDP Content */
444 char *line[SIP_MAX_LINES];
445 char data[SIP_MAX_PACKET];
446 int debug; /* Debug flag for this packet */
451 /* Parameters to the transmit_invite function */
452 struct sip_invite_param {
453 char *distinctive_ring;
463 struct sip_route *next;
467 /* sip_history: Structure for saving transactions within a SIP dialog */
470 struct sip_history *next;
473 /* sip_auth: Creadentials for authentication to other SIP services */
475 char realm[AST_MAX_EXTENSION]; /* Realm in which these credentials are valid */
476 char username[256]; /* Username */
477 char secret[256]; /* Secret */
478 char md5secret[256]; /* MD5Secret */
479 struct sip_auth *next; /* Next auth structure in list */
482 #define SIP_ALREADYGONE (1 << 0) /* Whether or not we've already been destroyed by our peer */
483 #define SIP_NEEDDESTROY (1 << 1) /* if we need to be destroyed */
484 #define SIP_NOVIDEO (1 << 2) /* Didn't get video in invite, don't offer */
485 #define SIP_RINGING (1 << 3) /* Have sent 180 ringing */
486 #define SIP_PROGRESS_SENT (1 << 4) /* Have sent 183 message progress */
487 #define SIP_NEEDREINVITE (1 << 5) /* Do we need to send another reinvite? */
488 #define SIP_PENDINGBYE (1 << 6) /* Need to send bye after we ack? */
489 #define SIP_GOTREFER (1 << 7) /* Got a refer? */
490 #define SIP_PROMISCREDIR (1 << 8) /* Promiscuous redirection */
491 #define SIP_TRUSTRPID (1 << 9) /* Trust RPID headers? */
492 #define SIP_USEREQPHONE (1 << 10) /* Add user=phone to numeric URI. Default off */
493 #define SIP_REALTIME (1 << 11) /* Flag for realtime users */
494 #define SIP_USECLIENTCODE (1 << 12) /* Trust X-ClientCode info message */
495 #define SIP_OUTGOING (1 << 13) /* Is this an outgoing call? */
496 #define SIP_SELFDESTRUCT (1 << 14)
497 #define SIP_DYNAMIC (1 << 15) /* Is this a dynamic peer? */
498 /* --- Choices for DTMF support in SIP channel */
499 #define SIP_DTMF (3 << 16) /* three settings, uses two bits */
500 #define SIP_DTMF_RFC2833 (0 << 16) /* RTP DTMF */
501 #define SIP_DTMF_INBAND (1 << 16) /* Inband audio, only for ULAW/ALAW */
502 #define SIP_DTMF_INFO (2 << 16) /* SIP Info messages */
503 #define SIP_DTMF_AUTO (3 << 16) /* AUTO switch between rfc2833 and in-band DTMF */
505 #define SIP_NAT (3 << 18) /* four settings, uses two bits */
506 #define SIP_NAT_NEVER (0 << 18) /* No nat support */
507 #define SIP_NAT_RFC3581 (1 << 18)
508 #define SIP_NAT_ROUTE (2 << 18)
509 #define SIP_NAT_ALWAYS (3 << 18)
510 /* re-INVITE related settings */
511 #define SIP_REINVITE (3 << 20) /* two bits used */
512 #define SIP_CAN_REINVITE (1 << 20) /* allow peers to be reinvited to send media directly p2p */
513 #define SIP_REINVITE_UPDATE (2 << 20) /* use UPDATE (RFC3311) when reinviting this peer */
514 /* "insecure" settings */
515 #define SIP_INSECURE_PORT (1 << 22) /* don't require matching port for incoming requests */
516 #define SIP_INSECURE_INVITE (1 << 23) /* don't require authentication for incoming INVITEs */
517 /* Sending PROGRESS in-band settings */
518 #define SIP_PROG_INBAND (3 << 24) /* three settings, uses two bits */
519 #define SIP_PROG_INBAND_NEVER (0 << 24)
520 #define SIP_PROG_INBAND_NO (1 << 24)
521 #define SIP_PROG_INBAND_YES (2 << 24)
522 /* Open Settlement Protocol authentication */
523 #define SIP_OSPAUTH (3 << 26) /* four settings, uses two bits */
524 #define SIP_OSPAUTH_NO (0 << 26)
525 #define SIP_OSPAUTH_GATEWAY (1 << 26)
526 #define SIP_OSPAUTH_PROXY (2 << 26)
527 #define SIP_OSPAUTH_EXCLUSIVE (3 << 26)
529 #define SIP_CALL_ONHOLD (1 << 28)
530 #define SIP_CALL_LIMIT (1 << 29)
532 /* a new page of flags for peer */
533 #define SIP_PAGE2_RTCACHEFRIENDS (1 << 0)
534 #define SIP_PAGE2_RTUPDATE (1 << 1)
535 #define SIP_PAGE2_RTAUTOCLEAR (1 << 2)
536 #define SIP_PAGE2_RTIGNOREREGEXPIRE (1 << 3)
538 static int global_rtautoclear = 120;
540 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call */
541 static struct sip_pvt {
542 ast_mutex_t lock; /* Channel private lock */
543 int method; /* SIP method of this packet */
544 char callid[80]; /* Global CallID */
545 char randdata[80]; /* Random data */
546 struct ast_codec_pref prefs; /* codec prefs */
547 unsigned int ocseq; /* Current outgoing seqno */
548 unsigned int icseq; /* Current incoming seqno */
549 ast_group_t callgroup; /* Call group */
550 ast_group_t pickupgroup; /* Pickup group */
551 int lastinvite; /* Last Cseq of invite */
552 unsigned int flags; /* SIP_ flags */
553 int timer_t1; /* SIP timer T1, ms rtt */
554 unsigned int sipoptions; /* Supported SIP sipoptions on the other end */
555 int capability; /* Special capability (codec) */
556 int jointcapability; /* Supported capability at both ends (codecs ) */
557 int peercapability; /* Supported peer capability */
558 int prefcodec; /* Preferred codec (outbound only) */
559 int noncodeccapability;
560 int callingpres; /* Calling presentation */
561 int authtries; /* Times we've tried to authenticate */
562 int expiry; /* How long we take to expire */
563 int branch; /* One random number */
564 int tag; /* Another random number */
565 int sessionid; /* SDP Session ID */
566 int sessionversion; /* SDP Session Version */
567 struct sockaddr_in sa; /* Our peer */
568 struct sockaddr_in redirip; /* Where our RTP should be going if not to us */
569 struct sockaddr_in vredirip; /* Where our Video RTP should be going if not to us */
570 int redircodecs; /* Redirect codecs */
571 struct sockaddr_in recv; /* Received as */
572 struct in_addr ourip; /* Our IP */
573 struct ast_channel *owner; /* Who owns us */
574 char exten[AST_MAX_EXTENSION]; /* Extension where to start */
575 char refer_to[AST_MAX_EXTENSION]; /* Place to store REFER-TO extension */
576 char referred_by[AST_MAX_EXTENSION]; /* Place to store REFERRED-BY extension */
577 char refer_contact[AST_MAX_EXTENSION]; /* Place to store Contact info from a REFER extension */
578 struct sip_pvt *refer_call; /* Call we are referring */
579 struct sip_route *route; /* Head of linked list of routing steps (fm Record-Route) */
580 int route_persistant; /* Is this the "real" route? */
581 char from[256]; /* The From: header */
582 char useragent[256]; /* User agent in SIP request */
583 char context[AST_MAX_CONTEXT]; /* Context for this call */
584 char subscribecontext[AST_MAX_CONTEXT]; /* Subscribecontext */
585 char fromdomain[MAXHOSTNAMELEN]; /* Domain to show in the from field */
586 char fromuser[AST_MAX_EXTENSION]; /* User to show in the user field */
587 char fromname[AST_MAX_EXTENSION]; /* Name to show in the user field */
588 char tohost[MAXHOSTNAMELEN]; /* Host we should put in the "to" field */
589 char language[MAX_LANGUAGE]; /* Default language for this call */
590 char musicclass[MAX_MUSICCLASS]; /* Music on Hold class */
591 char rdnis[256]; /* Referring DNIS */
592 char theirtag[256]; /* Their tag */
593 char username[256]; /* [user] name */
594 char peername[256]; /* [peer] name, not set if [user] */
595 char authname[256]; /* Who we use for authentication */
596 char uri[256]; /* Original requested URI */
597 char okcontacturi[256]; /* URI from the 200 OK on INVITE */
598 char peersecret[256]; /* Password */
599 char peermd5secret[256];
600 struct sip_auth *peerauth; /* Realm authentication */
601 char cid_num[256]; /* Caller*ID */
602 char cid_name[256]; /* Caller*ID */
603 char via[256]; /* Via: header */
604 char fullcontact[128]; /* The Contact: that the UA registers with us */
605 char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
606 char our_contact[256]; /* Our contact header */
607 char realm[MAXHOSTNAMELEN]; /* Authorization realm */
608 char nonce[256]; /* Authorization nonce */
609 char opaque[256]; /* Opaque nonsense */
610 char qop[80]; /* Quality of Protection, since SIP wasn't complicated enough yet. */
611 char domain[MAXHOSTNAMELEN]; /* Authorization domain */
612 char lastmsg[256]; /* Last Message sent/received */
613 int amaflags; /* AMA Flags */
614 int pendinginvite; /* Any pending invite */
616 int osphandle; /* OSP Handle for call */
617 time_t ospstart; /* OSP Start time */
619 struct sip_request initreq; /* Initial request */
621 int maxtime; /* Max time for first response */
622 int maxforwards; /* keep the max-forwards info */
623 int initid; /* Auto-congest ID if appropriate */
624 int autokillid; /* Auto-kill ID */
625 time_t lastrtprx; /* Last RTP received */
626 time_t lastrtptx; /* Last RTP sent */
627 int rtptimeout; /* RTP timeout time */
628 int rtpholdtimeout; /* RTP timeout when on hold */
629 int rtpkeepalive; /* Send RTP packets for keepalive */
630 enum subscriptiontype subscribed; /* Is this call a subscription? */
632 int laststate; /* Last known extension state */
635 struct ast_dsp *vad; /* Voice Activation Detection dsp */
637 struct sip_peer *peerpoke; /* If this calls is to poke a peer, which one */
638 struct sip_registry *registry; /* If this is a REGISTER call, to which registry */
639 struct ast_rtp *rtp; /* RTP Session */
640 struct ast_rtp *vrtp; /* Video RTP session */
641 struct sip_pkt *packets; /* Packets scheduled for re-transmission */
642 struct sip_history *history; /* History of this SIP dialog */
643 struct ast_variable *chanvars; /* Channel variables to set for call */
644 struct sip_pvt *next; /* Next call in chain */
645 struct sip_invite_param *options; /* Options for INVITE */
648 #define FLAG_RESPONSE (1 << 0)
649 #define FLAG_FATAL (1 << 1)
651 /* sip packet - read in sipsock_read, transmitted in send_request */
653 struct sip_pkt *next; /* Next packet */
654 int retrans; /* Retransmission number */
655 int method; /* SIP method for this packet */
656 int seqno; /* Sequence number */
657 unsigned int flags; /* non-zero if this is a response packet (e.g. 200 OK) */
658 struct sip_pvt *owner; /* Owner call */
659 int retransid; /* Retransmission ID */
660 int timer_a; /* SIP timer A, retransmission timer */
661 int timer_t1; /* SIP Timer T1, estimated RTT or 500 ms */
662 int packetlen; /* Length of packet */
666 /* Structure for SIP user data. User's place calls to us */
668 /* Users who can access various contexts */
669 ASTOBJ_COMPONENTS(struct sip_user);
670 char secret[80]; /* Password */
671 char md5secret[80]; /* Password in md5 */
672 char context[AST_MAX_CONTEXT]; /* Default context for incoming calls */
673 char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
674 char cid_num[80]; /* Caller ID num */
675 char cid_name[80]; /* Caller ID name */
676 char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
677 char language[MAX_LANGUAGE]; /* Default language for this user */
678 char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
679 char useragent[256]; /* User agent in SIP request */
680 struct ast_codec_pref prefs; /* codec prefs */
681 ast_group_t callgroup; /* Call group */
682 ast_group_t pickupgroup; /* Pickup Group */
683 unsigned int flags; /* SIP flags */
684 unsigned int sipoptions; /* Supported SIP options */
685 struct ast_flags flags_page2; /* SIP_PAGE2 flags */
686 int amaflags; /* AMA flags for billing */
687 int callingpres; /* Calling id presentation */
688 int capability; /* Codec capability */
689 int inUse; /* Number of calls in use */
690 int call_limit; /* Limit of concurrent calls */
691 struct ast_ha *ha; /* ACL setting */
692 struct ast_variable *chanvars; /* Variables to set for channel created by user */
695 /* Structure for SIP peer data, we place calls to peers if registred or fixed IP address (host) */
697 ASTOBJ_COMPONENTS(struct sip_peer); /* name, refcount, objflags, object pointers */
698 /* peer->name is the unique name of this object */
699 char secret[80]; /* Password */
700 char md5secret[80]; /* Password in MD5 */
701 struct sip_auth *auth; /* Realm authentication list */
702 char context[AST_MAX_CONTEXT]; /* Default context for incoming calls */
703 char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
704 char username[80]; /* Temporary username until registration */
705 char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
706 int amaflags; /* AMA Flags (for billing) */
707 char tohost[MAXHOSTNAMELEN]; /* If not dynamic, IP address */
708 char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
709 char fromuser[80]; /* From: user when calling this peer */
710 char fromdomain[MAXHOSTNAMELEN]; /* From: domain when calling this peer */
711 char fullcontact[256]; /* Contact registred with us (not in sip.conf) */
712 char cid_num[80]; /* Caller ID num */
713 char cid_name[80]; /* Caller ID name */
714 int callingpres; /* Calling id presentation */
715 int inUse; /* Number of calls in use */
716 int call_limit; /* Limit of concurrent calls */
717 char vmexten[AST_MAX_EXTENSION]; /* Dialplan extension for MWI notify message*/
718 char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
719 char language[MAX_LANGUAGE]; /* Default language for prompts */
720 char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
721 char useragent[256]; /* User agent in SIP request (saved from registration) */
722 struct ast_codec_pref prefs; /* codec prefs */
724 time_t lastmsgcheck; /* Last time we checked for MWI */
725 unsigned int flags; /* SIP flags */
726 unsigned int sipoptions; /* Supported SIP options */
727 struct ast_flags flags_page2; /* SIP_PAGE2 flags */
728 int expire; /* When to expire this peer registration */
729 int capability; /* Codec capability */
730 int rtptimeout; /* RTP timeout */
731 int rtpholdtimeout; /* RTP Hold Timeout */
732 int rtpkeepalive; /* Send RTP packets for keepalive */
733 ast_group_t callgroup; /* Call group */
734 ast_group_t pickupgroup; /* Pickup group */
735 struct ast_dnsmgr_entry *dnsmgr;/* DNS refresh manager for peer */
736 struct sockaddr_in addr; /* IP address of peer */
740 struct sip_pvt *call; /* Call pointer */
741 int pokeexpire; /* When to expire poke (qualify= checking) */
742 int lastms; /* How long last response took (in ms), or -1 for no response */
743 int maxms; /* Max ms we will accept for the host to be up, 0 to not monitor */
744 struct timeval ps; /* Ping send time */
746 struct sockaddr_in defaddr; /* Default IP address, used until registration */
747 struct ast_ha *ha; /* Access control list */
748 struct ast_variable *chanvars; /* Variables to set for channel created by user */
752 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
753 static int sip_reloading = 0;
755 /* States for outbound registrations (with register= lines in sip.conf */
756 #define REG_STATE_UNREGISTERED 0
757 #define REG_STATE_REGSENT 1
758 #define REG_STATE_AUTHSENT 2
759 #define REG_STATE_REGISTERED 3
760 #define REG_STATE_REJECTED 4
761 #define REG_STATE_TIMEOUT 5
762 #define REG_STATE_NOAUTH 6
763 #define REG_STATE_FAILED 7
766 /* sip_registry: Registrations with other SIP proxies */
767 struct sip_registry {
768 ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
769 int portno; /* Optional port override */
770 char username[80]; /* Who we are registering as */
771 char authuser[80]; /* Who we *authenticate* as */
772 char hostname[MAXHOSTNAMELEN]; /* Domain or host we register to */
773 char secret[80]; /* Password or key name in []'s */
775 char contact[256]; /* Contact extension */
777 int expire; /* Sched ID of expiration */
778 int regattempts; /* Number of attempts (since the last success) */
779 int timeout; /* sched id of sip_reg_timeout */
780 int refresh; /* How often to refresh */
781 struct sip_pvt *call; /* create a sip_pvt structure for each outbound "registration call" in progress */
782 int regstate; /* Registration state (see above) */
783 int callid_valid; /* 0 means we haven't chosen callid for this registry yet. */
784 char callid[80]; /* Global CallID for this registry */
785 unsigned int ocseq; /* Sequence number we got to for REGISTERs for this registry */
786 struct sockaddr_in us; /* Who the server thinks we are */
789 char realm[MAXHOSTNAMELEN]; /* Authorization realm */
790 char nonce[256]; /* Authorization nonce */
791 char domain[MAXHOSTNAMELEN]; /* Authorization domain */
792 char opaque[256]; /* Opaque nonsense */
793 char qop[80]; /* Quality of Protection. */
795 char lastmsg[256]; /* Last Message sent/received */
798 /*--- The user list: Users and friends ---*/
799 static struct ast_user_list {
800 ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
803 /*--- The peer list: Peers and Friends ---*/
804 static struct ast_peer_list {
805 ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
808 /*--- The register list: Other SIP proxys we register with and call ---*/
809 static struct ast_register_list {
810 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
815 static int __sip_do_register(struct sip_registry *r);
817 static int sipsock = -1;
820 static struct sockaddr_in bindaddr;
821 static struct sockaddr_in externip;
822 static char externhost[MAXHOSTNAMELEN] = "";
823 static time_t externexpire = 0;
824 static int externrefresh = 10;
825 static struct ast_ha *localaddr;
827 /* The list of manual NOTIFY types we know how to send */
828 struct ast_config *notify_types;
830 static struct sip_auth *authl; /* Authentication list */
833 static struct ast_frame *sip_read(struct ast_channel *ast);
834 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
835 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
836 static int transmit_response_with_unsupported(struct sip_pvt *p, char *msg, struct sip_request *req, char *unsupported);
837 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header, int stale);
838 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, int reliable, int newbranch);
839 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int inc, int reliable, int newbranch);
840 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sendsdp, int init);
841 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
842 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
843 static int transmit_info_with_vidupdate(struct sip_pvt *p);
844 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
845 static int transmit_refer(struct sip_pvt *p, const char *dest);
846 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
847 static struct sip_peer *temp_peer(const char *name);
848 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
849 static void free_old_route(struct sip_route *route);
850 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
851 static int update_call_counter(struct sip_pvt *fup, int event);
852 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
853 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
854 static int sip_do_reload(void);
855 static int expire_register(void *data);
856 static int callevents = 0;
858 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
859 static int sip_devicestate(void *data);
860 static int sip_sendtext(struct ast_channel *ast, const char *text);
861 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
862 static int sip_hangup(struct ast_channel *ast);
863 static int sip_answer(struct ast_channel *ast);
864 static struct ast_frame *sip_read(struct ast_channel *ast);
865 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
866 static int sip_indicate(struct ast_channel *ast, int condition);
867 static int sip_transfer(struct ast_channel *ast, const char *dest);
868 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
869 static int sip_senddigit(struct ast_channel *ast, char digit);
870 static int clear_realm_authentication(struct sip_auth *authlist); /* Clear realm authentication list (at reload) */
871 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno); /* Add realm authentication in list */
872 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, char *realm); /* Find authentication for a specific realm */
873 static void append_date(struct sip_request *req); /* Append date to SIP packet */
874 static int determine_firstline_parts(struct sip_request *req);
875 static void sip_dump_history(struct sip_pvt *dialog); /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
876 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
877 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int substate);
879 /* Definition of this channel for channel registration */
880 static const struct ast_channel_tech sip_tech = {
882 .description = "Session Initiation Protocol (SIP)",
883 .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
884 .properties = AST_CHAN_TP_WANTSJITTER,
885 .requester = sip_request_call,
886 .devicestate = sip_devicestate,
888 .hangup = sip_hangup,
889 .answer = sip_answer,
892 .write_video = sip_write,
893 .indicate = sip_indicate,
894 .transfer = sip_transfer,
896 .send_digit = sip_senddigit,
897 .bridge = ast_rtp_bridge,
898 .send_text = sip_sendtext,
901 /*--- find_sip_method: Find SIP method from header */
902 int find_sip_method(char *msg)
906 if (!msg || ast_strlen_zero(msg))
909 /* Strictly speaking, SIP methods are case SENSITIVE, but we don't check */
910 /* following Jon Postel's rule: Be gentle in what you accept, strict with what you send */
911 for (i = 1; (i < (sizeof(sip_methods) / sizeof(sip_methods[0]))) && !res; i++) {
912 if (!strcasecmp(sip_methods[i].text, msg))
913 res = sip_methods[i].id;
918 /*--- parse_sip_options: Parse supported header in incoming packet */
919 unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
923 char *temp = ast_strdupa(supported);
925 unsigned int profile = 0;
927 if (!supported || ast_strlen_zero(supported) )
930 if (option_debug > 2 && sipdebug)
931 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
936 if ( (sep = strchr(next, ',')) != NULL) {
940 while (*next == ' ') /* Skip spaces */
942 if (option_debug > 2 && sipdebug)
943 ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
944 for (i=0; (i < (sizeof(sip_options) / sizeof(sip_options[0]))) && !res; i++) {
945 if (!strcasecmp(next, sip_options[i].text)) {
946 profile |= sip_options[i].id;
948 if (option_debug > 2 && sipdebug)
949 ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
953 if (option_debug > 2 && sipdebug)
954 ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
958 pvt->sipoptions = profile;
960 ast_log(LOG_DEBUG, "* SIP extension value: %d for call %s\n", profile, pvt->callid);
965 /*--- sip_debug_test_addr: See if we pass debug IP filter */
966 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
970 if (debugaddr.sin_addr.s_addr) {
971 if (((ntohs(debugaddr.sin_port) != 0)
972 && (debugaddr.sin_port != addr->sin_port))
973 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
979 /*--- sip_debug_test_pvt: Test PVT for debugging output */
980 static inline int sip_debug_test_pvt(struct sip_pvt *p)
984 return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
988 /*--- __sip_xmit: Transmit SIP message ---*/
989 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
992 char iabuf[INET_ADDRSTRLEN];
994 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
995 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
997 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
999 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));
1004 static void sip_destroy(struct sip_pvt *p);
1006 /*--- build_via: Build a Via header for a request ---*/
1007 static void build_via(struct sip_pvt *p, char *buf, int len)
1009 char iabuf[INET_ADDRSTRLEN];
1011 /* z9hG4bK is a magic cookie. See RFC 3261 section 8.1.1.7 */
1012 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_RFC3581)
1013 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
1014 else /* Work around buggy UNIDEN UIP200 firmware */
1015 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
1018 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
1019 /* Only used for outbound registrations */
1020 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1023 * Using the localaddr structure built up with localnet statements
1024 * apply it to their address to see if we need to substitute our
1025 * externip or can get away with our internal bindaddr
1027 struct sockaddr_in theirs;
1028 theirs.sin_addr = *them;
1029 if (localaddr && externip.sin_addr.s_addr &&
1030 ast_apply_ha(localaddr, &theirs)) {
1031 char iabuf[INET_ADDRSTRLEN];
1032 if (externexpire && (time(NULL) >= externexpire)) {
1033 struct ast_hostent ahp;
1035 time(&externexpire);
1036 externexpire += externrefresh;
1037 if ((hp = ast_gethostbyname(externhost, &ahp))) {
1038 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1040 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1042 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
1043 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1044 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1046 else if (bindaddr.sin_addr.s_addr)
1047 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
1049 return ast_ouraddrfor(them, us);
1053 /*--- append_history: Append to SIP dialog history */
1054 /* Always returns 0 */
1055 static int append_history(struct sip_pvt *p, const char *event, const char *data)
1057 struct sip_history *hist, *prev;
1060 if (!recordhistory || !p)
1062 if(!(hist = malloc(sizeof(struct sip_history)))) {
1063 ast_log(LOG_WARNING, "Can't allocate memory for history");
1066 memset(hist, 0, sizeof(struct sip_history));
1067 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
1068 /* Trim up nicely */
1071 if ((*c == '\r') || (*c == '\n')) {
1077 /* Enqueue into history */
1089 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
1090 static int retrans_pkt(void *data)
1092 struct sip_pkt *pkt=data, *prev, *cur = NULL;
1093 char iabuf[INET_ADDRSTRLEN];
1094 int reschedule = DEFAULT_RETRANS;
1097 ast_mutex_lock(&pkt->owner->lock);
1099 if (pkt->retrans < MAX_RETRANS) {
1103 if (!pkt->timer_t1) { /* Re-schedule using timer_a and timer_t1 */
1104 if (sipdebug && option_debug > 3)
1105 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);
1109 if (sipdebug && option_debug > 3)
1110 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1114 pkt->timer_a = 2 * pkt->timer_a;
1116 /* For non-invites, a maximum of 4 secs */
1117 if (pkt->method != SIP_INVITE && pkt->timer_a > 4000)
1118 pkt->timer_a = 4000;
1119 siptimer_a = pkt->timer_t1 * pkt->timer_a; /* Double each time */
1121 /* Reschedule re-transmit */
1122 reschedule = siptimer_a;
1123 if (option_debug > 3)
1124 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);
1127 if (pkt->owner && sip_debug_test_pvt(pkt->owner)) {
1128 if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
1129 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);
1131 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);
1133 snprintf(buf, sizeof(buf), "ReTx %d", reschedule);
1135 append_history(pkt->owner, buf, pkt->data);
1136 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1137 ast_mutex_unlock(&pkt->owner->lock);
1140 /* Too many retries */
1141 if (pkt->owner && pkt->method != SIP_OPTIONS) {
1142 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1143 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");
1145 if (pkt->method == SIP_OPTIONS && sipdebug)
1146 ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1148 append_history(pkt->owner, "MaxRetries", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1150 pkt->retransid = -1;
1152 if (ast_test_flag(pkt, FLAG_FATAL)) {
1153 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
1154 ast_mutex_unlock(&pkt->owner->lock);
1156 ast_mutex_lock(&pkt->owner->lock);
1158 if (pkt->owner->owner) {
1159 ast_set_flag(pkt->owner, SIP_ALREADYGONE);
1160 ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1161 ast_queue_hangup(pkt->owner->owner);
1162 ast_mutex_unlock(&pkt->owner->owner->lock);
1164 /* If no channel owner, destroy now */
1165 ast_set_flag(pkt->owner, SIP_NEEDDESTROY);
1168 /* In any case, go ahead and remove the packet */
1170 cur = pkt->owner->packets;
1179 prev->next = cur->next;
1181 pkt->owner->packets = cur->next;
1182 ast_mutex_unlock(&pkt->owner->lock);
1186 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1188 ast_mutex_unlock(&pkt->owner->lock);
1192 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
1193 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1195 struct sip_pkt *pkt;
1196 int siptimer_a = DEFAULT_RETRANS;
1198 pkt = malloc(sizeof(struct sip_pkt) + len + 1);
1201 memset(pkt, 0, sizeof(struct sip_pkt));
1202 memcpy(pkt->data, data, len);
1203 pkt->method = sipmethod;
1204 pkt->packetlen = len;
1205 pkt->next = p->packets;
1209 pkt->data[len] = '\0';
1210 pkt->timer_t1 = p->timer_t1; /* Set SIP timer T1 */
1212 ast_set_flag(pkt, FLAG_FATAL);
1214 siptimer_a = pkt->timer_t1 * 2;
1216 /* Schedule retransmission */
1217 pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1218 if (option_debug > 3 && sipdebug)
1219 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id #%d\n", pkt->retransid);
1220 pkt->next = p->packets;
1223 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen); /* Send packet */
1224 if (sipmethod == SIP_INVITE) {
1225 /* Note this is a pending invite */
1226 p->pendinginvite = seqno;
1231 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
1232 static int __sip_autodestruct(void *data)
1234 struct sip_pvt *p = data;
1238 /* If this is a subscription, tell the phone that we got a timeout */
1239 if (p->subscribed) {
1240 p->subscribed = TIMEOUT;
1241 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, 1); /* Send first notification */
1242 p->subscribed = NONE;
1243 append_history(p, "Subscribestatus", "timeout");
1244 return 10000; /* Reschedule this destruction so that we know that it's gone */
1246 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1247 append_history(p, "AutoDestroy", "");
1249 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
1250 ast_queue_hangup(p->owner);
1257 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
1258 static int sip_scheddestroy(struct sip_pvt *p, int ms)
1261 if (sip_debug_test_pvt(p))
1262 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
1263 if (recordhistory) {
1264 snprintf(tmp, sizeof(tmp), "%d ms", ms);
1265 append_history(p, "SchedDestroy", tmp);
1268 if (p->autokillid > -1)
1269 ast_sched_del(sched, p->autokillid);
1270 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1274 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
1275 static int sip_cancel_destroy(struct sip_pvt *p)
1277 if (p->autokillid > -1)
1278 ast_sched_del(sched, p->autokillid);
1279 append_history(p, "CancelDestroy", "");
1284 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
1285 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1287 struct sip_pkt *cur, *prev = NULL;
1289 int resetinvite = 0;
1290 /* Just in case... */
1293 msg = sip_methods[sipmethod].text;
1297 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1298 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
1299 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1300 ast_mutex_lock(&p->lock);
1301 if (!resp && (seqno == p->pendinginvite)) {
1302 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1303 p->pendinginvite = 0;
1306 /* this is our baby */
1308 prev->next = cur->next;
1310 p->packets = cur->next;
1311 if (cur->retransid > -1) {
1312 if (sipdebug && option_debug > 3)
1313 ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1314 ast_sched_del(sched, cur->retransid);
1317 ast_mutex_unlock(&p->lock);
1324 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1328 /* Pretend to ack all packets */
1329 static int __sip_pretend_ack(struct sip_pvt *p)
1331 struct sip_pkt *cur=NULL;
1334 if (cur == p->packets) {
1335 ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1340 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), cur->method);
1341 else { /* Unknown packet type */
1344 ast_copy_string(method, p->packets->data, sizeof(method));
1345 c = ast_skip_blanks(method); /* XXX what ? */
1347 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), find_sip_method(method));
1353 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
1354 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1356 struct sip_pkt *cur;
1358 char *msg = sip_methods[sipmethod].text;
1362 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1363 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
1364 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1365 /* this is our baby */
1366 if (cur->retransid > -1) {
1367 if (option_debug > 3 && sipdebug)
1368 ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, msg);
1369 ast_sched_del(sched, cur->retransid);
1371 cur->retransid = -1;
1377 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");
1381 static void parse_request(struct sip_request *req);
1382 static char *get_header(struct sip_request *req, char *name);
1383 static void copy_request(struct sip_request *dst,struct sip_request *src);
1385 /*--- parse_copy: Copy SIP request, parse it */
1386 static void parse_copy(struct sip_request *dst, struct sip_request *src)
1388 memset(dst, 0, sizeof(*dst));
1389 memcpy(dst->data, src->data, sizeof(dst->data));
1390 dst->len = src->len;
1394 /*--- send_response: Transmit response on SIP request---*/
1395 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1398 char iabuf[INET_ADDRSTRLEN];
1399 struct sip_request tmp;
1402 if (sip_debug_test_pvt(p)) {
1403 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1404 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);
1406 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);
1409 if (recordhistory) {
1410 parse_copy(&tmp, req);
1411 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1412 append_history(p, "TxRespRel", tmpmsg);
1414 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1), req->method);
1416 if (recordhistory) {
1417 parse_copy(&tmp, req);
1418 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1419 append_history(p, "TxResp", tmpmsg);
1421 res = __sip_xmit(p, req->data, req->len);
1428 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
1429 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1432 char iabuf[INET_ADDRSTRLEN];
1433 struct sip_request tmp;
1436 if (sip_debug_test_pvt(p)) {
1437 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1438 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);
1440 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);
1443 if (recordhistory) {
1444 parse_copy(&tmp, req);
1445 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1446 append_history(p, "TxReqRel", tmpmsg);
1448 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method);
1450 if (recordhistory) {
1451 parse_copy(&tmp, req);
1452 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1453 append_history(p, "TxReq", tmpmsg);
1455 res = __sip_xmit(p, req->data, req->len);
1460 /*--- get_in_brackets: Pick out text in brackets from character string ---*/
1461 /* returns pointer to terminated stripped string. modifies input string. */
1462 static char *get_in_brackets(char *tmp)
1466 char *first_bracket;
1467 char *second_bracket;
1472 first_quote = strchr(parse, '"');
1473 first_bracket = strchr(parse, '<');
1474 if (first_quote && first_bracket && (first_quote < first_bracket)) {
1476 for (parse = first_quote + 1; *parse; parse++) {
1477 if ((*parse == '"') && (last_char != '\\'))
1482 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
1488 if (first_bracket) {
1489 second_bracket = strchr(first_bracket + 1, '>');
1490 if (second_bracket) {
1491 *second_bracket = '\0';
1492 return first_bracket + 1;
1494 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1502 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
1503 /* Called from PBX core text message functions */
1504 static int sip_sendtext(struct ast_channel *ast, const char *text)
1506 struct sip_pvt *p = ast->tech_pvt;
1507 int debug=sip_debug_test_pvt(p);
1510 ast_verbose("Sending text %s on %s\n", text, ast->name);
1513 if (!text || ast_strlen_zero(text))
1516 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1517 transmit_message_with_text(p, text);
1521 /*--- realtime_update_peer: Update peer object in realtime storage ---*/
1522 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
1526 char regseconds[20] = "0";
1528 if (expirey) { /* Registration */
1532 snprintf(regseconds, sizeof(regseconds), "%ld", nowtime); /* Expiration time */
1533 ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1534 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1536 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1539 /*--- register_peer_exten: Automatically add peer extension to dial plan ---*/
1540 static void register_peer_exten(struct sip_peer *peer, int onoff)
1543 char *stringp, *ext;
1544 if (!ast_strlen_zero(regcontext)) {
1545 ast_copy_string(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi));
1547 while((ext = strsep(&stringp, "&"))) {
1549 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, channeltype);
1551 ast_context_remove_extension(regcontext, ext, 1, NULL);
1556 /*--- sip_destroy_peer: Destroy peer object from memory */
1557 static void sip_destroy_peer(struct sip_peer *peer)
1559 /* Delete it, it needs to disappear */
1561 sip_destroy(peer->call);
1562 if (peer->chanvars) {
1563 ast_variables_destroy(peer->chanvars);
1564 peer->chanvars = NULL;
1566 if (peer->expire > -1)
1567 ast_sched_del(sched, peer->expire);
1568 if (peer->pokeexpire > -1)
1569 ast_sched_del(sched, peer->pokeexpire);
1570 register_peer_exten(peer, 0);
1571 ast_free_ha(peer->ha);
1572 if (ast_test_flag(peer, SIP_SELFDESTRUCT))
1574 else if (ast_test_flag(peer, SIP_REALTIME))
1578 clear_realm_authentication(peer->auth);
1579 peer->auth = (struct sip_auth *) NULL;
1581 ast_dnsmgr_release(peer->dnsmgr);
1585 /*--- update_peer: Update peer data in database (if used) ---*/
1586 static void update_peer(struct sip_peer *p, int expiry)
1588 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTUPDATE) &&
1589 (ast_test_flag(p, SIP_REALTIME) ||
1590 ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS))) {
1591 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1596 /*--- realtime_peer: Get peer from realtime storage ---*/
1597 /* Checks the "sippeers" realtime family from extconfig.conf */
1598 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1600 struct sip_peer *peer=NULL;
1601 struct ast_variable *var;
1602 struct ast_variable *tmp;
1603 char *newpeername = (char *) peername;
1606 /* First check on peer name */
1608 var = ast_load_realtime("sippeers", "name", peername, NULL);
1609 else if (sin) { /* Then check on IP address */
1610 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1611 var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);
1619 /* If this is type=user, then skip this object. */
1621 if (!strcasecmp(tmp->name, "type") &&
1622 !strcasecmp(tmp->value, "user")) {
1623 ast_variables_destroy(var);
1625 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
1626 newpeername = tmp->value;
1631 if (!newpeername) { /* Did not find peer in realtime */
1632 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
1633 ast_variables_destroy(var);
1634 return (struct sip_peer *) NULL;
1637 /* Peer found in realtime, now build it in memory */
1638 peer = build_peer(newpeername, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1641 ast_variables_destroy(var);
1642 return (struct sip_peer *) NULL;
1644 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1646 ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1647 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR)) {
1648 if (peer->expire > -1) {
1649 ast_sched_del(sched, peer->expire);
1651 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1653 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1655 ast_set_flag(peer, SIP_REALTIME);
1657 ast_variables_destroy(var);
1661 /*--- sip_addrcmp: Support routine for find_peer ---*/
1662 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1664 /* We know name is the first field, so we can cast */
1665 struct sip_peer *p = (struct sip_peer *)name;
1666 return !(!inaddrcmp(&p->addr, sin) ||
1667 (ast_test_flag(p, SIP_INSECURE_PORT) &&
1668 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1671 /*--- find_peer: Locate peer by name or ip address */
1672 /* This is used on incoming SIP message to find matching peer on ip
1673 or outgoing message to find matching peer on name */
1674 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1676 struct sip_peer *p = NULL;
1679 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1681 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1683 if (!p && realtime) {
1684 p = realtime_peer(peer, sin);
1690 /*--- sip_destroy_user: Remove user object from in-memory storage ---*/
1691 static void sip_destroy_user(struct sip_user *user)
1693 ast_free_ha(user->ha);
1694 if (user->chanvars) {
1695 ast_variables_destroy(user->chanvars);
1696 user->chanvars = NULL;
1698 if (ast_test_flag(user, SIP_REALTIME))
1705 /*--- realtime_user: Load user from realtime storage ---*/
1706 /* Loads user from "sipusers" category in realtime (extconfig.conf) */
1707 /* Users are matched on From: user name (the domain in skipped) */
1708 static struct sip_user *realtime_user(const char *username)
1710 struct ast_variable *var;
1711 struct ast_variable *tmp;
1712 struct sip_user *user = NULL;
1714 var = ast_load_realtime("sipusers", "name", username, NULL);
1721 if (!strcasecmp(tmp->name, "type") &&
1722 !strcasecmp(tmp->value, "peer")) {
1723 ast_variables_destroy(var);
1731 user = build_user(username, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1733 if (!user) { /* No user found */
1734 ast_variables_destroy(var);
1738 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1739 ast_set_flag((&user->flags_page2), SIP_PAGE2_RTCACHEFRIENDS);
1741 ASTOBJ_CONTAINER_LINK(&userl,user);
1743 /* Move counter from s to r... */
1746 ast_set_flag(user, SIP_REALTIME);
1748 ast_variables_destroy(var);
1752 /*--- find_user: Locate user by name ---*/
1753 /* Locates user by name (From: sip uri user name part) first
1754 from in-memory list (static configuration) then from
1755 realtime storage (defined in extconfig.conf) */
1756 static struct sip_user *find_user(const char *name, int realtime)
1758 struct sip_user *u = NULL;
1759 u = ASTOBJ_CONTAINER_FIND(&userl,name);
1760 if (!u && realtime) {
1761 u = realtime_user(name);
1766 /*--- create_addr_from_peer: create address structure from peer reference ---*/
1767 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
1771 if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
1772 (!peer->maxms || ((peer->lastms >= 0) && (peer->lastms <= peer->maxms)))) {
1773 if (peer->addr.sin_addr.s_addr) {
1774 r->sa.sin_family = peer->addr.sin_family;
1775 r->sa.sin_addr = peer->addr.sin_addr;
1776 r->sa.sin_port = peer->addr.sin_port;
1778 r->sa.sin_family = peer->defaddr.sin_family;
1779 r->sa.sin_addr = peer->defaddr.sin_addr;
1780 r->sa.sin_port = peer->defaddr.sin_port;
1782 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1787 ast_copy_flags(r, peer,
1788 SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE |
1789 SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
1790 r->capability = peer->capability;
1792 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1793 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1796 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1797 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1799 ast_copy_string(r->peername, peer->username, sizeof(r->peername));
1800 ast_copy_string(r->authname, peer->username, sizeof(r->authname));
1801 ast_copy_string(r->username, peer->username, sizeof(r->username));
1802 ast_copy_string(r->peersecret, peer->secret, sizeof(r->peersecret));
1803 ast_copy_string(r->peermd5secret, peer->md5secret, sizeof(r->peermd5secret));
1804 ast_copy_string(r->tohost, peer->tohost, sizeof(r->tohost));
1805 ast_copy_string(r->fullcontact, peer->fullcontact, sizeof(r->fullcontact));
1806 if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
1807 if ((callhost = strchr(r->callid, '@'))) {
1808 strncpy(callhost + 1, peer->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1811 if (ast_strlen_zero(r->tohost)) {
1812 if (peer->addr.sin_addr.s_addr)
1813 ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->addr.sin_addr);
1815 ast_inet_ntoa(r->tohost, sizeof(r->tohost), peer->defaddr.sin_addr);
1817 if (!ast_strlen_zero(peer->fromdomain))
1818 ast_copy_string(r->fromdomain, peer->fromdomain, sizeof(r->fromdomain));
1819 if (!ast_strlen_zero(peer->fromuser))
1820 ast_copy_string(r->fromuser, peer->fromuser, sizeof(r->fromuser));
1821 r->maxtime = peer->maxms;
1822 r->callgroup = peer->callgroup;
1823 r->pickupgroup = peer->pickupgroup;
1824 /* Set timer T1 to RTT for this peer (if known by qualify=) */
1825 if (peer->maxms && peer->lastms)
1826 r->timer_t1 = peer->lastms;
1827 if ((ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_AUTO))
1828 r->noncodeccapability |= AST_RTP_DTMF;
1830 r->noncodeccapability &= ~AST_RTP_DTMF;
1831 ast_copy_string(r->context, peer->context,sizeof(r->context));
1832 r->rtptimeout = peer->rtptimeout;
1833 r->rtpholdtimeout = peer->rtpholdtimeout;
1834 r->rtpkeepalive = peer->rtpkeepalive;
1835 if (peer->call_limit)
1836 ast_set_flag(r, SIP_CALL_LIMIT);
1841 /*--- create_addr: create address structure from peer name ---*/
1842 /* Or, if peer not found, find it in the global DNS */
1843 /* returns TRUE (-1) on failure, FALSE on success */
1844 static int create_addr(struct sip_pvt *dialog, char *opeer)
1847 struct ast_hostent ahp;
1852 char host[MAXHOSTNAMELEN], *hostn;
1855 ast_copy_string(peer, opeer, sizeof(peer));
1856 port = strchr(peer, ':');
1861 dialog->sa.sin_family = AF_INET;
1862 dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
1863 p = find_peer(peer, NULL, 1);
1867 if (create_addr_from_peer(dialog, p))
1868 ASTOBJ_UNREF(p, sip_destroy_peer);
1876 portno = atoi(port);
1878 portno = DEFAULT_SIP_PORT;
1880 char service[MAXHOSTNAMELEN];
1883 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1884 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1890 hp = ast_gethostbyname(hostn, &ahp);
1892 ast_copy_string(dialog->tohost, peer, sizeof(dialog->tohost));
1893 memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
1894 dialog->sa.sin_port = htons(portno);
1895 memcpy(&dialog->recv, &dialog->sa, sizeof(dialog->recv));
1898 ast_log(LOG_WARNING, "No such host: %s\n", peer);
1902 ASTOBJ_UNREF(p, sip_destroy_peer);
1907 /*--- auto_congest: Scheduled congestion on a call ---*/
1908 static int auto_congest(void *nothing)
1910 struct sip_pvt *p = nothing;
1911 ast_mutex_lock(&p->lock);
1914 if (!ast_mutex_trylock(&p->owner->lock)) {
1915 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1916 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1917 ast_mutex_unlock(&p->owner->lock);
1920 ast_mutex_unlock(&p->lock);
1927 /*--- sip_call: Initiate SIP call from PBX ---*/
1928 /* used from the dial() application */
1929 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1934 char *osphandle = NULL;
1936 struct varshead *headp;
1937 struct ast_var_t *current;
1942 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1943 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1948 /* Check whether there is vxml_url, distinctive ring variables */
1950 headp=&ast->varshead;
1951 AST_LIST_TRAVERSE(headp,current,entries) {
1952 /* Check whether there is a VXML_URL variable */
1953 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
1954 p->options->vxml_url = ast_var_value(current);
1955 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
1956 p->options->uri_options = ast_var_value(current);
1957 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
1958 /* Check whether there is a ALERT_INFO variable */
1959 p->options->distinctive_ring = ast_var_value(current);
1960 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
1961 /* Check whether there is a variable with a name starting with SIPADDHEADER */
1962 p->options->addsipheaders = 1;
1967 else if (!p->options->osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1968 p->options->osptoken = ast_var_value(current);
1969 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1970 osphandle = ast_var_value(current);
1976 ast_set_flag(p, SIP_OUTGOING);
1978 if (!p->options->osptoken || !osphandle || (sscanf(osphandle, "%d", &p->osphandle) != 1)) {
1979 /* Force Disable OSP support */
1980 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", p->options->osptoken, osphandle);
1981 p->options->osptoken = NULL;
1986 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1987 res = update_call_counter(p, INC_CALL_LIMIT);
1989 p->callingpres = ast->cid.cid_pres;
1990 p->jointcapability = p->capability;
1991 transmit_invite(p, SIP_INVITE, 1, 2);
1993 /* Initialize auto-congest time */
1994 p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2000 /*--- sip_registry_destroy: Destroy registry object ---*/
2001 /* Objects created with the register= statement in static configuration */
2002 static void sip_registry_destroy(struct sip_registry *reg)
2006 /* Clear registry before destroying to ensure
2007 we don't get reentered trying to grab the registry lock */
2008 reg->call->registry = NULL;
2009 sip_destroy(reg->call);
2011 if (reg->expire > -1)
2012 ast_sched_del(sched, reg->expire);
2013 if (reg->timeout > -1)
2014 ast_sched_del(sched, reg->timeout);
2020 /*--- __sip_destroy: Execute destrucion of call structure, release memory---*/
2021 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2023 struct sip_pvt *cur, *prev = NULL;
2025 struct sip_history *hist;
2027 if (sip_debug_test_pvt(p))
2028 ast_verbose("Destroying call '%s'\n", p->callid);
2031 sip_dump_history(p);
2036 if (p->stateid > -1)
2037 ast_extension_state_del(p->stateid, NULL);
2039 ast_sched_del(sched, p->initid);
2040 if (p->autokillid > -1)
2041 ast_sched_del(sched, p->autokillid);
2044 ast_rtp_destroy(p->rtp);
2047 ast_rtp_destroy(p->vrtp);
2050 free_old_route(p->route);
2054 if (p->registry->call == p)
2055 p->registry->call = NULL;
2056 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
2058 /* Unlink us from the owner if we have one */
2061 ast_mutex_lock(&p->owner->lock);
2062 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2063 p->owner->tech_pvt = NULL;
2065 ast_mutex_unlock(&p->owner->lock);
2070 p->history = p->history->next;
2078 prev->next = cur->next;
2087 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2091 ast_sched_del(sched, p->initid);
2093 while((cp = p->packets)) {
2094 p->packets = p->packets->next;
2095 if (cp->retransid > -1) {
2096 ast_sched_del(sched, cp->retransid);
2101 ast_variables_destroy(p->chanvars);
2104 ast_mutex_destroy(&p->lock);
2108 /*--- update_call_counter: Handle call_limit for SIP users ---*/
2109 /* Note: This is going to be replaced by app_groupcount */
2110 /* Thought: For realtime, we should propably update storage with inuse counter... */
2111 static int update_call_counter(struct sip_pvt *fup, int event)
2114 int *inuse, *call_limit;
2115 int outgoing = ast_test_flag(fup, SIP_OUTGOING);
2116 struct sip_user *u = NULL;
2117 struct sip_peer *p = NULL;
2119 if (option_debug > 2)
2120 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2121 /* Test if we need to check call limits, in order to avoid
2122 realtime lookups if we do not need it */
2123 if (!ast_test_flag(fup, SIP_CALL_LIMIT))
2126 ast_copy_string(name, fup->username, sizeof(name));
2128 /* Check the list of users */
2129 u = find_user(name, 1);
2132 call_limit = &u->call_limit;
2135 /* Try to find peer */
2137 p = find_peer(fup->peername, NULL, 1);
2140 call_limit = &p->call_limit;
2141 ast_copy_string(name, fup->peername, sizeof(name));
2143 if (option_debug > 1)
2144 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2149 /* incoming and outgoing affects the inUse counter */
2150 case DEC_CALL_LIMIT:
2156 if (option_debug > 1 || sipdebug) {
2157 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2160 case INC_CALL_LIMIT:
2161 if (*call_limit > 0 ) {
2162 if (*inuse >= *call_limit) {
2163 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);
2164 /* inc inUse as well */
2165 if ( event == INC_CALL_LIMIT ) {
2169 ASTOBJ_UNREF(u,sip_destroy_user);
2171 ASTOBJ_UNREF(p,sip_destroy_peer);
2176 if (option_debug > 1 || sipdebug) {
2177 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2181 ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2184 ASTOBJ_UNREF(u,sip_destroy_user);
2186 ASTOBJ_UNREF(p,sip_destroy_peer);
2190 /*--- sip_destroy: Destroy SIP call structure ---*/
2191 static void sip_destroy(struct sip_pvt *p)
2193 ast_mutex_lock(&iflock);
2194 __sip_destroy(p, 1);
2195 ast_mutex_unlock(&iflock);
2199 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
2201 /*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
2202 static int hangup_sip2cause(int cause)
2204 /* Possible values taken from causes.h */
2207 case 403: /* Not found */
2208 return AST_CAUSE_CALL_REJECTED;
2209 case 404: /* Not found */
2210 return AST_CAUSE_UNALLOCATED;
2211 case 408: /* No reaction */
2212 return AST_CAUSE_NO_USER_RESPONSE;
2213 case 480: /* No answer */
2214 return AST_CAUSE_FAILURE;
2215 case 483: /* Too many hops */
2216 return AST_CAUSE_NO_ANSWER;
2217 case 486: /* Busy everywhere */
2218 return AST_CAUSE_BUSY;
2219 case 488: /* No codecs approved */
2220 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2221 case 500: /* Server internal failure */
2222 return AST_CAUSE_FAILURE;
2223 case 501: /* Call rejected */
2224 return AST_CAUSE_FACILITY_REJECTED;
2226 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2227 case 503: /* Service unavailable */
2228 return AST_CAUSE_CONGESTION;
2230 return AST_CAUSE_NORMAL;
2237 /*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
2238 /* Possible values from causes.h
2239 AST_CAUSE_NOTDEFINED AST_CAUSE_NORMAL AST_CAUSE_BUSY
2240 AST_CAUSE_FAILURE AST_CAUSE_CONGESTION AST_CAUSE_UNALLOCATED
2242 In addition to these, a lot of PRI codes is defined in causes.h
2243 ...should we take care of them too ?
2247 ISUP Cause value SIP response
2248 ---------------- ------------
2249 1 unallocated number 404 Not Found
2250 2 no route to network 404 Not found
2251 3 no route to destination 404 Not found
2252 16 normal call clearing --- (*)
2253 17 user busy 486 Busy here
2254 18 no user responding 408 Request Timeout
2255 19 no answer from the user 480 Temporarily unavailable
2256 20 subscriber absent 480 Temporarily unavailable
2257 21 call rejected 403 Forbidden (+)
2258 22 number changed (w/o diagnostic) 410 Gone
2259 22 number changed (w/ diagnostic) 301 Moved Permanently
2260 23 redirection to new destination 410 Gone
2261 26 non-selected user clearing 404 Not Found (=)
2262 27 destination out of order 502 Bad Gateway
2263 28 address incomplete 484 Address incomplete
2264 29 facility rejected 501 Not implemented
2265 31 normal unspecified 480 Temporarily unavailable
2267 static char *hangup_cause2sip(int cause)
2271 case AST_CAUSE_UNALLOCATED: /* 1 */
2272 case AST_CAUSE_NO_ROUTE_DESTINATION: /* 3 IAX2: Can't find extension in context */
2273 case AST_CAUSE_NO_ROUTE_TRANSIT_NET: /* 2 */
2274 return "404 Not Found";
2275 case AST_CAUSE_CONGESTION: /* 34 */
2276 case AST_CAUSE_SWITCH_CONGESTION: /* 42 */
2277 return "503 Service Unavailable";
2278 case AST_CAUSE_NO_USER_RESPONSE: /* 18 */
2279 return "408 Request Timeout";
2280 case AST_CAUSE_NO_ANSWER: /* 19 */
2281 return "480 Temporarily unavailable";
2282 case AST_CAUSE_CALL_REJECTED: /* 21 */
2283 return "403 Forbidden";
2284 case AST_CAUSE_NUMBER_CHANGED: /* 22 */
2286 case AST_CAUSE_NORMAL_UNSPECIFIED: /* 31 */
2287 return "480 Temporarily unavailable";
2288 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2289 return "484 Address incomplete";
2290 case AST_CAUSE_USER_BUSY:
2291 return "486 Busy here";
2292 case AST_CAUSE_FAILURE:
2293 return "500 Server internal failure";
2294 case AST_CAUSE_FACILITY_REJECTED: /* 29 */
2295 return "501 Not Implemented";
2296 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2297 return "503 Service Unavailable";
2298 /* Used in chan_iax2 */
2299 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2300 return "502 Bad Gateway";
2301 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL: /* Can't find codec to connect to host */
2302 return "488 Not Acceptable Here";
2304 case AST_CAUSE_NOTDEFINED:
2306 ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2315 /*--- sip_hangup: Hangup SIP call ---*/
2316 /* Part of PBX interface */
2317 static int sip_hangup(struct ast_channel *ast)
2319 struct sip_pvt *p = ast->tech_pvt;
2321 struct ast_flags locflags = {0};
2324 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
2328 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2330 ast_mutex_lock(&p->lock);
2332 if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
2333 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
2336 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter\n", p->username);
2337 update_call_counter(p, DEC_CALL_LIMIT);
2338 /* Determine how to disconnect */
2339 if (p->owner != ast) {
2340 ast_log(LOG_WARNING, "Huh? We aren't the owner? Can't hangup call.\n");
2341 ast_mutex_unlock(&p->lock);
2344 /* If the call is not UP, we need to send CANCEL instead of BYE */
2345 if (ast->_state != AST_STATE_UP)
2351 ast_dsp_free(p->vad);
2354 ast->tech_pvt = NULL;
2356 ast_mutex_lock(&usecnt_lock);
2358 ast_mutex_unlock(&usecnt_lock);
2359 ast_update_use_count();
2361 ast_set_flag(&locflags, SIP_NEEDDESTROY);
2363 /* Start the process if it's not already started */
2364 if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2365 if (needcancel) { /* Outgoing call, not up */
2366 if (ast_test_flag(p, SIP_OUTGOING)) {
2367 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, 1, 0);
2368 /* Actually don't destroy us yet, wait for the 487 on our original
2369 INVITE, but do set an autodestruct just in case we never get it. */
2370 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2371 sip_scheddestroy(p, 15000);
2372 /* stop retransmitting an INVITE that has not received a response */
2373 __sip_pretend_ack(p);
2374 if ( p->initid != -1 ) {
2375 /* channel still up - reverse dec of inUse counter
2376 only if the channel is not auto-congested */
2377 update_call_counter(p, INC_CALL_LIMIT);
2379 } else { /* Incoming call, not up */
2381 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
2382 transmit_response_reliable(p, res, &p->initreq, 1);
2384 transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
2386 } else { /* Call is in UP state, send BYE */
2387 if (!p->pendinginvite) {
2389 transmit_request_with_auth(p, SIP_BYE, 0, 1, 1);
2391 /* Note we will need a BYE when this all settles out
2392 but we can't send one while we have "INVITE" outstanding. */
2393 ast_set_flag(p, SIP_PENDINGBYE);
2394 ast_clear_flag(p, SIP_NEEDREINVITE);
2398 ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);
2399 ast_mutex_unlock(&p->lock);
2403 /*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
2404 /* Part of PBX interface */
2405 static int sip_answer(struct ast_channel *ast)
2409 struct sip_pvt *p = ast->tech_pvt;
2411 ast_mutex_lock(&p->lock);
2412 if (ast->_state != AST_STATE_UP) {
2417 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
2419 fmt=ast_getformatbyname(codec);
2421 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
2422 if (p->jointcapability & fmt) {
2423 p->jointcapability &= fmt;
2424 p->capability &= fmt;
2426 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2427 } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
2430 ast_setstate(ast, AST_STATE_UP);
2432 ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
2433 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
2435 ast_mutex_unlock(&p->lock);
2439 /*--- sip_write: Send frame to media channel (rtp) ---*/
2440 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2442 struct sip_pvt *p = ast->tech_pvt;
2444 switch (frame->frametype) {
2445 case AST_FRAME_VOICE:
2446 if (!(frame->subclass & ast->nativeformats)) {
2447 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2448 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2452 ast_mutex_lock(&p->lock);
2454 /* If channel is not up, activate early media session */
2455 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2456 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2457 ast_set_flag(p, SIP_PROGRESS_SENT);
2459 time(&p->lastrtptx);
2460 res = ast_rtp_write(p->rtp, frame);
2462 ast_mutex_unlock(&p->lock);
2465 case AST_FRAME_VIDEO:
2467 ast_mutex_lock(&p->lock);
2469 /* Activate video early media */
2470 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2471 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2472 ast_set_flag(p, SIP_PROGRESS_SENT);
2474 time(&p->lastrtptx);
2475 res = ast_rtp_write(p->vrtp, frame);
2477 ast_mutex_unlock(&p->lock);
2480 case AST_FRAME_IMAGE:
2484 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2491 /*--- sip_fixup: Fix up a channel: If a channel is consumed, this is called.
2492 Basically update any ->owner links ----*/
2493 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2495 struct sip_pvt *p = newchan->tech_pvt;
2496 ast_mutex_lock(&p->lock);
2497 if (p->owner != oldchan) {
2498 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2499 ast_mutex_unlock(&p->lock);
2503 ast_mutex_unlock(&p->lock);
2507 /*--- sip_senddigit: Send DTMF character on SIP channel */
2508 /* within one call, we're able to transmit in many methods simultaneously */
2509 static int sip_senddigit(struct ast_channel *ast, char digit)
2511 struct sip_pvt *p = ast->tech_pvt;
2513 ast_mutex_lock(&p->lock);
2514 switch (ast_test_flag(p, SIP_DTMF)) {
2516 transmit_info_with_digit(p, digit);
2518 case SIP_DTMF_RFC2833:
2520 ast_rtp_senddigit(p->rtp, digit);
2522 case SIP_DTMF_INBAND:
2526 ast_mutex_unlock(&p->lock);
2530 #define DEFAULT_MAX_FORWARDS 70
2533 /*--- sip_transfer: Transfer SIP call */
2534 static int sip_transfer(struct ast_channel *ast, const char *dest)
2536 struct sip_pvt *p = ast->tech_pvt;
2539 ast_mutex_lock(&p->lock);
2540 if (ast->_state == AST_STATE_RING)
2541 res = sip_sipredirect(p, dest);
2543 res = transmit_refer(p, dest);
2544 ast_mutex_unlock(&p->lock);
2548 /*--- sip_indicate: Play indication to user */
2549 /* With SIP a lot of indications is sent as messages, letting the device play
2550 the indication - busy signal, congestion etc */
2551 static int sip_indicate(struct ast_channel *ast, int condition)
2553 struct sip_pvt *p = ast->tech_pvt;
2556 ast_mutex_lock(&p->lock);
2558 case AST_CONTROL_RINGING:
2559 if (ast->_state == AST_STATE_RING) {
2560 if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2561 (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2562 /* Send 180 ringing if out-of-band seems reasonable */
2563 transmit_response(p, "180 Ringing", &p->initreq);
2564 ast_set_flag(p, SIP_RINGING);
2565 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2568 /* Well, if it's not reasonable, just send in-band */
2573 case AST_CONTROL_BUSY:
2574 if (ast->_state != AST_STATE_UP) {
2575 transmit_response(p, "486 Busy Here", &p->initreq);
2576 ast_set_flag(p, SIP_ALREADYGONE);
2577 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2582 case AST_CONTROL_CONGESTION:
2583 if (ast->_state != AST_STATE_UP) {
2584 transmit_response(p, "503 Service Unavailable", &p->initreq);
2585 ast_set_flag(p, SIP_ALREADYGONE);
2586 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2591 case AST_CONTROL_PROGRESS:
2592 case AST_CONTROL_PROCEEDING:
2593 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2594 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2595 ast_set_flag(p, SIP_PROGRESS_SENT);
2600 case AST_CONTROL_HOLD: /* The other part of the bridge are put on hold */
2602 ast_log(LOG_DEBUG, "Bridged channel now on hold%s\n", p->callid);
2605 case AST_CONTROL_UNHOLD: /* The other part of the bridge are back from hold */
2607 ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2610 case AST_CONTROL_VIDUPDATE: /* Request a video frame update */
2611 if (p->vrtp && !ast_test_flag(p, SIP_NOVIDEO)) {
2612 transmit_info_with_vidupdate(p);
2621 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2625 ast_mutex_unlock(&p->lock);
2631 /*--- sip_new: Initiate a call in the SIP channel */
2632 /* called from sip_request_call (calls from the pbx ) */
2633 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2635 struct ast_channel *tmp;
2636 struct ast_variable *v = NULL;
2639 ast_mutex_unlock(&i->lock);
2640 /* Don't hold a sip pvt lock while we allocate a channel */
2641 tmp = ast_channel_alloc(1);
2642 ast_mutex_lock(&i->lock);
2644 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2647 tmp->tech = &sip_tech;
2648 /* Select our native format based on codec preference until we receive
2649 something from another device to the contrary. */
2650 ast_mutex_lock(&i->lock);
2651 if (i->jointcapability)
2652 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2653 else if (i->capability)
2654 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2656 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2657 ast_mutex_unlock(&i->lock);
2658 fmt = ast_best_codec(tmp->nativeformats);
2661 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2662 else if (strchr(i->fromdomain,':'))
2663 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2665 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2667 tmp->type = channeltype;
2668 if (ast_test_flag(i, SIP_DTMF) == SIP_DTMF_INBAND) {
2669 i->vad = ast_dsp_new();
2670 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2672 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2675 tmp->fds[0] = ast_rtp_fd(i->rtp);
2676 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2679 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2680 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2682 if (state == AST_STATE_RING)
2684 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2685 tmp->writeformat = fmt;
2686 tmp->rawwriteformat = fmt;
2687 tmp->readformat = fmt;
2688 tmp->rawreadformat = fmt;
2691 tmp->callgroup = i->callgroup;
2692 tmp->pickupgroup = i->pickupgroup;
2693 tmp->cid.cid_pres = i->callingpres;
2694 if (!ast_strlen_zero(i->accountcode))
2695 ast_copy_string(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode));
2697 tmp->amaflags = i->amaflags;
2698 if (!ast_strlen_zero(i->language))
2699 ast_copy_string(tmp->language, i->language, sizeof(tmp->language));
2700 if (!ast_strlen_zero(i->musicclass))
2701 ast_copy_string(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass));
2703 ast_mutex_lock(&usecnt_lock);
2705 ast_mutex_unlock(&usecnt_lock);
2706 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
2707 ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
2708 if (!ast_strlen_zero(i->cid_num))
2709 tmp->cid.cid_num = strdup(i->cid_num);
2710 if (!ast_strlen_zero(i->cid_name))
2711 tmp->cid.cid_name = strdup(i->cid_name);
2712 if (!ast_strlen_zero(i->rdnis))
2713 tmp->cid.cid_rdnis = strdup(i->rdnis);
2714 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2715 tmp->cid.cid_dnid = strdup(i->exten);
2717 if (!ast_strlen_zero(i->uri)) {
2718 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2720 if (!ast_strlen_zero(i->domain)) {
2721 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2723 if (!ast_strlen_zero(i->useragent)) {
2724 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2726 if (!ast_strlen_zero(i->callid)) {
2727 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2729 ast_setstate(tmp, state);
2730 if (state != AST_STATE_DOWN) {
2731 if (ast_pbx_start(tmp)) {
2732 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2737 /* Set channel variables for this call from configuration */
2738 for (v = i->chanvars ; v ; v = v->next)
2739 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2744 /*--- get_sdp_by_line: Reads one line of SIP message body */
2745 static char* get_sdp_by_line(char* line, char *name, int nameLen)
2747 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2748 return ast_skip_blanks(line + nameLen + 1);
2753 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2754 but the name wrongly applies _only_ sdp */
2755 static char *get_sdp(struct sip_request *req, char *name)
2758 int len = strlen(name);
2761 for (x=0; x<req->lines; x++) {
2762 r = get_sdp_by_line(req->line[x], name, len);
2770 static void sdpLineNum_iterator_init(int* iterator)
2775 static char* get_sdp_iterate(int* iterator,
2776 struct sip_request *req, char *name)
2778 int len = strlen(name);
2781 while (*iterator < req->lines) {
2782 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2789 static char *find_alias(const char *name, char *_default)
2792 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2793 if (!strcasecmp(aliases[x].fullname, name))
2794 return aliases[x].shortname;
2798 static char *__get_header(struct sip_request *req, char *name, int *start)
2803 * Technically you can place arbitrary whitespace both before and after the ':' in
2804 * a header, although RFC3261 clearly says you shouldn't before, and place just
2805 * one afterwards. If you shouldn't do it, what absolute idiot decided it was
2806 * a good idea to say you can do it, and if you can do it, why in the hell would.
2807 * you say you shouldn't.
2808 * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
2809 * and we always allow spaces after that for compatibility.
2811 for (pass = 0; name && pass < 2;pass++) {
2812 int x, len = strlen(name);
2813 for (x=*start; x<req->headers; x++) {
2814 if (!strncasecmp(req->header[x], name, len)) {
2815 char *r = req->header[x] + len; /* skip name */
2816 if (pedanticsipchecking)
2817 r = ast_skip_blanks(r);
2821 return ast_skip_blanks(r+1);
2825 if (pass == 0) /* Try aliases */
2826 name = find_alias(name, NULL);
2829 /* Don't return NULL, so get_header is always a valid pointer */
2833 /*--- get_header: Get header from SIP request ---*/
2834 static char *get_header(struct sip_request *req, char *name)
2837 return __get_header(req, name, &start);
2840 /*--- sip_rtp_read: Read RTP from network ---*/
2841 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2843 /* Retrieve audio/etc from channel. Assumes p->lock is already held. */
2844 struct ast_frame *f;
2845 static struct ast_frame null_frame = { AST_FRAME_NULL, };
2848 /* We have no RTP allocated for this channel */
2854 f = ast_rtp_read(p->rtp); /* RTP Audio */
2857 f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
2860 f = ast_rtp_read(p->vrtp); /* RTP Video */
2863 f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */
2868 /* Don't forward RFC2833 if we're not supposed to */
2869 if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2872 /* We already hold the channel lock */
2873 if (f->frametype == AST_FRAME_VOICE) {
2874 if (f->subclass != p->owner->nativeformats) {
2875 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2876 p->owner->nativeformats = f->subclass;
2877 ast_set_read_format(p->owner, p->owner->readformat);
2878 ast_set_write_format(p->owner, p->owner->writeformat);
2880 if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2881 f = ast_dsp_process(p->owner, p->vad, f);
2882 if (f && (f->frametype == AST_FRAME_DTMF))
2883 ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
2890 /*--- sip_read: Read SIP RTP from channel */
2891 static struct ast_frame *sip_read(struct ast_channel *ast)
2893 struct ast_frame *fr;
2894 struct sip_pvt *p = ast->tech_pvt;
2895 ast_mutex_lock(&p->lock);
2896 fr = sip_rtp_read(ast, p);
2897 time(&p->lastrtprx);
2898 ast_mutex_unlock(&p->lock);
2902 /*--- build_callid: Build SIP CALLID header ---*/
2903 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2908 char iabuf[INET_ADDRSTRLEN];
2909 for (x=0; x<4; x++) {
2911 res = snprintf(callid, len, "%08x", val);
2915 if (!ast_strlen_zero(fromdomain))
2916 snprintf(callid, len, "@%s", fromdomain);
2918 /* It's not important that we really use our right IP here... */
2919 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2922 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2923 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
2927 p = malloc(sizeof(struct sip_pvt));
2930 /* Keep track of stuff */
2931 memset(p, 0, sizeof(struct sip_pvt));
2932 ast_mutex_init(&p->lock);
2934 p->method = intended_method;
2937 p->subscribed = NONE;
2940 if (intended_method != SIP_OPTIONS) /* Peerpoke has it's own system */
2941 p->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
2946 memcpy(&p->sa, sin, sizeof(p->sa));
2947 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2948 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2950 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2955 /* Start with 101 instead of 1 */
2958 if (sip_methods[intended_method].need_rtp) {
2959 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2961 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2962 if (!p->rtp || (videosupport && !p->vrtp)) {
2963 ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n", videosupport ? "and video" : "", strerror(errno));
2964 ast_mutex_destroy(&p->lock);
2966 ast_variables_destroy(p->chanvars);
2972 ast_rtp_settos(p->rtp, tos);
2974 ast_rtp_settos(p->vrtp, tos);
2975 p->rtptimeout = global_rtptimeout;
2976 p->rtpholdtimeout = global_rtpholdtimeout;
2977 p->rtpkeepalive = global_rtpkeepalive;
2980 if (useglobal_nat && sin) {
2981 /* Setup NAT structure according to global settings if we have an address */
2982 ast_copy_flags(p, &global_flags, SIP_NAT);
2983 memcpy(&p->recv, sin, sizeof(p->recv));
2985 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2987 ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2990 if (p->method != SIP_REGISTER)
2991 ast_copy_string(p->fromdomain, default_fromdomain, sizeof(p->fromdomain));
2992 build_via(p, p->via, sizeof(p->via));
2994 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2996 ast_copy_string(p->callid, callid, sizeof(p->callid));
2997 ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2998 /* Assign default music on hold class */
2999 strcpy(p->musicclass, global_musicclass);
3000 p->capability = global_capability;
3001 if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_AUTO))
3002 p->noncodeccapability |= AST_RTP_DTMF;
3003 strcpy(p->context, default_context);
3005 /* Add to active dialog list */
3006 ast_mutex_lock(&iflock);
3009 ast_mutex_unlock(&iflock);
3011 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");
3015 /*--- find_call: Connect incoming SIP message to current dialog or create new dialog structure */
3016 /* Called by handle_request ,sipsock_read */
3017 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
3024 callid = get_header(req, "Call-ID");
3026 if (pedanticsipchecking) {
3027 /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
3028 we need more to identify a branch - so we have to check branch, from
3029 and to tags to identify a call leg.
3030 For Asterisk to behave correctly, you need to turn on pedanticsipchecking
3033 if (req->method == SIP_RESPONSE)
3034 ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
3036 ast_copy_string(tmp, get_header(req, "From"), sizeof(tmp));
3037 tag = strcasestr(tmp, "tag=");
3040 c = strchr(tag, ';');
3047 ast_mutex_lock(&iflock);
3051 if (req->method == SIP_REGISTER)
3052 found = (!strcmp(p->callid, callid));
3054 found = (!strcmp(p->callid, callid) &&
3055 (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) ;
3057 /* Found the call */
3058 ast_mutex_lock(&p->lock);
3059 ast_mutex_unlock(&iflock);
3064 ast_mutex_unlock(&iflock);
3065 p = sip_alloc(callid, sin, 1, intended_method);
3067 ast_mutex_lock(&p->lock);
3071 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
3072 static int sip_register(char *value, int lineno)
3074 struct sip_registry *reg;
3076 char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
3083 ast_copy_string(copy, value, sizeof(copy));
3086 hostname = strrchr(stringp, '@');
3091 if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
3092 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d\n", lineno);
3096 username = strsep(&stringp, ":");
3098 secret = strsep(&stringp, ":");
3100 authuser = strsep(&stringp, ":");
3103 hostname = strsep(&stringp, "/");
3105 contact = strsep(&stringp, "/");
3106 if (!contact || ast_strlen_zero(contact))
3109 hostname = strsep(&stringp, ":");
3110 porta = strsep(&stringp, ":");
3112 if (porta && !atoi(porta)) {
3113 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
3116 reg = malloc(sizeof(struct sip_registry));
3118 ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry entry\n");
3121 memset(reg, 0, sizeof(struct sip_registry));
3124 ast_copy_string(reg->contact, contact, sizeof(reg->contact));
3126 ast_copy_string(reg->username, username, sizeof(reg->username));
3128 ast_copy_string(reg->hostname, hostname, sizeof(reg->hostname));
3130 ast_copy_string(reg->authuser, authuser, sizeof(reg->authuser));
3132 ast_copy_string(reg->secret, secret, sizeof(reg->secret));
3135 reg->refresh = default_expiry;
3136 reg->portno = porta ? atoi(porta) : 0;
3137 reg->callid_valid = 0;
3139 ASTOBJ_CONTAINER_LINK(®l, reg);
3140 ASTOBJ_UNREF(reg,sip_registry_destroy);
3144 /*--- lws2sws: Parse multiline SIP headers into one header */
3145 /* This is enabled if pedanticsipchecking is enabled */
3146 static int lws2sws(char *msgbuf, int len)
3152 /* Eliminate all CRs */
3153 if (msgbuf[h] == '\r') {
3157 /* Check for end-of-line */
3158 if (msgbuf[h] == '\n') {
3159 /* Check for end-of-message */
3162 /* Check for a continuation line */
3163 if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
3164 /* Merge continuation line */
3168 /* Propagate LF and start new line */
3169 msgbuf[t++] = msgbuf[h++];
3173 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
3178 msgbuf[t++] = msgbuf[h++];
3182 msgbuf[t++] = msgbuf[h++];
3190 /*--- parse_request: Parse a SIP message ----*/
3191 static void parse_request(struct sip_request *req)
3193 /* Divide fields by NULL's */
3199 /* First header starts immediately */
3203 /* We've got a new header */
3206 if (sipdebug && option_debug > 3)
3207 ast_log(LOG_DEBUG, "Header: %s (%d)\n", req->header[f], (int) strlen(req->header[f]));
3208 if (ast_strlen_zero(req->header[f])) {
3209 /* Line by itself means we're now in content */
3213 if (f >= SIP_MAX_HEADERS - 1) {
3214 ast_log(LOG_WARNING, "Too many SIP headers. Ignoring.\n");
3217 req->header[f] = c + 1;
3218 } else if (*c == '\r') {
3219 /* Ignore but eliminate \r's */
3224 /* Check for last header */
3225 if (!ast_strlen_zero(req->header[f]))
3228 /* Now we process any mime content */
3233 /* We've got a new line */
3235 if (sipdebug && option_debug > 3)
3236 ast_log(LOG_DEBUG, "Line: %s (%d)\n", req->line[f], (int) strlen(req->line[f]));
3237 if (f >= SIP_MAX_LINES - 1) {
3238 ast_log(LOG_WARNING, "Too many SDP lines. Ignoring.\n");
3241 req->line[f] = c + 1;
3242 } else if (*c == '\r') {
3243 /* Ignore and eliminate \r's */
3248 /* Check for last line */
3249 if (!ast_strlen_zero(req->line[f]))
3253 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
3254 /* Split up the first line parts */
3255 determine_firstline_parts(req);
3258 /*--- process_sdp: Process SIP SDP and activate RTP channels---*/
3259 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
3265 char iabuf[INET_ADDRSTRLEN];
3269 int peercapability, peernoncodeccapability;
3270 int vpeercapability=0, vpeernoncodeccapability=0;
3271 struct sockaddr_in sin;
3274 struct ast_hostent ahp;
3276 int destiterator = 0;
3280 int debug=sip_debug_test_pvt(p);
3281 struct ast_channel *bridgepeer = NULL;
3284 ast_log(LOG_ERROR, "Got SDP but have no RTP session allocated.\n");
3288 /* Update our last rtprx when we receive an SDP, too */
3289 time(&p->lastrtprx);
3290 time(&p->lastrtptx);
3292 /* Get codec and RTP info from SDP */
3293 if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
3294 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
3297 m = get_sdp(req, "m");
3298 sdpLineNum_iterator_init(&destiterator);
3299 c = get_sdp_iterate(&destiterator, req, "c");
3300 if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
3301 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
3304 if (sscanf(c, "IN IP4 %256s", host) != 1) {
3305 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
3308 /* XXX This could block for a long time, and block the main thread! XXX */
3309 hp = ast_gethostbyname(host, &ahp);
3311 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
3314 sdpLineNum_iterator_init(&iterator);
3315 ast_set_flag(p, SIP_NOVIDEO);
3316 while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
3318 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
3319 (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
3322 /* Scan through the RTP payload types specified in a "m=" line: */
3323 ast_rtp_pt_clear(p->rtp);
3325 while(!ast_strlen_zero(codecs)) {
3326 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
3327 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
3331 ast_verbose("Found RTP audio format %d\n", codec);
3332 ast_rtp_set_m_type(p->rtp, codec);
3333 codecs = ast_skip_blanks(codecs + len);
3337 ast_rtp_pt_clear(p->vrtp); /* Must be cleared in case no m=video line exists */
3339 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
3341 ast_clear_flag(p, SIP_NOVIDEO);
3343 /* Scan through the RTP payload types specified in a "m=" line: */
3345 while(!ast_strlen_zero(codecs)) {
3346 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
3347 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
3351 ast_verbose("Found video format %s\n", ast_getformatname(codec));
3352 ast_rtp_set_m_type(p->vrtp, codec);
3353 codecs = ast_skip_blanks(codecs + len);
3357 ast_log(LOG_WARNING, "Unknown SDP media type in offer: %s\n", m);
3359 if (portno == -1 && vportno == -1) {
3360 /* No acceptable offer found in SDP */
3363 /* Check for Media-description-level-address for audio */
3364 if (pedanticsipchecking) {
3365 c = get_sdp_iterate(&destiterator, req, "c");
3366 if (!ast_strlen_zero(c)) {
3367 if (sscanf(c, "IN IP4 %256s", host) != 1) {
3368 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
3370 /* XXX This could block for a long time, and block the main thread! XXX */
3371 hp = ast_gethostbyname(host, &ahp);
3373 ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
3378 /* RTP addresses and ports for audio and video */
3379 sin.sin_family = AF_INET;
3380 memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
3382 /* Setup audio port number */
3383 sin.sin_port = htons(portno);
3384 if (p->rtp && sin.sin_port) {
3385 ast_rtp_set_peer(p->rtp, &sin);
3387 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
3388 ast_log(LOG_DEBUG,"Peer audio RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
3391 /* Check for Media-description-level-address for video */
3392 if (pedanticsipchecking) {
3393 c = get_sdp_iterate(&destiterator, req, "c");
3394 if (!ast_strlen_zero(c)) {
3395 if (sscanf(c, "IN IP4 %256s", host) != 1) {
3396 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
3398 /* XXX This could block for a long time, and block the main thread! XXX */
3399 hp = ast_gethostbyname(host, &ahp);
3401 ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
3406 /* Setup video port number */
3407 sin.sin_port = htons(vportno);
3408 if (p->vrtp && sin.sin_port) {
3409 ast_rtp_set_peer(p->vrtp, &sin);
3411 ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
3412 ast_log(LOG_DEBUG,"Peer video RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
3416 /* Next, scan through each "a=rtpmap:" line, noting each
3417 * specified RTP payload type (with corresponding MIME subtype):
3419 sdpLineNum_iterator_init(&iterator);
3420 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
3421 char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
3422 if (!strcasecmp(a, "sendonly")) {
3426 if (!strcasecmp(a, "sendrecv")) {
3429 if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
3431 ast_verbose("Found description format %s\n", mimeSubtype);
3432 /* Note: should really look at the 'freq' and '#chans' params too */
3433 ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
3435 ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
3438 /* Now gather all of the codecs that were asked for: */
3439 ast_rtp_get_current_formats(p->rtp,
3440 &peercapability, &peernoncodeccapability);
3442 ast_rtp_get_current_formats(p->vrtp,
3443 &vpeercapability, &vpeernoncodeccapability);
3444 p->jointcapability = p->capability & (peercapability | vpeercapability);
3445 p->peercapability = (peercapability | vpeercapability);
3446 p->noncodeccapability = noncodeccapability & peernoncodeccapability;
3448 if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_AUTO) {
3449 ast_clear_flag(p, SIP_DTMF);
3450 if (p->noncodeccapability & AST_RTP_DTMF) {
3451 /* XXX Would it be reasonable to drop the DSP at this point? XXX */
3452 ast_set_flag(p, SIP_DTMF_RFC2833);
3454 ast_set_flag(p, SIP_DTMF_INBAND);
3459 /* shame on whoever coded this.... */
3460 const unsigned slen=512;
3461 char s1[slen], s2[slen], s3[slen], s4[slen];
3463 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
3464 ast_getformatname_multiple(s1, slen, p->capability),
3465 ast_getformatname_multiple(s2, slen, peercapability),
3466 ast_getformatname_multiple(s3, slen, vpeercapability),
3467 ast_getformatname_multiple(s4, slen, p->jointcapability));
3469 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
3470 ast_rtp_lookup_mime_multiple(s1, slen, noncodeccapability, 0),
3471 ast_rtp_lookup_mime_multiple(s2, slen, peernoncodeccapability, 0),
3472 ast_rtp_lookup_mime_multiple(s3, slen, p->noncodeccapability, 0));
3474 if (!p->jointcapability) {
3475 ast_log(LOG_NOTICE, "No compatible codecs!\n");
3479 if (!p->owner) /* There's no open channel owning us */
3482 if (!(p->owner->nativeformats & p->jointcapability)) {
3483 const unsigned slen=512;
projects / asterisk/asterisk.git / blob