channels/chan_sip.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   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.
  13  *
  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.
  17  */
  18
  19 /*!
  20  * \file
  21  * \brief Implementation of Session Initiation Protocol
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  *
  25  * See Also:
  26  * \arg \ref AstCREDITS
  27  *
  28  * Implementation of RFC 3261 - without S/MIME, TCP and TLS support
  29  * Configuration file \link Config_sip sip.conf \endlink
  30  *
  31  *
  32  * \todo SIP over TCP
  33  * \todo SIP over TLS
  34  * \todo Better support of forking
  35  *
  36  * \ingroup channel_drivers
  37  *
  38  */
  39
  40
  41 #include <stdio.h>
  42 #include <ctype.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <sys/socket.h>
  46 #include <sys/ioctl.h>
  47 #include <net/if.h>
  48 #include <errno.h>
  49 #include <stdlib.h>
  50 #include <fcntl.h>
  51 #include <netdb.h>
  52 #include <signal.h>
  53 #include <sys/signal.h>
  54 #include <netinet/in.h>
  55 #include <netinet/in_systm.h>
  56 #include <arpa/inet.h>
  57 #include <netinet/ip.h>
  58 #include <regex.h>
  59
  60 #include "asterisk.h"
  61
  62 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  63
  64 #include "asterisk/lock.h"
  65 #include "asterisk/channel.h"
  66 #include "asterisk/config.h"
  67 #include "asterisk/logger.h"
  68 #include "asterisk/module.h"
  69 #include "asterisk/pbx.h"
  70 #include "asterisk/options.h"
  71 #include "asterisk/lock.h"
  72 #include "asterisk/sched.h"
  73 #include "asterisk/io.h"
  74 #include "asterisk/rtp.h"
  75 #include "asterisk/acl.h"
  76 #include "asterisk/manager.h"
  77 #include "asterisk/callerid.h"
  78 #include "asterisk/cli.h"
  79 #include "asterisk/app.h"
  80 #include "asterisk/musiconhold.h"
  81 #include "asterisk/dsp.h"
  82 #include "asterisk/features.h"
  83 #include "asterisk/acl.h"
  84 #include "asterisk/srv.h"
  85 #include "asterisk/astdb.h"
  86 #include "asterisk/causes.h"
  87 #include "asterisk/utils.h"
  88 #include "asterisk/file.h"
  89 #include "asterisk/astobj.h"
  90 #include "asterisk/dnsmgr.h"
  91 #include "asterisk/devicestate.h"
  92 #include "asterisk/linkedlists.h"
  93 #include "asterisk/stringfields.h"
  94
  95 #ifdef OSP_SUPPORT
  96 #include "asterisk/astosp.h"
  97 #endif
  98
  99 #ifndef FALSE
 100 #define FALSE   0
 101 #endif
 102
 103 #ifndef TRUE
 104 #define TRUE 1
 105 #endif
 106
 107
 108 #define VIDEO_CODEC_MASK        0x1fc0000 /*!< Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
 109 #ifndef IPTOS_MINCOST
 110 #define IPTOS_MINCOST           0x02
 111 #endif
 112
 113 /* #define VOCAL_DATA_HACK */
 114
 115 #define DEFAULT_DEFAULT_EXPIRY  120
 116 #define DEFAULT_MIN_EXPIRY      60
 117 #define DEFAULT_MAX_EXPIRY      3600
 118 #define DEFAULT_REGISTRATION_TIMEOUT    20
 119 #define DEFAULT_MAX_FORWARDS    "70"
 120
 121 /* guard limit must be larger than guard secs */
 122 /* guard min must be < 1000, and should be >= 250 */
 123 #define EXPIRY_GUARD_SECS       15              /*!< How long before expiry do we reregister */
 124 #define EXPIRY_GUARD_LIMIT      30              /*!< Below here, we use EXPIRY_GUARD_PCT instead of
 125                                                   EXPIRY_GUARD_SECS */
 126 #define EXPIRY_GUARD_MIN        500             /*!< This is the minimum guard time applied. If
 127                                                   GUARD_PCT turns out to be lower than this, it
 128                                                    will use this time instead.
 129                                                    This is in milliseconds. */
 130 #define EXPIRY_GUARD_PCT        0.20            /*!< Percentage of expires timeout to use when
 131                                                    below EXPIRY_GUARD_LIMIT */
 132 #define DEFAULT_EXPIRY 900                      /*!< Expire slowly */
 133
 134 static int min_expiry = DEFAULT_MIN_EXPIRY;     /*!< Minimum accepted registration time */
 135 static int max_expiry = DEFAULT_MAX_EXPIRY;     /*!< Maximum accepted registration time */
 136 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
 137 static int expiry = DEFAULT_EXPIRY;
 138
 139 #ifndef MAX
 140 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 141 #endif
 142
 143 #define CALLERID_UNKNOWN        "Unknown"
 144
 145 #define DEFAULT_MAXMS           2000            /*!< Qualification: Must be faster than 2 seconds by default */
 146 #define DEFAULT_FREQ_OK         60 * 1000       /*!< Qualification: How often to check for the host to be up */
 147 #define DEFAULT_FREQ_NOTOK      10 * 1000       /*!< Qualification: How often to check, if the host is down... */
 148
 149 #define DEFAULT_RETRANS         1000            /*!< How frequently to retransmit Default: 2 * 500 ms in RFC 3261 */
 150 #define MAX_RETRANS             6               /*!< Try only 6 times for retransmissions, a total of 7 transmissions */
 151 #define MAX_AUTHTRIES           3               /*!< Try authentication three times, then fail */
 152
 153 #define SIP_MAX_HEADERS         64                      /*!< Max amount of SIP headers to read */
 154 #define SIP_MAX_LINES           64                      /*!< Max amount of lines in SIP attachment (like SDP) */
 155 #define SIP_MAX_PACKET          4096    /*!< Also from RFC 3261 (2543), should sub headers tho */
 156
 157
 158 static const char desc[] = "Session Initiation Protocol (SIP)";
 159 static const char config[] = "sip.conf";
 160 static const char notify_config[] = "sip_notify.conf";
 161 static int usecnt = 0;
 162
 163
 164 #define RTP     1
 165 #define NO_RTP  0
 166
 167 /* Do _NOT_ make any changes to this enum, or the array following it;
 168    if you think you are doing the right thing, you are probably
 169    not doing the right thing. If you think there are changes
 170    needed, get someone else to review them first _before_
 171    submitting a patch. If these two lists do not match properly
 172    bad things will happen.
 173 */
 174
 175 enum xmittype {
 176         XMIT_CRITICAL = 2,              /*!< Transmit critical SIP message reliably, with re-transmits.
 177                                                         If it fails, it's critical and will cause a teardown of the session */
 178         XMIT_RELIABLE = 1,              /*!< Transmit SIP message reliably, with re-transmits */
 179         XMIT_UNRELIABLE = 0,            /*!< Transmit SIP message without bothering with re-transmits */
 180 };
 181
 182 enum subscriptiontype {
 183         NONE = 0,
 184         TIMEOUT,
 185         XPIDF_XML,
 186         DIALOG_INFO_XML,
 187         CPIM_PIDF_XML,
 188         PIDF_XML
 189 };
 190
 191 static const struct cfsubscription_types {
 192         enum subscriptiontype type;
 193         const char * const event;
 194         const char * const mediatype;
 195         const char * const text;
 196 } subscription_types[] = {
 197         { NONE,            "-",        "unknown",                    "unknown" },
 198         /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
 199         { DIALOG_INFO_XML, "dialog",   "application/dialog-info+xml", "dialog-info+xml" },
 200         { CPIM_PIDF_XML,   "presence", "application/cpim-pidf+xml",   "cpim-pidf+xml" },  /* RFC 3863 */
 201         { PIDF_XML,        "presence", "application/pidf+xml",        "pidf+xml" },       /* RFC 3863 */
 202         { XPIDF_XML,       "presence", "application/xpidf+xml",       "xpidf+xml" }       /* Pre-RFC 3863 with MS additions */
 203 };
 204
 205 enum sipmethod {
 206         SIP_UNKNOWN,
 207         SIP_RESPONSE,
 208         SIP_REGISTER,
 209         SIP_OPTIONS,
 210         SIP_NOTIFY,
 211         SIP_INVITE,
 212         SIP_ACK,
 213         SIP_PRACK,
 214         SIP_BYE,
 215         SIP_REFER,
 216         SIP_SUBSCRIBE,
 217         SIP_MESSAGE,
 218         SIP_UPDATE,
 219         SIP_INFO,
 220         SIP_CANCEL,
 221         SIP_PUBLISH,
 222 } sip_method_list;
 223
 224 enum sip_auth_type {
 225         PROXY_AUTH,
 226         WWW_AUTH,
 227 };
 228
 229 /*! XXX Note that sip_methods[i].id == i must hold or the code breaks */
 230 static const struct  cfsip_methods {
 231         enum sipmethod id;
 232         int need_rtp;           /*!< when this is the 'primary' use for a pvt structure, does it need RTP? */
 233         char * const text;
 234 } sip_methods[] = {
 235         { SIP_UNKNOWN,   RTP,    "-UNKNOWN-" },
 236         { SIP_RESPONSE,  NO_RTP, "SIP/2.0" },
 237         { SIP_REGISTER,  NO_RTP, "REGISTER" },
 238         { SIP_OPTIONS,   NO_RTP, "OPTIONS" },
 239         { SIP_NOTIFY,    NO_RTP, "NOTIFY" },
 240         { SIP_INVITE,    RTP,    "INVITE" },
 241         { SIP_ACK,       NO_RTP, "ACK" },
 242         { SIP_PRACK,     NO_RTP, "PRACK" },
 243         { SIP_BYE,       NO_RTP, "BYE" },
 244         { SIP_REFER,     NO_RTP, "REFER" },
 245         { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE" },
 246         { SIP_MESSAGE,   NO_RTP, "MESSAGE" },
 247         { SIP_UPDATE,    NO_RTP, "UPDATE" },
 248         { SIP_INFO,      NO_RTP, "INFO" },
 249         { SIP_CANCEL,    NO_RTP, "CANCEL" },
 250         { SIP_PUBLISH,   NO_RTP, "PUBLISH" }
 251 };
 252
 253 /*! \brief Structure for conversion between compressed SIP and "normal" SIP */
 254 static const struct cfalias {
 255         char * const fullname;
 256         char * const shortname;
 257 } aliases[] = {
 258         { "Content-Type", "c" },
 259         { "Content-Encoding", "e" },
 260         { "From", "f" },
 261         { "Call-ID", "i" },
 262         { "Contact", "m" },
 263         { "Content-Length", "l" },
 264         { "Subject", "s" },
 265         { "To", "t" },
 266         { "Supported", "k" },
 267         { "Refer-To", "r" },
 268         { "Referred-By", "b" },
 269         { "Allow-Events", "u" },
 270         { "Event", "o" },
 271         { "Via", "v" },
 272         { "Accept-Contact", "a" },
 273         { "Reject-Contact", "j" },
 274         { "Request-Disposition", "d" },
 275         { "Session-Expires", "x" },
 276 };
 277
 278 /*!  Define SIP option tags, used in Require: and Supported: headers
 279         We need to be aware of these properties in the phones to use
 280         the replace: header. We should not do that without knowing
 281         that the other end supports it...
 282         This is nothing we can configure, we learn by the dialog
 283         Supported: header on the REGISTER (peer) or the INVITE
 284         (other devices)
 285         We are not using many of these today, but will in the future.
 286         This is documented in RFC 3261
 287 */
 288 #define SUPPORTED               1
 289 #define NOT_SUPPORTED           0
 290
 291 #define SIP_OPT_REPLACES        (1 << 0)
 292 #define SIP_OPT_100REL          (1 << 1)
 293 #define SIP_OPT_TIMER           (1 << 2)
 294 #define SIP_OPT_EARLY_SESSION   (1 << 3)
 295 #define SIP_OPT_JOIN            (1 << 4)
 296 #define SIP_OPT_PATH            (1 << 5)
 297 #define SIP_OPT_PREF            (1 << 6)
 298 #define SIP_OPT_PRECONDITION    (1 << 7)
 299 #define SIP_OPT_PRIVACY         (1 << 8)
 300 #define SIP_OPT_SDP_ANAT        (1 << 9)
 301 #define SIP_OPT_SEC_AGREE       (1 << 10)
 302 #define SIP_OPT_EVENTLIST       (1 << 11)
 303 #define SIP_OPT_GRUU            (1 << 12)
 304 #define SIP_OPT_TARGET_DIALOG   (1 << 13)
 305
 306 /*! \brief List of well-known SIP options. If we get this in a require,
 307    we should check the list and answer accordingly. */
 308 static const struct cfsip_options {
 309         int id;                 /*!< Bitmap ID */
 310         int supported;          /*!< Supported by Asterisk ? */
 311         char * const text;      /*!< Text id, as in standard */
 312 } sip_options[] = {
 313         /* Replaces: header for transfer */
 314         { SIP_OPT_REPLACES,     SUPPORTED,      "replaces" },
 315         /* RFC3262: PRACK 100% reliability */
 316         { SIP_OPT_100REL,       NOT_SUPPORTED,  "100rel" },
 317         /* SIP Session Timers */
 318         { SIP_OPT_TIMER,        NOT_SUPPORTED,  "timer" },
 319         /* RFC3959: SIP Early session support */
 320         { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
 321         /* SIP Join header support */
 322         { SIP_OPT_JOIN,         NOT_SUPPORTED,  "join" },
 323         /* RFC3327: Path support */
 324         { SIP_OPT_PATH,         NOT_SUPPORTED,  "path" },
 325         /* RFC3840: Callee preferences */
 326         { SIP_OPT_PREF,         NOT_SUPPORTED,  "pref" },
 327         /* RFC3312: Precondition support */
 328         { SIP_OPT_PRECONDITION, NOT_SUPPORTED,  "precondition" },
 329         /* RFC3323: Privacy with proxies*/
 330         { SIP_OPT_PRIVACY,      NOT_SUPPORTED,  "privacy" },
 331         /* RFC4092: Usage of the SDP ANAT Semantics in the SIP */
 332         { SIP_OPT_SDP_ANAT,     NOT_SUPPORTED,  "sdp-anat" },
 333         /* RFC3329: Security agreement mechanism */
 334         { SIP_OPT_SEC_AGREE,    NOT_SUPPORTED,  "sec_agree" },
 335         /* SIMPLE events:  draft-ietf-simple-event-list-07.txt */
 336         { SIP_OPT_EVENTLIST,    NOT_SUPPORTED,  "eventlist" },
 337         /* GRUU: Globally Routable User Agent URI's */
 338         { SIP_OPT_GRUU,         NOT_SUPPORTED,  "gruu" },
 339         /* Target-dialog: draft-ietf-sip-target-dialog-00.txt */
 340         { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED,  "target-dialog" },
 341 };
 342
 343
 344 /*! \brief SIP Methods we support */
 345 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
 346
 347 /*! \brief SIP Extensions we support */
 348 #define SUPPORTED_EXTENSIONS "replaces"
 349
 350
 351 /* Default values, set and reset in reload_config before reading configuration */
 352 /* These are default values in the source. There are other recommended values in the
 353    sip.conf.sample for new installations. These may differ to keep backwards compatibility,
 354    yet encouraging new behaviour on new installations
 355  */
 356 #define DEFAULT_SIP_PORT        5060    /*!< From RFC 3261 (former 2543) */
 357 #define DEFAULT_CONTEXT         "default"
 358 #define DEFAULT_MUSICCLASS      "default"
 359 #define DEFAULT_VMEXTEN         "asterisk"
 360 #define DEFAULT_CALLERID        "asterisk"
 361 #define DEFAULT_NOTIFYMIME      "application/simple-message-summary"
 362 #define DEFAULT_MWITIME         10
 363 #define DEFAULT_ALLOWGUEST      TRUE
 364 #define DEFAULT_VIDEOSUPPORT    FALSE
 365 #define DEFAULT_SRVLOOKUP       FALSE           /*!< Recommended setting is ON */
 366 #define DEFAULT_COMPACTHEADERS  FALSE
 367 #define DEFAULT_TOS             FALSE
 368 #define DEFAULT_ALLOW_EXT_DOM   TRUE
 369 #define DEFAULT_REALM           "asterisk"
 370 #define DEFAULT_NOTIFYRINGING   TRUE
 371 #define DEFAULT_PEDANTIC        FALSE
 372 #define DEFAULT_AUTOCREATEPEER  FALSE
 373 #define DEFAULT_QUALIFY         FALSE
 374 #define DEFAULT_T1MIN           100             /*!< 100 MS for minimal roundtrip time */
 375 #ifndef DEFAULT_USERAGENT
 376 #define DEFAULT_USERAGENT "Asterisk PBX"        /*!< Default Useragent: header unless re-defined in sip.conf */
 377 #endif
 378
 379 /* Default setttings are used as a channel setting and as a default when
 380    configuring devices */
 381 static char default_context[AST_MAX_CONTEXT];
 382 static char default_subscribecontext[AST_MAX_CONTEXT];
 383 static char default_language[MAX_LANGUAGE];
 384 static char default_callerid[AST_MAX_EXTENSION];
 385 static char default_fromdomain[AST_MAX_EXTENSION];
 386 static char default_notifymime[AST_MAX_EXTENSION];
 387 static int default_qualify;             /*!< Default Qualify= setting */
 388 static char default_vmexten[AST_MAX_EXTENSION];
 389 static char default_musicclass[MAX_MUSICCLASS];         /*!< Global music on hold class */
 390 static struct ast_codec_pref default_prefs;             /*!< Default codec prefs */
 391
 392 /* Global settings only apply to the channel */
 393 static int global_rtautoclear = 120;
 394 static int global_notifyringing;        /*!< Send notifications on ringing */
 395 static int srvlookup;                   /*!< SRV Lookup on or off. Default is off, RFC behavior is on */
 396 static int pedanticsipchecking;         /*!< Extra checking ?  Default off */
 397 static int autocreatepeer;              /*!< Auto creation of peers at registration? Default off. */
 398 static int global_relaxdtmf;                    /*!< Relax DTMF */
 399 static int global_rtptimeout;           /*!< Time out call if no RTP */
 400 static int global_rtpholdtimeout;
 401 static int global_rtpkeepalive;         /*!< Send RTP keepalives */
 402 static int global_reg_timeout;
 403 static int global_regattempts_max;      /*!< Registration attempts before giving up */
 404 static int global_allowguest;           /*!< allow unauthenticated users/peers to connect? */
 405 static int global_mwitime;              /*!< Time between MWI checks for peers */
 406 static int global_tos;                  /*!< IP Type of service */
 407 static int global_videosupport;         /*!< Videosupport on or off */
 408 static int compactheaders;              /*!< send compact sip headers */
 409 static int recordhistory;               /*!< Record SIP history. Off by default */
 410 static int dumphistory;                 /*!< Dump history to verbose before destroying SIP dialog */
 411 static char global_realm[MAXHOSTNAMELEN];               /*!< Default realm */
 412 static char regcontext[AST_MAX_CONTEXT];                /*!< Context for auto-extensions */
 413 static char global_useragent[AST_MAX_EXTENSION];        /*!< Useragent for the SIP channel */
 414 static int allow_external_domains;      /*!< Accept calls to external SIP domains? */
 415 static int global_callevents;           /*!< Whether we send manager events or not */
 416 static int global_t1min;                /*!< T1 roundtrip time minimum */
 417
 418 /*! \brief Codecs that we support by default: */
 419 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
 420 static int noncodeccapability = AST_RTP_DTMF;
 421
 422 /* Object counters */
 423 static int suserobjs = 0;               /*!< Static users */
 424 static int ruserobjs = 0;               /*!< Realtime users */
 425 static int speerobjs = 0;               /*!< Statis peers */
 426 static int rpeerobjs = 0;               /*!< Realtime peers */
 427 static int apeerobjs = 0;               /*!< Autocreated peer objects */
 428 static int regobjs = 0;                 /*!< Registry objects */
 429
 430 static struct ast_flags global_flags = {0};             /*!< global SIP_ flags */
 431 static struct ast_flags global_flags_page2 = {0};       /*!< more global SIP_ flags */
 432
 433 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
 434
 435 AST_MUTEX_DEFINE_STATIC(rand_lock);                     /*!< Lock for thread-safe random generator */
 436
 437 /*! \brief Protect the SIP dialog list (of sip_pvt's) */
 438 AST_MUTEX_DEFINE_STATIC(iflock);
 439
 440 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
 441    when it's doing something critical. */
 442 AST_MUTEX_DEFINE_STATIC(netlock);
 443
 444 AST_MUTEX_DEFINE_STATIC(monlock);
 445
 446 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
 447
 448 /*! \brief This is the thread for the monitor which checks for input on the channels
 449    which are not currently in use.  */
 450 static pthread_t monitor_thread = AST_PTHREADT_NULL;
 451
 452 static int sip_reloading = FALSE;                       /*!< Flag for avoiding multiple reloads at the same time */
 453 static enum channelreloadreason sip_reloadreason;       /*!< Reason for last reload/load of configuration */
 454
 455 static struct sched_context *sched;     /*!< The scheduling context */
 456 static struct io_context *io;           /*!< The IO context */
 457
 458 #define DEC_CALL_LIMIT  0
 459 #define INC_CALL_LIMIT  1
 460
 461
 462 /*! \brief sip_request: The data grabbed from the UDP socket */
 463 struct sip_request {
 464         char *rlPart1;          /*!< SIP Method Name or "SIP/2.0" protocol version */
 465         char *rlPart2;          /*!< The Request URI or Response Status */
 466         int len;                /*!< Length */
 467         int headers;            /*!< # of SIP Headers */
 468         int method;             /*!< Method of this request */
 469         char *header[SIP_MAX_HEADERS];
 470         int lines;              /*!< SDP Content */
 471         char *line[SIP_MAX_LINES];
 472         char data[SIP_MAX_PACKET];
 473         int debug;              /*!< Debug flag for this packet */
 474         unsigned int flags;     /*!< SIP_PKT Flags for this packet */
 475 };
 476
 477 /*! \brief structure used in transfers */
 478 struct sip_dual {
 479         struct ast_channel *chan1;
 480         struct ast_channel *chan2;
 481         struct sip_request req;
 482 };
 483
 484 struct sip_pkt;
 485
 486 /*! \brief Parameters to the transmit_invite function */
 487 struct sip_invite_param {
 488         const char *distinctive_ring;   /*!< Distinctive ring header */
 489         const char *osptoken;           /*!< OSP token for this call */
 490         int addsipheaders;      /*!< Add extra SIP headers */
 491         const char *uri_options;        /*!< URI options to add to the URI */
 492         const char *vxml_url;           /*!< VXML url for Cisco phones */
 493         char *auth;             /*!< Authentication */
 494         char *authheader;       /*!< Auth header */
 495         enum sip_auth_type auth_type;   /*!< Authentication type */
 496 };
 497
 498 /*! \brief Structure to save routing information for a SIP session */
 499 struct sip_route {
 500         struct sip_route *next;
 501         char hop[0];
 502 };
 503
 504 /*! \brief Modes for SIP domain handling in the PBX */
 505 enum domain_mode {
 506         SIP_DOMAIN_AUTO,        /*!< This domain is auto-configured */
 507         SIP_DOMAIN_CONFIG,      /*!< This domain is from configuration */
 508 };
 509
 510 struct domain {
 511         char domain[MAXHOSTNAMELEN];            /*!< SIP domain we are responsible for */
 512         char context[AST_MAX_EXTENSION];        /*!< Incoming context for this domain */
 513         enum domain_mode mode;                  /*!< How did we find this domain? */
 514         AST_LIST_ENTRY(domain) list;            /*!< List mechanics */
 515 };
 516
 517 static AST_LIST_HEAD_STATIC(domain_list, domain);       /*!< The SIP domain list */
 518
 519
 520 /*! \brief sip_history: Structure for saving transactions within a SIP dialog */
 521 struct sip_history {
 522         AST_LIST_ENTRY(sip_history) list;
 523         char event[0];  /* actually more, depending on needs */
 524 };
 525
 526 AST_LIST_HEAD_NOLOCK(sip_history_head, sip_history); /*!< history list, entry in sip_pvt */
 527
 528 /*! \brief sip_auth: Creadentials for authentication to other SIP services */
 529 struct sip_auth {
 530         char realm[AST_MAX_EXTENSION];  /*!< Realm in which these credentials are valid */
 531         char username[256];             /*!< Username */
 532         char secret[256];               /*!< Secret */
 533         char md5secret[256];            /*!< MD5Secret */
 534         struct sip_auth *next;          /*!< Next auth structure in list */
 535 };
 536
 537 /*--- Various flags for the flags field in the pvt structure
 538  Peer only flags should be set in PAGE2 below
 539 */
 540 #define SIP_ALREADYGONE         (1 << 0)        /*!< Whether or not we've already been destroyed by our peer */
 541 #define SIP_NEEDDESTROY         (1 << 1)        /*!< if we need to be destroyed */
 542 #define SIP_NOVIDEO             (1 << 2)        /*!< Didn't get video in invite, don't offer */
 543 #define SIP_RINGING             (1 << 3)        /*!< Have sent 180 ringing */
 544 #define SIP_PROGRESS_SENT       (1 << 4)        /*!< Have sent 183 message progress */
 545 #define SIP_NEEDREINVITE        (1 << 5)        /*!< Do we need to send another reinvite? */
 546 #define SIP_PENDINGBYE          (1 << 6)        /*!< Need to send bye after we ack? */
 547 #define SIP_GOTREFER            (1 << 7)        /*!< Got a refer? */
 548 #define SIP_PROMISCREDIR        (1 << 8)        /*!< Promiscuous redirection */
 549 #define SIP_TRUSTRPID           (1 << 9)        /*!< Trust RPID headers? */
 550 #define SIP_USEREQPHONE         (1 << 10)       /*!< Add user=phone to numeric URI. Default off */
 551 #define SIP_REALTIME            (1 << 11)       /*!< Flag for realtime users */
 552 #define SIP_USECLIENTCODE       (1 << 12)       /*!< Trust X-ClientCode info message */
 553 #define SIP_OUTGOING            (1 << 13)       /*!< Is this an outgoing call? */
 554 #define SIP_FREEBIT             (1 << 14)       /*!< Free for session-related use */
 555 #define SIP_FREEBIT3            (1 << 15)       /*!< Free for session-related use */
 556 #define SIP_DTMF                (3 << 16)       /*!< DTMF Support: four settings, uses two bits */
 557 #define SIP_DTMF_RFC2833        (0 << 16)       /*!< DTMF Support: RTP DTMF - "rfc2833" */
 558 #define SIP_DTMF_INBAND         (1 << 16)       /*!< DTMF Support: Inband audio, only for ULAW/ALAW - "inband" */
 559 #define SIP_DTMF_INFO           (2 << 16)       /*!< DTMF Support: SIP Info messages - "info" */
 560 #define SIP_DTMF_AUTO           (3 << 16)       /*!< DTMF Support: AUTO switch between rfc2833 and in-band DTMF */
 561 /* NAT settings */
 562 #define SIP_NAT                 (3 << 18)       /*!< four settings, uses two bits */
 563 #define SIP_NAT_NEVER           (0 << 18)       /*!< No nat support */
 564 #define SIP_NAT_RFC3581         (1 << 18)
 565 #define SIP_NAT_ROUTE           (2 << 18)
 566 #define SIP_NAT_ALWAYS          (3 << 18)
 567 /* re-INVITE related settings */
 568 #define SIP_REINVITE            (3 << 20)       /*!< two bits used */
 569 #define SIP_CAN_REINVITE        (1 << 20)       /*!< allow peers to be reinvited to send media directly p2p */
 570 #define SIP_REINVITE_UPDATE     (2 << 20)       /*!< use UPDATE (RFC3311) when reinviting this peer */
 571 /* "insecure" settings */
 572 #define SIP_INSECURE_PORT       (1 << 22)       /*!< don't require matching port for incoming requests */
 573 #define SIP_INSECURE_INVITE     (1 << 23)       /*!< don't require authentication for incoming INVITEs */
 574 /* Sending PROGRESS in-band settings */
 575 #define SIP_PROG_INBAND         (3 << 24)       /*!< three settings, uses two bits */
 576 #define SIP_PROG_INBAND_NEVER   (0 << 24)
 577 #define SIP_PROG_INBAND_NO      (1 << 24)
 578 #define SIP_PROG_INBAND_YES     (2 << 24)
 579 /* Open Settlement Protocol authentication */
 580 #define SIP_OSPAUTH             (3 << 26)       /*!< four settings, uses two bits */
 581 #define SIP_OSPAUTH_NO          (0 << 26)
 582 #define SIP_OSPAUTH_GATEWAY     (1 << 26)
 583 #define SIP_OSPAUTH_PROXY       (2 << 26)
 584 #define SIP_OSPAUTH_EXCLUSIVE   (3 << 26)
 585 /* Call states */
 586 #define SIP_CALL_ONHOLD         (1 << 28)
 587 #define SIP_CALL_LIMIT          (1 << 29)
 588 /* Remote Party-ID Support */
 589 #define SIP_SENDRPID            (1 << 30)
 590 /* Did this connection increment the counter of in-use calls? */
 591 #define SIP_INC_COUNT           (1 << 31)
 592
 593 #define SIP_FLAGS_TO_COPY \
 594         (SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | \
 595          SIP_PROG_INBAND | SIP_OSPAUTH | SIP_USECLIENTCODE | SIP_NAT | \
 596          SIP_INSECURE_PORT | SIP_INSECURE_INVITE)
 597
 598 /* a new page of flags for peers */
 599 #define SIP_PAGE2_RTCACHEFRIENDS        (1 << 0)
 600 #define SIP_PAGE2_RTUPDATE              (1 << 1)
 601 #define SIP_PAGE2_RTAUTOCLEAR           (1 << 2)
 602 #define SIP_PAGE2_IGNOREREGEXPIRE       (1 << 3)
 603 #define SIP_PAGE2_RT_FROMCONTACT        (1 << 4)
 604 #define SIP_PAGE2_DEBUG                 (3 << 5)
 605 #define SIP_PAGE2_DEBUG_CONFIG          (1 << 5)
 606 #define SIP_PAGE2_DEBUG_CONSOLE         (1 << 6)
 607 #define SIP_PAGE2_DYNAMIC               (1 << 7)        /*!< Dynamic Peers register with Asterisk */
 608 #define SIP_PAGE2_SELFDESTRUCT          (1 << 8)        /*!< Automatic peers need to destruct themselves */
 609
 610 /* SIP packet flags */
 611 #define SIP_PKT_DEBUG           (1 << 0)        /*!< Debug this packet */
 612 #define SIP_PKT_WITH_TOTAG      (1 << 1)        /*!< This packet has a to-tag */
 613
 614 #define sipdebug                ast_test_flag(&global_flags_page2, SIP_PAGE2_DEBUG)
 615 #define sipdebug_config         ast_test_flag(&global_flags_page2, SIP_PAGE2_DEBUG_CONFIG)
 616 #define sipdebug_console        ast_test_flag(&global_flags_page2, SIP_PAGE2_DEBUG_CONSOLE)
 617
 618
 619 /*! \brief sip_pvt: PVT structures are used for each SIP dialog, ie. a call, a registration, a subscribe  */
 620 static struct sip_pvt {
 621         ast_mutex_t lock;                       /*!< Dialog private lock */
 622         int method;                             /*!< SIP method that opened this dialog */
 623         AST_DECLARE_STRING_FIELDS(
 624                 AST_STRING_FIELD(callid);       /*!< Global CallID */
 625                 AST_STRING_FIELD(randdata);     /*!< Random data */
 626                 AST_STRING_FIELD(accountcode);  /*!< Account code */
 627                 AST_STRING_FIELD(realm);        /*!< Authorization realm */
 628                 AST_STRING_FIELD(nonce);        /*!< Authorization nonce */
 629                 AST_STRING_FIELD(opaque);       /*!< Opaque nonsense */
 630                 AST_STRING_FIELD(qop);          /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
 631                 AST_STRING_FIELD(domain);       /*!< Authorization domain */
 632                 AST_STRING_FIELD(refer_to);     /*!< Place to store REFER-TO extension */
 633                 AST_STRING_FIELD(referred_by);  /*!< Place to store REFERRED-BY extension */
 634                 AST_STRING_FIELD(refer_contact);/*!< Place to store Contact info from a REFER extension */
 635                 AST_STRING_FIELD(from);         /*!< The From: header */
 636                 AST_STRING_FIELD(useragent);    /*!< User agent in SIP request */
 637                 AST_STRING_FIELD(exten);        /*!< Extension where to start */
 638                 AST_STRING_FIELD(context);      /*!< Context for this call */
 639                 AST_STRING_FIELD(subscribecontext); /*!< Subscribecontext */
 640                 AST_STRING_FIELD(fromdomain);   /*!< Domain to show in the from field */
 641                 AST_STRING_FIELD(fromuser);     /*!< User to show in the user field */
 642                 AST_STRING_FIELD(fromname);     /*!< Name to show in the user field */
 643                 AST_STRING_FIELD(tohost);       /*!< Host we should put in the "to" field */
 644                 AST_STRING_FIELD(language);     /*!< Default language for this call */
 645                 AST_STRING_FIELD(musicclass);   /*!< Music on Hold class */
 646                 AST_STRING_FIELD(rdnis);        /*!< Referring DNIS */
 647                 AST_STRING_FIELD(theirtag);     /*!< Their tag */
 648                 AST_STRING_FIELD(username);     /*!< [user] name */
 649                 AST_STRING_FIELD(peername);     /*!< [peer] name, not set if [user] */
 650                 AST_STRING_FIELD(authname);     /*!< Who we use for authentication */
 651                 AST_STRING_FIELD(uri);          /*!< Original requested URI */
 652                 AST_STRING_FIELD(okcontacturi); /*!< URI from the 200 OK on INVITE */
 653                 AST_STRING_FIELD(peersecret);   /*!< Password */
 654                 AST_STRING_FIELD(peermd5secret);
 655                 AST_STRING_FIELD(cid_num);      /*!< Caller*ID */
 656                 AST_STRING_FIELD(cid_name);     /*!< Caller*ID */
 657                 AST_STRING_FIELD(via);          /*!< Via: header */
 658                 AST_STRING_FIELD(fullcontact);  /*!< The Contact: that the UA registers with us */
 659                 AST_STRING_FIELD(our_contact);  /*!< Our contact header */
 660                 AST_STRING_FIELD(rpid);         /*!< Our RPID header */
 661                 AST_STRING_FIELD(rpid_from);    /*!< Our RPID From header */
 662         );
 663         struct ast_codec_pref prefs;            /*!< codec prefs */
 664         unsigned int ocseq;                     /*!< Current outgoing seqno */
 665         unsigned int icseq;                     /*!< Current incoming seqno */
 666         ast_group_t callgroup;                  /*!< Call group */
 667         ast_group_t pickupgroup;                /*!< Pickup group */
 668         int lastinvite;                         /*!< Last Cseq of invite */
 669         unsigned int flags;                     /*!< SIP_ flags */
 670         int timer_t1;                           /*!< SIP timer T1, ms rtt */
 671         unsigned int sipoptions;                /*!< Supported SIP sipoptions on the other end */
 672         int capability;                         /*!< Special capability (codec) */
 673         int jointcapability;                    /*!< Supported capability at both ends (codecs ) */
 674         int peercapability;                     /*!< Supported peer capability */
 675         int prefcodec;                          /*!< Preferred codec (outbound only) */
 676         int noncodeccapability;
 677         int callingpres;                        /*!< Calling presentation */
 678         int authtries;                          /*!< Times we've tried to authenticate */
 679         int expiry;                             /*!< How long we take to expire */
 680         int branch;                             /*!< One random number */
 681         char tag[11];                           /*!< Another random number */
 682         int sessionid;                          /*!< SDP Session ID */
 683         int sessionversion;                     /*!< SDP Session Version */
 684         struct sockaddr_in sa;                  /*!< Our peer */
 685         struct sockaddr_in redirip;             /*!< Where our RTP should be going if not to us */
 686         struct sockaddr_in vredirip;            /*!< Where our Video RTP should be going if not to us */
 687         int redircodecs;                        /*!< Redirect codecs */
 688         struct sockaddr_in recv;                /*!< Received as */
 689         struct in_addr ourip;                   /*!< Our IP */
 690         struct ast_channel *owner;              /*!< Who owns us */
 691         struct sip_pvt *refer_call;             /*!< Call we are referring */
 692         struct sip_route *route;                /*!< Head of linked list of routing steps (fm Record-Route) */
 693         int route_persistant;                   /*!< Is this the "real" route? */
 694         struct sip_auth *peerauth;              /*!< Realm authentication */
 695         int noncecount;                         /*!< Nonce-count */
 696         char lastmsg[256];                      /*!< Last Message sent/received */
 697         int amaflags;                           /*!< AMA Flags */
 698         int pendinginvite;                      /*!< Any pending invite */
 699 #ifdef OSP_SUPPORT
 700         int osphandle;                          /*!< OSP Handle for call */
 701         time_t ospstart;                        /*!< OSP Start time */
 702         unsigned int osptimelimit;              /*!< OSP call duration limit */
 703 #endif
 704         struct sip_request initreq;             /*!< Initial request that opened the SIP dialog */
 705
 706         int maxtime;                            /*!< Max time for first response */
 707         int initid;                             /*!< Auto-congest ID if appropriate */
 708         int autokillid;                         /*!< Auto-kill ID */
 709         time_t lastrtprx;                       /*!< Last RTP received */
 710         time_t lastrtptx;                       /*!< Last RTP sent */
 711         int rtptimeout;                         /*!< RTP timeout time */
 712         int rtpholdtimeout;                     /*!< RTP timeout when on hold */
 713         int rtpkeepalive;                       /*!< Send RTP packets for keepalive */
 714         enum subscriptiontype subscribed;       /*!< Is this dialog a subscription?  */
 715         int stateid;
 716         int laststate;                          /*!< Last known extension state */
 717         int dialogver;
 718
 719         struct ast_dsp *vad;                    /*!< Voice Activation Detection dsp */
 720
 721         struct sip_peer *peerpoke;              /*!< If this dialog is to poke a peer, which one */
 722         struct sip_registry *registry;          /*!< If this is a REGISTER dialog, to which registry */
 723         struct ast_rtp *rtp;                    /*!< RTP Session */
 724         struct ast_rtp *vrtp;                   /*!< Video RTP session */
 725         struct sip_pkt *packets;                /*!< Packets scheduled for re-transmission */
 726         struct sip_history_head *history;       /*!< History of this SIP dialog */
 727         struct ast_variable *chanvars;          /*!< Channel variables to set for call */
 728         struct sip_pvt *next;                   /*!< Next dialog in chain */
 729         struct sip_invite_param *options;       /*!< Options for INVITE */
 730 } *iflist = NULL;
 731
 732 #define FLAG_RESPONSE (1 << 0)
 733 #define FLAG_FATAL (1 << 1)
 734
 735 /*! \brief sip packet - read in sipsock_read(), transmitted in send_request() */
 736 struct sip_pkt {
 737         struct sip_pkt *next;                   /*!< Next packet */
 738         int retrans;                            /*!< Retransmission number */
 739         int method;                             /*!< SIP method for this packet */
 740         int seqno;                              /*!< Sequence number */
 741         unsigned int flags;                     /*!< non-zero if this is a response packet (e.g. 200 OK) */
 742         struct sip_pvt *owner;                  /*!< Owner AST call */
 743         int retransid;                          /*!< Retransmission ID */
 744         int timer_a;                            /*!< SIP timer A, retransmission timer */
 745         int timer_t1;                           /*!< SIP Timer T1, estimated RTT or 500 ms */
 746         int packetlen;                          /*!< Length of packet */
 747         char data[0];
 748 };
 749
 750 /*! \brief Structure for SIP user data. User's place calls to us */
 751 struct sip_user {
 752         /* Users who can access various contexts */
 753         ASTOBJ_COMPONENTS(struct sip_user);
 754         char secret[80];                /*!< Password */
 755         char md5secret[80];             /*!< Password in md5 */
 756         char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
 757         char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
 758         char cid_num[80];               /*!< Caller ID num */
 759         char cid_name[80];              /*!< Caller ID name */
 760         char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
 761         char language[MAX_LANGUAGE];    /*!< Default language for this user */
 762         char musicclass[MAX_MUSICCLASS];/*!< Music on Hold class */
 763         char useragent[256];            /*!< User agent in SIP request */
 764         struct ast_codec_pref prefs;    /*!< codec prefs */
 765         ast_group_t callgroup;          /*!< Call group */
 766         ast_group_t pickupgroup;        /*!< Pickup Group */
 767         unsigned int flags;             /*!< SIP flags */
 768         unsigned int sipoptions;        /*!< Supported SIP options */
 769         struct ast_flags flags_page2;   /*!< SIP_PAGE2 flags */
 770         int amaflags;                   /*!< AMA flags for billing */
 771         int callingpres;                /*!< Calling id presentation */
 772         int capability;                 /*!< Codec capability */
 773         int inUse;                      /*!< Number of calls in use */
 774         int call_limit;                 /*!< Limit of concurrent calls */
 775         struct ast_ha *ha;              /*!< ACL setting */
 776         struct ast_variable *chanvars;  /*!< Variables to set for channel created by user */
 777 };
 778
 779 /*! \brief Structure for SIP peer data, we place calls to peers if registered  or fixed IP address (host) */
 780 struct sip_peer {
 781         ASTOBJ_COMPONENTS(struct sip_peer);     /*!< name, refcount, objflags,  object pointers */
 782                                         /*!< peer->name is the unique name of this object */
 783         char secret[80];                /*!< Password */
 784         char md5secret[80];             /*!< Password in MD5 */
 785         struct sip_auth *auth;          /*!< Realm authentication list */
 786         char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
 787         char subscribecontext[AST_MAX_CONTEXT]; /*!< Default context for subscriptions */
 788         char username[80];              /*!< Temporary username until registration */
 789         char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
 790         int amaflags;                   /*!< AMA Flags (for billing) */
 791         char tohost[MAXHOSTNAMELEN];    /*!< If not dynamic, IP address */
 792         char regexten[AST_MAX_EXTENSION]; /*!< Extension to register (if regcontext is used) */
 793         char fromuser[80];              /*!< From: user when calling this peer */
 794         char fromdomain[MAXHOSTNAMELEN];        /*!< From: domain when calling this peer */
 795         char fullcontact[256];          /*!< Contact registered with us (not in sip.conf) */
 796         char cid_num[80];               /*!< Caller ID num */
 797         char cid_name[80];              /*!< Caller ID name */
 798         int callingpres;                /*!< Calling id presentation */
 799         int inUse;                      /*!< Number of calls in use */
 800         int call_limit;                 /*!< Limit of concurrent calls */
 801         char vmexten[AST_MAX_EXTENSION]; /*!< Dialplan extension for MWI notify message*/
 802         char mailbox[AST_MAX_EXTENSION]; /*!< Mailbox setting for MWI checks */
 803         char language[MAX_LANGUAGE];    /*!<  Default language for prompts */
 804         char musicclass[MAX_MUSICCLASS];/*!<  Music on Hold class */
 805         char useragent[256];            /*!<  User agent in SIP request (saved from registration) */
 806         struct ast_codec_pref prefs;    /*!<  codec prefs */
 807         int lastmsgssent;
 808         time_t  lastmsgcheck;           /*!<  Last time we checked for MWI */
 809         unsigned int flags;             /*!<  SIP flags */
 810         unsigned int sipoptions;        /*!<  Supported SIP options */
 811         struct ast_flags flags_page2;   /*!<  SIP_PAGE2 flags */
 812         int expire;                     /*!<  When to expire this peer registration */
 813         int capability;                 /*!<  Codec capability */
 814         int rtptimeout;                 /*!<  RTP timeout */
 815         int rtpholdtimeout;             /*!<  RTP Hold Timeout */
 816         int rtpkeepalive;               /*!<  Send RTP packets for keepalive */
 817         ast_group_t callgroup;          /*!<  Call group */
 818         ast_group_t pickupgroup;        /*!<  Pickup group */
 819         struct ast_dnsmgr_entry *dnsmgr;/*!<  DNS refresh manager for peer */
 820         struct sockaddr_in addr;        /*!<  IP address of peer */
 821
 822         /* Qualification */
 823         struct sip_pvt *call;           /*!<  Call pointer */
 824         int pokeexpire;                 /*!<  When to expire poke (qualify= checking) */
 825         int lastms;                     /*!<  How long last response took (in ms), or -1 for no response */
 826         int maxms;                      /*!<  Max ms we will accept for the host to be up, 0 to not monitor */
 827         struct timeval ps;              /*!<  Ping send time */
 828
 829         struct sockaddr_in defaddr;     /*!<  Default IP address, used until registration */
 830         struct ast_ha *ha;              /*!<  Access control list */
 831         struct ast_variable *chanvars;  /*!<  Variables to set for channel created by user */
 832         int lastmsg;
 833 };
 834
 835
 836 /* States for outbound registrations (with register= lines in sip.conf */
 837 #define REG_STATE_UNREGISTERED          0       /*!< We are not registred */
 838 #define REG_STATE_REGSENT               1       /*!< Registration request sent */
 839 #define REG_STATE_AUTHSENT              2       /*!< We have tried to authenticate */
 840 #define REG_STATE_REGISTERED            3       /*!< Registred and done */
 841 #define REG_STATE_REJECTED              4       /*!< Registration rejected */
 842 #define REG_STATE_TIMEOUT               5       /*!< Registration timed out */
 843 #define REG_STATE_NOAUTH                6       /*!< We have no accepted credentials */
 844 #define REG_STATE_FAILED                7       /*!< Registration failed after several tries */
 845
 846
 847 /*! \brief Registrations with other SIP proxies */
 848 struct sip_registry {
 849         ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
 850         AST_DECLARE_STRING_FIELDS(
 851                 AST_STRING_FIELD(callid);       /*!< Global Call-ID */
 852                 AST_STRING_FIELD(realm);        /*!< Authorization realm */
 853                 AST_STRING_FIELD(nonce);        /*!< Authorization nonce */
 854                 AST_STRING_FIELD(opaque);       /*!< Opaque nonsense */
 855                 AST_STRING_FIELD(qop);          /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
 856                 AST_STRING_FIELD(domain);       /*!< Authorization domain */
 857                 AST_STRING_FIELD(username);     /*!< Who we are registering as */
 858                 AST_STRING_FIELD(authuser);     /*!< Who we *authenticate* as */
 859                 AST_STRING_FIELD(hostname);     /*!< Domain or host we register to */
 860                 AST_STRING_FIELD(secret);       /*!< Password in clear text */
 861                 AST_STRING_FIELD(md5secret);    /*!< Password in md5 */
 862                 AST_STRING_FIELD(contact);      /*!< Contact extension */
 863                 AST_STRING_FIELD(random);
 864         );
 865         int portno;                     /*!<  Optional port override */
 866         int expire;                     /*!< Sched ID of expiration */
 867         int regattempts;                /*!< Number of attempts (since the last success) */
 868         int timeout;                    /*!< sched id of sip_reg_timeout */
 869         int refresh;                    /*!< How often to refresh */
 870         struct sip_pvt *call;           /*!< create a sip_pvt structure for each outbound "registration dialog" in progress */
 871         int regstate;                   /*!< Registration state (see above) */
 872         int callid_valid;               /*!< 0 means we haven't chosen callid for this registry yet. */
 873         unsigned int ocseq;             /*!< Sequence number we got to for REGISTERs for this registry */
 874         struct sockaddr_in us;          /*!< Who the server thinks we are */
 875         int noncecount;                 /*!< Nonce-count */
 876         char lastmsg[256];              /*!< Last Message sent/received */
 877 };
 878
 879 /* --- Linked lists of various objects --------*/
 880
 881 /*! \brief  The user list: Users and friends */
 882 static struct ast_user_list {
 883         ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
 884 } userl;
 885
 886 /*! \brief  The peer list: Peers and Friends */
 887 static struct ast_peer_list {
 888         ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
 889 } peerl;
 890
 891 /*! \brief  The register list: Other SIP proxys we register with and place calls to */
 892 static struct ast_register_list {
 893         ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
 894         int recheck;
 895 } regl;
 896
 897 /*! \todo Move the sip_auth list to AST_LIST */
 898 static struct sip_auth *authl = NULL;           /*!< Authentication list for realm authentication */
 899
 900
 901 /* --- Sockets and networking --------------*/
 902 static int sipsock  = -1;                       /*!< Main socket for SIP network communication */
 903 static struct sockaddr_in bindaddr = { 0, };    /*!< The address we bind to */
 904 static struct sockaddr_in externip;             /*!< External IP address if we are behind NAT */
 905 static char externhost[MAXHOSTNAMELEN];         /*!< External host name (possibly with dynamic DNS and DHCP */
 906 static time_t externexpire = 0;                 /*!< Expiration counter for re-resolving external host name in dynamic DNS */
 907 static int externrefresh = 10;
 908 static struct ast_ha *localaddr;                /*!< List of local networks, on the same side of NAT as this Asterisk */
 909 static struct in_addr __ourip;
 910 static struct sockaddr_in outboundproxyip;
 911 static int ourport;
 912 static struct sockaddr_in debugaddr;
 913
 914 struct ast_config *notify_types;                /*!< The list of manual NOTIFY types we know how to send */
 915
 916
 917
 918 /*---------------------------- Forward declarations of functions in chan_sip.c */
 919 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
 920 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, enum xmittype reliable);
 921 static int transmit_response_with_unsupported(struct sip_pvt *p, char *msg, struct sip_request *req, char *unsupported);
 922 static int transmit_response_with_auth(struct sip_pvt *p, const char *msg, struct sip_request *req, const char *rand, enum xmittype reliable, const char *header, int stale);
 923 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
 924 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
 925 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sendsdp, int init);
 926 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
 927 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
 928 static int transmit_info_with_vidupdate(struct sip_pvt *p);
 929 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
 930 static int transmit_refer(struct sip_pvt *p, const char *dest);
 931 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
 932 static struct sip_peer *temp_peer(const char *name);
 933 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init);
 934 static void free_old_route(struct sip_route *route);
 935 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
 936 static int update_call_counter(struct sip_pvt *fup, int event);
 937 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
 938 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
 939 static int sip_do_reload(enum channelreloadreason reason);
 940 static int expire_register(void *data);
 941 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
 942 static int sip_devicestate(void *data);
 943 static int sip_sendtext(struct ast_channel *ast, const char *text);
 944 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
 945 static int sip_hangup(struct ast_channel *ast);
 946 static int sip_answer(struct ast_channel *ast);
 947 static struct ast_frame *sip_read(struct ast_channel *ast);
 948 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
 949 static int sip_indicate(struct ast_channel *ast, int condition);
 950 static int sip_transfer(struct ast_channel *ast, const char *dest);
 951 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
 952 static int sip_senddigit(struct ast_channel *ast, char digit);
 953 static int clear_realm_authentication(struct sip_auth *authlist);       /* Clear realm authentication list (at reload) */
 954 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);   /* Add realm authentication in list */
 955 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);        /* Find authentication for a specific realm */
 956 static int check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
 957                 const char *secret, const char *md5secret, int sipmethod,
 958                 char *uri, enum xmittype reliable, int ignore);
 959 static int check_sip_domain(const char *domain, char *context, size_t len); /* Check if domain is one of our local domains */
 960 static void append_date(struct sip_request *req);       /* Append date to SIP packet */
 961 static int determine_firstline_parts(struct sip_request *req);
 962 static void sip_dump_history(struct sip_pvt *dialog);   /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
 963 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
 964 static int transmit_state_notify(struct sip_pvt *p, int state, int full);
 965 static char *gettag(struct sip_request *req, char *header, char *tagbuf, int tagbufsize);
 966 static int find_sip_method(char *msg);
 967 static unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported);
 968 static void sip_destroy(struct sip_pvt *p);
 969 static void parse_request(struct sip_request *req);
 970 static char *get_header(struct sip_request *req, const char *name);
 971 static void copy_request(struct sip_request *dst,struct sip_request *src);
 972 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req);
 973 static int transmit_register(struct sip_registry *r, int sipmethod, char *auth, char *authheader);
 974 static int sip_poke_peer(struct sip_peer *peer);
 975 static int __sip_do_register(struct sip_registry *r);
 976 static int restart_monitor(void);
 977 static void set_peer_defaults(struct sip_peer *peer);
 978 static struct sip_peer *temp_peer(const char *name);
 979
 980
 981 /*----- RTP interface functions */
 982 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active);
 983 static struct ast_rtp *sip_get_rtp_peer(struct ast_channel *chan);
 984 static struct ast_rtp *sip_get_vrtp_peer(struct ast_channel *chan);
 985 static int sip_get_codec(struct ast_channel *chan);
 986
 987 /*! \brief Definition of this channel for PBX channel registration */
 988 static const struct ast_channel_tech sip_tech = {
 989         .type = "SIP",
 990         .description = "Session Initiation Protocol (SIP)",
 991         .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
 992         .properties = AST_CHAN_TP_WANTSJITTER,
 993         .requester = sip_request_call,
 994         .devicestate = sip_devicestate,
 995         .call = sip_call,
 996         .hangup = sip_hangup,
 997         .answer = sip_answer,
 998         .read = sip_read,
 999         .write = sip_write,
1000         .write_video = sip_write,
1001         .indicate = sip_indicate,
1002         .transfer = sip_transfer,
1003         .fixup = sip_fixup,
1004         .send_digit = sip_senddigit,
1005         .bridge = ast_rtp_bridge,
1006         .send_text = sip_sendtext,
1007 };
1008
1009 /*! \brief Interface structure with callbacks used to connect to RTP module */
1010 static struct ast_rtp_protocol sip_rtp = {
1011         type: "SIP",
1012         get_rtp_info: sip_get_rtp_peer,
1013         get_vrtp_info: sip_get_vrtp_peer,
1014         set_rtp_peer: sip_set_rtp_peer,
1015         get_codec: sip_get_codec,
1016 };
1017
1018
1019 /*!
1020   \brief Thread-safe random number generator
1021   \return a random number
1022
1023   This function uses a mutex lock to guarantee that no
1024   two threads will receive the same random number.
1025  */
1026 static force_inline int thread_safe_rand(void)
1027 {
1028         int val;
1029
1030         ast_mutex_lock(&rand_lock);
1031         val = rand();
1032         ast_mutex_unlock(&rand_lock);
1033
1034         return val;
1035 }
1036
1037 /*! \brief Find SIP method from header
1038  * Strictly speaking, SIP methods are case SENSITIVE, but we don't check
1039  * following Jon Postel's rule: Be gentle in what you accept, strict with what you send */
1040 static int find_sip_method(char *msg)
1041 {
1042         int i, res = 0;
1043
1044         if (ast_strlen_zero(msg))
1045                 return 0;
1046
1047         for (i = 1; (i < (sizeof(sip_methods) / sizeof(sip_methods[0]))) && !res; i++) {
1048                 if (!strcasecmp(sip_methods[i].text, msg))
1049                         res = sip_methods[i].id;
1050         }
1051         return res;
1052 }
1053
1054 /*! \brief Parse supported header in incoming packet */
1055 static unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
1056 {
1057         char *next = NULL;
1058         char *sep = NULL;
1059         char *temp = ast_strdupa(supported);
1060         int i;
1061         unsigned int profile = 0;
1062
1063         if (ast_strlen_zero(supported) )
1064                 return 0;
1065
1066         if (option_debug > 2 && sipdebug)
1067                 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
1068
1069         next = temp;
1070         while (next) {
1071                 char res=0;
1072                 if ( (sep = strchr(next, ',')) != NULL) {
1073                         *sep = '\0';
1074                         sep++;
1075                 }
1076                 while (*next == ' ')    /* Skip spaces */
1077                         next++;
1078                 if (option_debug > 2 && sipdebug)
1079                         ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
1080                 for (i=0; (i < (sizeof(sip_options) / sizeof(sip_options[0]))) && !res; i++) {
1081                         if (!strcasecmp(next, sip_options[i].text)) {
1082                                 profile |= sip_options[i].id;
1083                                 res = 1;
1084                                 if (option_debug > 2 && sipdebug)
1085                                         ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
1086                         }
1087                 }
1088                 if (!res)
1089                         if (option_debug > 2 && sipdebug)
1090                                 ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
1091                 next = sep;
1092         }
1093         if (pvt) {
1094                 pvt->sipoptions = profile;
1095                 if (option_debug)
1096                         ast_log(LOG_DEBUG, "* SIP extension value: %d for call %s\n", profile, pvt->callid);
1097         }
1098         return profile;
1099 }
1100
1101 /*! \brief See if we pass debug IP filter */
1102 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
1103 {
1104         if (!sipdebug)
1105                 return 0;
1106         if (debugaddr.sin_addr.s_addr) {
1107                 if (((ntohs(debugaddr.sin_port) != 0)
1108                         && (debugaddr.sin_port != addr->sin_port))
1109                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
1110                         return 0;
1111         }
1112         return 1;
1113 }
1114
1115 /*! \brief Test PVT for debugging output */
1116 static inline int sip_debug_test_pvt(struct sip_pvt *p)
1117 {
1118         if (!sipdebug)
1119                 return 0;
1120         return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
1121 }
1122
1123
1124 /*! \brief Transmit SIP message */
1125 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
1126 {
1127         int res;
1128         char iabuf[INET_ADDRSTRLEN];
1129
1130         if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1131                 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
1132         else
1133                 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
1134
1135         if (res != len) {
1136                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s:%d returned %d: %s\n", data, len, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), res, strerror(errno));
1137         }
1138         return res;
1139 }
1140
1141
1142 /*! \brief Build a Via header for a request */
1143 static void build_via(struct sip_pvt *p)
1144 {
1145         char iabuf[INET_ADDRSTRLEN];
1146         /* Work around buggy UNIDEN UIP200 firmware */
1147         const char *rport = ast_test_flag(p, SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : "";
1148
1149         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
1150         ast_string_field_build(p, via, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x%s",
1151                          ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch, rport);
1152 }
1153
1154 /*! \brief NAT fix - decide which IP address to use for ASterisk server?
1155  * Only used for outbound registrations */
1156 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
1157 {
1158         /*
1159          * Using the localaddr structure built up with localnet statements
1160          * apply it to their address to see if we need to substitute our
1161          * externip or can get away with our internal bindaddr
1162          */
1163         struct sockaddr_in theirs;
1164         theirs.sin_addr = *them;
1165
1166         if (localaddr && externip.sin_addr.s_addr &&
1167            ast_apply_ha(localaddr, &theirs)) {
1168                 if (externexpire && (time(NULL) >= externexpire)) {
1169                         struct ast_hostent ahp;
1170                         struct hostent *hp;
1171
1172                         time(&externexpire);
1173                         externexpire += externrefresh;
1174                         if ((hp = ast_gethostbyname(externhost, &ahp))) {
1175                                 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
1176                         } else
1177                                 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
1178                 }
1179                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
1180                 if (option_debug) {
1181                         char iabuf[INET_ADDRSTRLEN];
1182                         ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
1183
1184                         ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
1185                 }
1186         } else if (bindaddr.sin_addr.s_addr)
1187                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
1188         else
1189                 return ast_ouraddrfor(them, us);
1190         return 0;
1191 }
1192
1193 /*! \brief Append to SIP dialog history
1194         \return Always returns 0 */
1195 #define append_history(p, event, fmt , args... )        append_history_full(p, "%-15s " fmt, event, ## args)
1196
1197 static int append_history_full(struct sip_pvt *p, const char *fmt, ...)
1198         __attribute__ ((format (printf, 2, 3)));
1199
1200 /*! \brief Append to SIP dialog history with arg list  */
1201 static void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
1202 {
1203         char buf[80], *c = buf; /* max history length */
1204         struct sip_history *hist;
1205         int l;
1206
1207         vsnprintf(buf, sizeof(buf), fmt, ap);
1208         strsep(&c, "\r\n"); /* Trim up everything after \r or \n */
1209         l = strlen(buf) + 1;
1210         if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
1211                 return;
1212         if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
1213                 free(hist);
1214                 return;
1215         }
1216         memcpy(hist->event, buf, l);
1217         AST_LIST_INSERT_TAIL(p->history, hist, list);
1218 }
1219
1220 /*! \brief Append to SIP dialog history with arg list  */
1221 static int append_history_full(struct sip_pvt *p, const char *fmt, ...)
1222 {
1223         va_list ap;
1224
1225         if (!recordhistory || !p)
1226                 return 0;
1227         va_start(ap, fmt);
1228         append_history_va(p, fmt, ap);
1229         va_end(ap);
1230
1231         return 0;
1232 }
1233
1234 /*! \brief Retransmit SIP message if no answer */
1235 static int retrans_pkt(void *data)
1236 {
1237         struct sip_pkt *pkt=data, *prev, *cur = NULL;
1238         char iabuf[INET_ADDRSTRLEN];
1239         int reschedule = DEFAULT_RETRANS;
1240
1241         /* Lock channel */
1242         ast_mutex_lock(&pkt->owner->lock);
1243
1244         if (pkt->retrans < MAX_RETRANS) {
1245                 pkt->retrans++;
1246                 if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
1247                         if (sipdebug && option_debug > 3)
1248                                 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);
1249                 } else {
1250                         int siptimer_a;
1251
1252                         if (sipdebug && option_debug > 3)
1253                                 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
1254                         if (!pkt->timer_a)
1255                                 pkt->timer_a = 2 ;
1256                         else
1257                                 pkt->timer_a = 2 * pkt->timer_a;
1258
1259                         /* For non-invites, a maximum of 4 secs */
1260                         siptimer_a = pkt->timer_t1 * pkt->timer_a;      /* Double each time */
1261                         if (pkt->method != SIP_INVITE && siptimer_a > 4000)
1262                                 siptimer_a = 4000;
1263
1264                         /* Reschedule re-transmit */
1265                         reschedule = siptimer_a;
1266                         if (option_debug > 3)
1267                                 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);
1268                 }
1269
1270                 if (pkt->owner && sip_debug_test_pvt(pkt->owner)) {
1271                         if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
1272                                 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);
1273                         else
1274                                 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);
1275                 }
1276
1277                 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
1278                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
1279                 ast_mutex_unlock(&pkt->owner->lock);
1280                 return  reschedule;
1281         }
1282         /* Too many retries */
1283         if (pkt->owner && pkt->method != SIP_OPTIONS) {
1284                 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
1285                         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");
1286         } else {
1287                 if ((pkt->method == SIP_OPTIONS) && sipdebug)
1288                         ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
1289         }
1290         append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
1291
1292         pkt->retransid = -1;
1293
1294         if (ast_test_flag(pkt, FLAG_FATAL)) {
1295                 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
1296                         ast_mutex_unlock(&pkt->owner->lock);
1297                         usleep(1);
1298                         ast_mutex_lock(&pkt->owner->lock);
1299                 }
1300                 if (pkt->owner->owner) {
1301                         ast_set_flag(pkt->owner, SIP_ALREADYGONE);
1302                         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
1303                         ast_queue_hangup(pkt->owner->owner);
1304                         ast_mutex_unlock(&pkt->owner->owner->lock);
1305                 } else {
1306                         /* If no channel owner, destroy now */
1307                         ast_set_flag(pkt->owner, SIP_NEEDDESTROY);
1308                 }
1309         }
1310         /* In any case, go ahead and remove the packet */
1311         prev = NULL;
1312         cur = pkt->owner->packets;
1313         while(cur) {
1314                 if (cur == pkt)
1315                         break;
1316                 prev = cur;
1317                 cur = cur->next;
1318         }
1319         if (cur) {
1320                 if (prev)
1321                         prev->next = cur->next;
1322                 else
1323                         pkt->owner->packets = cur->next;
1324                 ast_mutex_unlock(&pkt->owner->lock);
1325                 free(cur);
1326                 pkt = NULL;
1327         } else
1328                 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
1329         if (pkt)
1330                 ast_mutex_unlock(&pkt->owner->lock);
1331         return 0;
1332 }
1333
1334 /*! \brief Transmit packet with retransmits
1335         \return 0 on success, -1 on failure to allocate packet
1336 */
1337 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
1338 {
1339         struct sip_pkt *pkt;
1340         int siptimer_a = DEFAULT_RETRANS;
1341
1342         if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
1343                 return -1;
1344         memcpy(pkt->data, data, len);
1345         pkt->method = sipmethod;
1346         pkt->packetlen = len;
1347         pkt->next = p->packets;
1348         pkt->owner = p;
1349         pkt->seqno = seqno;
1350         pkt->flags = resp;
1351         pkt->data[len] = '\0';
1352         pkt->timer_t1 = p->timer_t1;    /* Set SIP timer T1 */
1353         if (fatal)
1354                 ast_set_flag(pkt, FLAG_FATAL);
1355
1356         if (pkt->timer_t1)
1357                 siptimer_a = pkt->timer_t1 * 2;
1358
1359         /* Schedule retransmission */
1360         pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
1361         if (option_debug > 3 && sipdebug)
1362                 ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id  #%d\n", pkt->retransid);
1363         pkt->next = p->packets;
1364         p->packets = pkt;
1365
1366         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);      /* Send packet */
1367         if (sipmethod == SIP_INVITE) {
1368                 /* Note this is a pending invite */
1369                 p->pendinginvite = seqno;
1370         }
1371         return 0;
1372 }
1373
1374 /*! \brief Kill a SIP dialog (called by scheduler) */
1375 static int __sip_autodestruct(void *data)
1376 {
1377         struct sip_pvt *p = data;
1378
1379         /* If this is a subscription, tell the phone that we got a timeout */
1380         if (p->subscribed) {
1381                 p->subscribed = TIMEOUT;
1382                 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1); /* Send last notification */
1383                 p->subscribed = NONE;
1384                 append_history(p, "Subscribestatus", "timeout");
1385                 if (option_debug > 2)
1386                         ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
1387                 return 10000;   /* Reschedule this destruction so that we know that it's gone */
1388         }
1389
1390         /* Reset schedule ID */
1391         p->autokillid = -1;
1392
1393         if (option_debug)
1394                 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
1395         append_history(p, "AutoDestroy", "");
1396         if (p->owner) {
1397                 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
1398                 ast_queue_hangup(p->owner);
1399         } else {
1400                 sip_destroy(p);
1401         }
1402         return 0;
1403 }
1404
1405 /*! \brief Schedule destruction of SIP call */
1406 static int sip_scheddestroy(struct sip_pvt *p, int ms)
1407 {
1408         if (sip_debug_test_pvt(p))
1409                 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
1410         if (recordhistory)
1411                 append_history(p, "SchedDestroy", "%d ms", ms);
1412
1413         if (p->autokillid > -1)
1414                 ast_sched_del(sched, p->autokillid);
1415         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
1416         return 0;
1417 }
1418
1419 /*! \brief Cancel destruction of SIP dialog */
1420 static int sip_cancel_destroy(struct sip_pvt *p)
1421 {
1422         if (p->autokillid > -1)
1423                 ast_sched_del(sched, p->autokillid);
1424         append_history(p, "CancelDestroy", "");
1425         p->autokillid = -1;
1426         return 0;
1427 }
1428
1429 /*! \brief Acknowledges receipt of a packet and stops retransmission */
1430 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1431 {
1432         struct sip_pkt *cur, *prev = NULL;
1433         int res = -1;
1434
1435         /* Just in case... */
1436         char *msg;
1437
1438         msg = sip_methods[sipmethod].text;
1439
1440         ast_mutex_lock(&p->lock);
1441         cur = p->packets;
1442         while(cur) {
1443                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1444                         ((ast_test_flag(cur, FLAG_RESPONSE)) ||
1445                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1446                         if (!resp && (seqno == p->pendinginvite)) {
1447                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
1448                                 p->pendinginvite = 0;
1449                         }
1450                         /* this is our baby */
1451                         if (prev)
1452                                 prev->next = cur->next;
1453                         else
1454                                 p->packets = cur->next;
1455                         if (cur->retransid > -1) {
1456                                 if (sipdebug && option_debug > 3)
1457                                         ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
1458                                 ast_sched_del(sched, cur->retransid);
1459                         }
1460                         free(cur);
1461                         res = 0;
1462                         break;
1463                 }
1464                 prev = cur;
1465                 cur = cur->next;
1466         }
1467         ast_mutex_unlock(&p->lock);
1468         if (option_debug)
1469                 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
1470         return res;
1471 }
1472
1473 /*! \brief Pretend to ack all packets */
1474 static int __sip_pretend_ack(struct sip_pvt *p)
1475 {
1476         struct sip_pkt *cur=NULL;
1477
1478         while(p->packets) {
1479                 if (cur == p->packets) {
1480                         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
1481                         return -1;
1482                 }
1483                 cur = p->packets;
1484                 if (cur->method)
1485                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), cur->method);
1486                 else {  /* Unknown packet type */
1487                         char *c;
1488                         char method[128];
1489
1490                         ast_copy_string(method, p->packets->data, sizeof(method));
1491                         c = ast_skip_blanks(method); /* XXX what ? */
1492                         *c = '\0';
1493                         __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), find_sip_method(method));
1494                 }
1495         }
1496         return 0;
1497 }
1498
1499 /*! \brief Acks receipt of packet, keep it around (used for provisional responses) */
1500 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
1501 {
1502         struct sip_pkt *cur;
1503         int res = -1;
1504         char *msg = sip_methods[sipmethod].text;
1505
1506         cur = p->packets;
1507         while(cur) {
1508                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
1509                         ((ast_test_flag(cur, FLAG_RESPONSE)) ||
1510                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
1511                         /* this is our baby */
1512                         if (cur->retransid > -1) {
1513                                 if (option_debug > 3 && sipdebug)
1514                                         ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, msg);
1515                                 ast_sched_del(sched, cur->retransid);
1516                         }
1517                         cur->retransid = -1;
1518                         res = 0;
1519                         break;
1520                 }
1521                 cur = cur->next;
1522         }
1523         if (option_debug)
1524                 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");
1525         return res;
1526 }
1527
1528
1529 /*! \brief Copy SIP request, parse it */
1530 static void parse_copy(struct sip_request *dst, struct sip_request *src)
1531 {
1532         memset(dst, 0, sizeof(*dst));
1533         memcpy(dst->data, src->data, sizeof(dst->data));
1534         dst->len = src->len;
1535         parse_request(dst);
1536 }
1537
1538 /*! \brief Transmit response on SIP request*/
1539 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1540 {
1541         int res;
1542
1543         if (sip_debug_test_pvt(p)) {
1544                 char iabuf[INET_ADDRSTRLEN];
1545                 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1546                         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);
1547                 else
1548                         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);
1549         }
1550         if (recordhistory) {
1551                 struct sip_request tmp;
1552                 parse_copy(&tmp, req);
1553                 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1554         }
1555         res = (reliable) ?
1556                 __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
1557                 __sip_xmit(p, req->data, req->len);
1558         if (res > 0)
1559                 return 0;
1560         return res;
1561 }
1562
1563 /*! \brief Send SIP Request to the other part of the dialogue */
1564 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
1565 {
1566         int res;
1567
1568         if (sip_debug_test_pvt(p)) {
1569                 char iabuf[INET_ADDRSTRLEN];
1570                 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1571                         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);
1572                 else
1573                         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);
1574         }
1575         if (recordhistory) {
1576                 struct sip_request tmp;
1577                 parse_copy(&tmp, req);
1578                 append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1579         }
1580         res = (reliable) ?
1581                 __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method) :
1582                 __sip_xmit(p, req->data, req->len);
1583         return res;
1584 }
1585
1586 /*! \brief Pick out text in brackets from character string
1587         \return pointer to terminated stripped string
1588         \param tmp input string that will be modified */
1589 static char *get_in_brackets(char *tmp)
1590 {
1591         char *parse;
1592         char *first_quote;
1593         char *first_bracket;
1594         char *second_bracket;
1595         char last_char;
1596
1597         parse = tmp;
1598         while (1) {
1599                 first_quote = strchr(parse, '"');
1600                 first_bracket = strchr(parse, '<');
1601                 if (first_quote && first_bracket && (first_quote < first_bracket)) {
1602                         last_char = '\0';
1603                         for (parse = first_quote + 1; *parse; parse++) {
1604                                 if ((*parse == '"') && (last_char != '\\'))
1605                                         break;
1606                                 last_char = *parse;
1607                         }
1608                         if (!*parse) {
1609                                 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
1610                                 return tmp;
1611                         }
1612                         parse++;
1613                         continue;
1614                 }
1615                 if (first_bracket) {
1616                         second_bracket = strchr(first_bracket + 1, '>');
1617                         if (second_bracket) {
1618                                 *second_bracket = '\0';
1619                                 return first_bracket + 1;
1620                         } else {
1621                                 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1622                                 return tmp;
1623                         }
1624                 }
1625                 return tmp;
1626         }
1627 }
1628
1629 /*! \brief Send SIP MESSAGE text within a call
1630         Called from PBX core sendtext() application */
1631 static int sip_sendtext(struct ast_channel *ast, const char *text)
1632 {
1633         struct sip_pvt *p = ast->tech_pvt;
1634         int debug = sip_debug_test_pvt(p);
1635
1636         if (debug)
1637                 ast_verbose("Sending text %s on %s\n", text, ast->name);
1638         if (!p)
1639                 return -1;
1640         if (ast_strlen_zero(text))
1641                 return 0;
1642         if (debug)
1643                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1644         transmit_message_with_text(p, text);
1645         return 0;
1646 }
1647
1648 /*! \brief Update peer object in realtime storage */
1649 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
1650 {
1651         char port[10];
1652         char ipaddr[20];
1653         char regseconds[20];
1654         time_t nowtime;
1655
1656         time(&nowtime);
1657         nowtime += expirey;
1658         snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);   /* Expiration time */
1659         ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1660         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1661
1662         if (fullcontact)
1663                 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, "fullcontact", fullcontact, NULL);
1664         else
1665                 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1666 }
1667
1668 /*! \brief Automatically add peer extension to dial plan */
1669 static void register_peer_exten(struct sip_peer *peer, int onoff)
1670 {
1671         char multi[256];
1672         char *stringp, *ext;
1673         if (!ast_strlen_zero(regcontext)) {
1674                 ast_copy_string(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi));
1675                 stringp = multi;
1676                 while((ext = strsep(&stringp, "&"))) {
1677                         if (onoff)
1678                                 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop",
1679                                                   ast_strdup(peer->name), free, "SIP");
1680                         else
1681                                 ast_context_remove_extension(regcontext, ext, 1, NULL);
1682                 }
1683         }
1684 }
1685
1686 /*! \brief Destroy peer object from memory */
1687 static void sip_destroy_peer(struct sip_peer *peer)
1688 {
1689         if (option_debug > 2)
1690                 ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);
1691
1692         /* Delete it, it needs to disappear */
1693         if (peer->call)
1694                 sip_destroy(peer->call);
1695         if (peer->chanvars) {
1696                 ast_variables_destroy(peer->chanvars);
1697                 peer->chanvars = NULL;
1698         }
1699         if (peer->expire > -1)
1700                 ast_sched_del(sched, peer->expire);
1701         if (peer->pokeexpire > -1)
1702                 ast_sched_del(sched, peer->pokeexpire);
1703         register_peer_exten(peer, 0);
1704         ast_free_ha(peer->ha);
1705         if (ast_test_flag((&peer->flags_page2), SIP_PAGE2_SELFDESTRUCT))
1706                 apeerobjs--;
1707         else if (ast_test_flag(peer, SIP_REALTIME))
1708                 rpeerobjs--;
1709         else
1710                 speerobjs--;
1711         clear_realm_authentication(peer->auth);
1712         peer->auth = (struct sip_auth *) NULL;
1713         if (peer->dnsmgr)
1714                 ast_dnsmgr_release(peer->dnsmgr);
1715         free(peer);
1716 }
1717
1718 /*! \brief Update peer data in database (if used) */
1719 static void update_peer(struct sip_peer *p, int expiry)
1720 {
1721         int rtcachefriends = ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS);
1722         if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTUPDATE) &&
1723                 (ast_test_flag(p, SIP_REALTIME) || rtcachefriends)) {
1724                 realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
1725         }
1726 }
1727
1728
1729 /*! \brief  realtime_peer: Get peer from realtime storage
1730  * Checks the "sippeers" realtime family from extconfig.conf
1731  * \todo Consider adding check of port address when matching here to follow the same
1732  *      algorithm as for static peers. Will we break anything by adding that?
1733 */
1734 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1735 {
1736         struct sip_peer *peer = NULL;
1737         struct ast_variable *var;
1738         struct ast_variable *tmp;
1739         char *newpeername = (char *) peername;
1740         char iabuf[80];
1741
1742         /* First check on peer name */
1743         if (newpeername)
1744                 var = ast_load_realtime("sippeers", "name", peername, NULL);
1745         else if (sin) { /* Then check on IP address for dynamic peers */
1746                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1747                 var = ast_load_realtime("sippeers", "host", iabuf, NULL);       /* First check for fixed IP hosts */
1748                 if (!var)
1749                         var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);     /* Then check for registred hosts */
1750
1751         } else
1752                 return NULL;
1753
1754         if (!var)
1755                 return NULL;
1756
1757         for (tmp = var; tmp; tmp = tmp->next) {
1758                 /* If this is type=user, then skip this object. */
1759                 if (!strcasecmp(tmp->name, "type") &&
1760                     !strcasecmp(tmp->value, "user")) {
1761                         ast_variables_destroy(var);
1762                         return NULL;
1763                 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
1764                         newpeername = tmp->value;
1765                 }
1766         }
1767
1768         if (!newpeername) {     /* Did not find peer in realtime */
1769                 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
1770                 ast_variables_destroy(var);
1771                 return (struct sip_peer *) NULL;
1772         }
1773
1774         /* Peer found in realtime, now build it in memory */
1775         peer = build_peer(newpeername, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1776         if (!peer) {
1777                 ast_variables_destroy(var);
1778                 return (struct sip_peer *) NULL;
1779         }
1780
1781         if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1782                 /* Cache peer */
1783                 ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1784                 if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR)) {
1785                         if (peer->expire > -1) {
1786                                 ast_sched_del(sched, peer->expire);
1787                         }
1788                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1789                 }
1790                 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1791         } else {
1792                 ast_set_flag(peer, SIP_REALTIME);
1793         }
1794         ast_variables_destroy(var);
1795
1796         return peer;
1797 }
1798
1799 /*! \brief Support routine for find_peer */
1800 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1801 {
1802         /* We know name is the first field, so we can cast */
1803         struct sip_peer *p = (struct sip_peer *) name;
1804         return  !(!inaddrcmp(&p->addr, sin) ||
1805                                         (ast_test_flag(p, SIP_INSECURE_PORT) &&
1806                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1807 }
1808
1809 /*! \brief Locate peer by name or ip address
1810  *      This is used on incoming SIP message to find matching peer on ip
1811         or outgoing message to find matching peer on name */
1812 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1813 {
1814         struct sip_peer *p = NULL;
1815
1816         if (peer)
1817                 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
1818         else
1819                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);
1820
1821         if (!p && realtime) {
1822                 p = realtime_peer(peer, sin);
1823         }
1824         return p;
1825 }
1826
1827 /*! \brief Remove user object from in-memory storage */
1828 static void sip_destroy_user(struct sip_user *user)
1829 {
1830         if (option_debug > 2)
1831                 ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
1832         ast_free_ha(user->ha);
1833         if (user->chanvars) {
1834                 ast_variables_destroy(user->chanvars);
1835                 user->chanvars = NULL;
1836         }
1837         if (ast_test_flag(user, SIP_REALTIME))
1838                 ruserobjs--;
1839         else
1840                 suserobjs--;
1841         free(user);
1842 }
1843
1844 /*! \brief Load user from realtime storage
1845  * Loads user from "sipusers" category in realtime (extconfig.conf)
1846  * Users are matched on From: user name (the domain in skipped) */
1847 static struct sip_user *realtime_user(const char *username)
1848 {
1849         struct ast_variable *var;
1850         struct ast_variable *tmp;
1851         struct sip_user *user = NULL;
1852
1853         var = ast_load_realtime("sipusers", "name", username, NULL);
1854
1855         if (!var)
1856                 return NULL;
1857
1858         for (tmp = var; tmp; tmp = tmp->next) {
1859                 if (!strcasecmp(tmp->name, "type") &&
1860                         !strcasecmp(tmp->value, "peer")) {
1861                         ast_variables_destroy(var);
1862                         return NULL;
1863                 }
1864         }
1865
1866         user = build_user(username, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1867
1868         if (!user) {    /* No user found */
1869                 ast_variables_destroy(var);
1870                 return NULL;
1871         }
1872
1873         if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1874                 ast_set_flag((&user->flags_page2), SIP_PAGE2_RTCACHEFRIENDS);
1875                 suserobjs++;
1876                 ASTOBJ_CONTAINER_LINK(&userl,user);
1877         } else {
1878                 /* Move counter from s to r... */
1879                 suserobjs--;
1880                 ruserobjs++;
1881                 ast_set_flag(user, SIP_REALTIME);
1882         }
1883         ast_variables_destroy(var);
1884         return user;
1885 }
1886
1887 /*! \brief Locate user by name
1888  * Locates user by name (From: sip uri user name part) first
1889  * from in-memory list (static configuration) then from
1890  * realtime storage (defined in extconfig.conf) */
1891 static struct sip_user *find_user(const char *name, int realtime)
1892 {
1893         struct sip_user *u = NULL;
1894         u = ASTOBJ_CONTAINER_FIND(&userl,name);
1895         if (!u && realtime) {
1896                 u = realtime_user(name);
1897         }
1898         return u;
1899 }
1900
1901 /*! \brief Create address structure from peer reference */
1902 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
1903 {
1904         if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
1905             (!peer->maxms || ((peer->lastms >= 0)  && (peer->lastms <= peer->maxms)))) {
1906                 if (peer->addr.sin_addr.s_addr) {
1907                         r->sa.sin_family = peer->addr.sin_family;
1908                         r->sa.sin_addr = peer->addr.sin_addr;
1909                         r->sa.sin_port = peer->addr.sin_port;
1910                 } else {
1911                         r->sa.sin_family = peer->defaddr.sin_family;
1912                         r->sa.sin_addr = peer->defaddr.sin_addr;
1913                         r->sa.sin_port = peer->defaddr.sin_port;
1914                 }
1915                 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1916         } else {
1917                 return -1;
1918         }
1919
1920         ast_copy_flags(r, peer, SIP_FLAGS_TO_COPY);
1921         r->capability = peer->capability;
1922         r->prefs = peer->prefs;
1923         if (r->rtp) {
1924                 if (option_debug)
1925                         ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1926                 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1927         }
1928         if (r->vrtp) {
1929                 if (option_debug)
1930                         ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1931                 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1932         }
1933         ast_string_field_set(r, peername, peer->username);
1934         ast_string_field_set(r, authname, peer->username);
1935         ast_string_field_set(r, username, peer->username);
1936         ast_string_field_set(r, peersecret, peer->secret);
1937         ast_string_field_set(r, peermd5secret, peer->md5secret);
1938         ast_string_field_set(r, tohost, peer->tohost);
1939         ast_string_field_set(r, fullcontact, peer->fullcontact);
1940         if (!r->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
1941                 char *tmpcall;
1942                 char *c;
1943                 tmpcall = ast_strdupa(r->callid);
1944                 if (tmpcall) {
1945                         c = strchr(tmpcall, '@');
1946                         if (c) {
1947                                 *c = '\0';
1948                                 ast_string_field_build(r, callid, "%s@%s", tmpcall, peer->fromdomain);
1949                         }
1950                 }
1951         }
1952         if (ast_strlen_zero(r->tohost)) {
1953                 char iabuf[INET_ADDRSTRLEN];
1954
1955                 ast_inet_ntoa(iabuf, sizeof(iabuf),  peer->addr.sin_addr.s_addr ? peer->addr.sin_addr : peer->defaddr.sin_addr);
1956
1957                 ast_string_field_set(r, tohost, iabuf);
1958         }
1959         if (!ast_strlen_zero(peer->fromdomain))
1960                 ast_string_field_set(r, fromdomain, peer->fromdomain);
1961         if (!ast_strlen_zero(peer->fromuser))
1962                 ast_string_field_set(r, fromuser, peer->fromuser);
1963         r->maxtime = peer->maxms;
1964         r->callgroup = peer->callgroup;
1965         r->pickupgroup = peer->pickupgroup;
1966         /* Set timer T1 to RTT for this peer (if known by qualify=) */
1967         /* Minimum is settable or default to 100 ms */
1968         if (peer->maxms && peer->lastms)
1969                 r->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
1970         if ((ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833) || (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_AUTO))
1971                 r->noncodeccapability |= AST_RTP_DTMF;
1972         else
1973                 r->noncodeccapability &= ~AST_RTP_DTMF;
1974         ast_string_field_set(r, context, peer->context);
1975         r->rtptimeout = peer->rtptimeout;
1976         r->rtpholdtimeout = peer->rtpholdtimeout;
1977         r->rtpkeepalive = peer->rtpkeepalive;
1978         if (peer->call_limit)
1979                 ast_set_flag(r, SIP_CALL_LIMIT);
1980
1981         return 0;
1982 }
1983
1984 /*! \brief create address structure from peer name
1985  *      Or, if peer not found, find it in the global DNS
1986  *      returns TRUE (-1) on failure, FALSE on success */
1987 static int create_addr(struct sip_pvt *dialog, const char *opeer)
1988 {
1989         struct hostent *hp;
1990         struct ast_hostent ahp;
1991         struct sip_peer *p;
1992         int found=0;
1993         char *port;
1994         int portno;
1995         char host[MAXHOSTNAMELEN], *hostn;
1996         char peer[256];
1997
1998         ast_copy_string(peer, opeer, sizeof(peer));
1999         port = strchr(peer, ':');
2000         if (port) {
2001                 *port = '\0';
2002                 port++;
2003         }
2004         dialog->sa.sin_family = AF_INET;
2005         dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
2006         p = find_peer(peer, NULL, 1);
2007
2008         if (p) {
2009                 found++;
2010                 if (create_addr_from_peer(dialog, p))
2011                         ASTOBJ_UNREF(p, sip_destroy_peer);
2012         }
2013         if (!p) {
2014                 if (found)
2015                         return -1;
2016
2017                 hostn = peer;
2018                 if (port)
2019                         portno = atoi(port);
2020                 else
2021                         portno = DEFAULT_SIP_PORT;
2022                 if (srvlookup) {
2023                         char service[MAXHOSTNAMELEN];
2024                         int tportno;
2025                         int ret;
2026                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
2027                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
2028                         if (ret > 0) {
2029                                 hostn = host;
2030                                 portno = tportno;
2031                         }
2032                 }
2033                 hp = ast_gethostbyname(hostn, &ahp);
2034                 if (hp) {
2035                         ast_string_field_set(dialog, tohost, peer);
2036                         memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
2037                         dialog->sa.sin_port = htons(portno);
2038                         memcpy(&dialog->recv, &dialog->sa, sizeof(dialog->recv));
2039                         return 0;
2040                 } else {
2041                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
2042                         return -1;
2043                 }
2044         } else {
2045                 ASTOBJ_UNREF(p, sip_destroy_peer);
2046                 return 0;
2047         }
2048 }
2049
2050 /*! \brief Scheduled congestion on a call */
2051 static int auto_congest(void *nothing)
2052 {
2053         struct sip_pvt *p = nothing;
2054
2055         ast_mutex_lock(&p->lock);
2056         p->initid = -1;
2057         if (p->owner) {
2058                 if (!ast_mutex_trylock(&p->owner->lock)) {
2059                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
2060                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
2061                         ast_mutex_unlock(&p->owner->lock);
2062                 }
2063         }
2064         ast_mutex_unlock(&p->lock);
2065         return 0;
2066 }
2067
2068
2069
2070
2071 /*! \brief Initiate SIP call from PBX
2072  *      used from the dial() application      */
2073 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
2074 {
2075         int res;
2076         struct sip_pvt *p;
2077 #ifdef OSP_SUPPORT
2078         const char *osphandle = NULL;
2079 #endif
2080         struct varshead *headp;
2081         struct ast_var_t *current;
2082
2083         p = ast->tech_pvt;
2084         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
2085                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
2086                 return -1;
2087         }
2088
2089         /* Check whether there is vxml_url, distinctive ring variables */
2090         headp=&ast->varshead;
2091         AST_LIST_TRAVERSE(headp,current,entries) {
2092                 /* Check whether there is a VXML_URL variable */
2093                 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
2094                         p->options->vxml_url = ast_var_value(current);
2095                 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
2096                         p->options->uri_options = ast_var_value(current);
2097                 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
2098                         /* Check whether there is a ALERT_INFO variable */
2099                         p->options->distinctive_ring = ast_var_value(current);
2100                 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
2101                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
2102                         p->options->addsipheaders = 1;
2103                 }
2104
2105
2106 #ifdef OSP_SUPPORT
2107                 else if (!p->options->osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
2108                         p->options->osptoken = ast_var_value(current);
2109                 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
2110                         osphandle = ast_var_value(current);
2111                 }
2112 #endif
2113         }
2114
2115         res = 0;
2116         ast_set_flag(p, SIP_OUTGOING);
2117 #ifdef OSP_SUPPORT
2118         if (!p->options->osptoken || !osphandle || (sscanf(osphandle, "%d", &p->osphandle) != 1)) {
2119                 /* Force Disable OSP support */
2120                 if (option_debug)
2121                         ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", p->options->osptoken, osphandle);
2122                 p->options->osptoken = NULL;
2123                 osphandle = NULL;
2124                 p->osphandle = -1;
2125         }
2126 #endif
2127         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
2128         res = update_call_counter(p, INC_CALL_LIMIT);
2129         if ( res != -1 ) {
2130                 p->callingpres = ast->cid.cid_pres;
2131                 p->jointcapability = p->capability;
2132                 transmit_invite(p, SIP_INVITE, 1, 2);
2133                 if (p->maxtime) {
2134                         /* Initialize auto-congest time */
2135                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
2136                 }
2137         }
2138         return res;
2139 }
2140
2141 /*! \brief Destroy registry object
2142         Objects created with the register= statement in static configuration */
2143 static void sip_registry_destroy(struct sip_registry *reg)
2144 {
2145         /* Really delete */
2146         if (option_debug > 2)
2147                 ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
2148
2149         if (reg->call) {
2150                 /* Clear registry before destroying to ensure
2151                    we don't get reentered trying to grab the registry lock */
2152                 reg->call->registry = NULL;
2153                 if (option_debug > 2)
2154                         ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
2155                 sip_destroy(reg->call);
2156         }
2157         if (reg->expire > -1)
2158                 ast_sched_del(sched, reg->expire);
2159         if (reg->timeout > -1)
2160                 ast_sched_del(sched, reg->timeout);
2161         ast_string_field_free_all(reg);
2162         regobjs--;
2163         free(reg);
2164
2165 }
2166
2167 /*! \brief Execute destrucion of SIP dialog structure, release memory */
2168 static void __sip_destroy(struct sip_pvt *p, int lockowner)
2169 {
2170         struct sip_pvt *cur, *prev = NULL;
2171         struct sip_pkt *cp;
2172
2173         if (sip_debug_test_pvt(p) || option_debug > 2)
2174                 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
2175
2176         if (dumphistory)
2177                 sip_dump_history(p);
2178
2179         if (p->options)
2180                 free(p->options);
2181
2182         if (p->stateid > -1)
2183                 ast_extension_state_del(p->stateid, NULL);
2184         if (p->initid > -1)
2185                 ast_sched_del(sched, p->initid);
2186         if (p->autokillid > -1)
2187                 ast_sched_del(sched, p->autokillid);
2188
2189         if (p->rtp) {
2190                 ast_rtp_destroy(p->rtp);
2191         }
2192         if (p->vrtp) {
2193                 ast_rtp_destroy(p->vrtp);
2194         }
2195         if (p->route) {
2196                 free_old_route(p->route);
2197                 p->route = NULL;
2198         }
2199         if (p->registry) {
2200                 if (p->registry->call == p)
2201                         p->registry->call = NULL;
2202                 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
2203         }
2204
2205         /* Unlink us from the owner if we have one */
2206         if (p->owner) {
2207                 if (lockowner)
2208                         ast_mutex_lock(&p->owner->lock);
2209                 if (option_debug)
2210                         ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
2211                 p->owner->tech_pvt = NULL;
2212                 if (lockowner)
2213                         ast_mutex_unlock(&p->owner->lock);
2214         }
2215         /* Clear history */
2216         if (p->history) {
2217                 while(!AST_LIST_EMPTY(p->history)) {
2218                         struct sip_history *hist = AST_LIST_FIRST(p->history);
2219                         AST_LIST_REMOVE_HEAD(p->history, list);
2220                         free(hist);
2221                 }
2222                 free(p->history);
2223                 p->history = NULL;
2224         }
2225
2226         cur = iflist;
2227         while(cur) {
2228                 if (cur == p) {
2229                         if (prev)
2230                                 prev->next = cur->next;
2231                         else
2232                                 iflist = cur->next;
2233                         break;
2234                 }
2235                 prev = cur;
2236                 cur = cur->next;
2237         }
2238         if (!cur) {
2239                 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
2240                 return;
2241         }
2242         if (p->initid > -1)
2243                 ast_sched_del(sched, p->initid);
2244
2245         /* remove all current packets in this dialog */
2246         while((cp = p->packets)) {
2247                 p->packets = p->packets->next;
2248                 if (cp->retransid > -1) {
2249                         ast_sched_del(sched, cp->retransid);
2250                 }
2251                 free(cp);
2252         }
2253         if (p->chanvars) {
2254                 ast_variables_destroy(p->chanvars);
2255                 p->chanvars = NULL;
2256         }
2257         ast_mutex_destroy(&p->lock);
2258
2259         ast_string_field_free_all(p);
2260
2261         free(p);
2262 }
2263
2264 /*! \brief  update_call_counter: Handle call_limit for SIP users
2265  * Setting a call-limit will cause calls above the limit not to be accepted.
2266  *
2267  * Remember that for a type=friend, there's one limit for the user and
2268  * another for the peer, not a combined call limit.
2269  * This will cause unexpected behaviour in subscriptions, since a "friend"
2270  * is *two* devices in Asterisk, not one.
2271  *
2272  * Thought: For realtime, we should propably update storage with inuse counter...
2273  *
2274  * \return 0 if call is ok (no call limit, below treshold)
2275  *      -1 on rejection of call
2276  *
2277  */
2278 static int update_call_counter(struct sip_pvt *fup, int event)
2279 {
2280         char name[256];
2281         int *inuse, *call_limit;
2282         int outgoing = ast_test_flag(fup, SIP_OUTGOING);
2283         struct sip_user *u = NULL;
2284         struct sip_peer *p = NULL;
2285
2286         if (option_debug > 2)
2287                 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
2288         /* Test if we need to check call limits, in order to avoid
2289            realtime lookups if we do not need it */
2290         if (!ast_test_flag(fup, SIP_CALL_LIMIT))
2291                 return 0;
2292
2293         ast_copy_string(name, fup->username, sizeof(name));
2294
2295         /* Check the list of users */
2296         if (!outgoing)  /* Only check users for incoming calls */
2297                 u = find_user(name, 1);
2298
2299         if (u) {
2300                 inuse = &u->inUse;
2301                 call_limit = &u->call_limit;
2302                 p = NULL;
2303         } else {
2304                 /* Try to find peer */
2305                 if (!p)
2306                         p = find_peer(fup->peername, NULL, 1);
2307                 if (p) {
2308                         inuse = &p->inUse;
2309                         call_limit = &p->call_limit;
2310                         ast_copy_string(name, fup->peername, sizeof(name));
2311                 } else {
2312                         if (option_debug > 1)
2313                                 ast_log(LOG_DEBUG, "%s is not a local user, no call limit\n", name);
2314                         return 0;
2315                 }
2316         }
2317         switch(event) {
2318                 /* incoming and outgoing affects the inUse counter */
2319                 case DEC_CALL_LIMIT:
2320                         if ( *inuse > 0 ) {
2321                                 if (ast_test_flag(fup, SIP_INC_COUNT))
2322                                         (*inuse)--;
2323                         } else {
2324                                 *inuse = 0;
2325                         }
2326                         if (option_debug > 1 || sipdebug) {
2327                                 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
2328                         }
2329                         break;
2330                 case INC_CALL_LIMIT:
2331                         if (*call_limit > 0 ) {
2332                                 if (*inuse >= *call_limit) {
2333                                         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);
2334                                         if (u)
2335                                                 ASTOBJ_UNREF(u, sip_destroy_user);
2336                                         else
2337                                                 ASTOBJ_UNREF(p, sip_destroy_peer);
2338                                         return -1;
2339                                 }
2340                         }
2341                         (*inuse)++;
2342                         ast_set_flag(fup, SIP_INC_COUNT);
2343                         if (option_debug > 1 || sipdebug) {
2344                                 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
2345                         }
2346                         break;
2347                 default:
2348                         ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
2349         }
2350         if (u)
2351                 ASTOBJ_UNREF(u, sip_destroy_user);
2352         else
2353                 ASTOBJ_UNREF(p, sip_destroy_peer);
2354         return 0;
2355 }
2356
2357 /*! \brief Destroy SIP call structure */
2358 static void sip_destroy(struct sip_pvt *p)
2359 {
2360         ast_mutex_lock(&iflock);
2361         if (option_debug > 2)
2362                 ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
2363         __sip_destroy(p, 1);
2364         ast_mutex_unlock(&iflock);
2365 }
2366
2367 /*! \brief Convert SIP hangup causes to Asterisk hangup causes */
2368 static int hangup_sip2cause(int cause)
2369 {
2370         /* Possible values taken from causes.h */
2371
2372         switch(cause) {
2373                 case 401:       /* Unauthorized */
2374                         return AST_CAUSE_CALL_REJECTED;
2375                 case 403:       /* Not found */
2376                         return AST_CAUSE_CALL_REJECTED;
2377                 case 404:       /* Not found */
2378                         return AST_CAUSE_UNALLOCATED;
2379                 case 405:       /* Method not allowed */
2380                         return AST_CAUSE_INTERWORKING;
2381                 case 407:       /* Proxy authentication required */
2382                         return AST_CAUSE_CALL_REJECTED;
2383                 case 408:       /* No reaction */
2384                         return AST_CAUSE_NO_USER_RESPONSE;
2385                 case 409:       /* Conflict */
2386                         return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
2387                 case 410:       /* Gone */
2388                         return AST_CAUSE_UNALLOCATED;
2389                 case 411:       /* Length required */
2390                         return AST_CAUSE_INTERWORKING;
2391                 case 413:       /* Request entity too large */
2392                         return AST_CAUSE_INTERWORKING;
2393                 case 414:       /* Request URI too large */
2394                         return AST_CAUSE_INTERWORKING;
2395                 case 415:       /* Unsupported media type */
2396                         return AST_CAUSE_INTERWORKING;
2397                 case 420:       /* Bad extension */
2398                         return AST_CAUSE_NO_ROUTE_DESTINATION;
2399                 case 480:       /* No answer */
2400                         return AST_CAUSE_FAILURE;
2401                 case 481:       /* No answer */
2402                         return AST_CAUSE_INTERWORKING;
2403                 case 482:       /* Loop detected */
2404                         return AST_CAUSE_INTERWORKING;
2405                 case 483:       /* Too many hops */
2406                         return AST_CAUSE_NO_ANSWER;
2407                 case 484:       /* Address incomplete */
2408                         return AST_CAUSE_INVALID_NUMBER_FORMAT;
2409                 case 485:       /* Ambigous */
2410                         return AST_CAUSE_UNALLOCATED;
2411                 case 486:       /* Busy everywhere */
2412                         return AST_CAUSE_BUSY;
2413                 case 487:       /* Request terminated */
2414                         return AST_CAUSE_INTERWORKING;
2415                 case 488:       /* No codecs approved */
2416                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2417                 case 491:       /* Request pending */
2418                         return AST_CAUSE_INTERWORKING;
2419                 case 493:       /* Undecipherable */
2420                         return AST_CAUSE_INTERWORKING;
2421                 case 500:       /* Server internal failure */
2422                         return AST_CAUSE_FAILURE;
2423                 case 501:       /* Call rejected */
2424                         return AST_CAUSE_FACILITY_REJECTED;
2425                 case 502:
2426                         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2427                 case 503:       /* Service unavailable */
2428                         return AST_CAUSE_CONGESTION;
2429                 case 504:       /* Gateway timeout */
2430                         return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
2431                 case 505:       /* SIP version not supported */
2432                         return AST_CAUSE_INTERWORKING;
2433                 case 600:       /* Busy everywhere */
2434                         return AST_CAUSE_USER_BUSY;
2435                 case 603:       /* Decline */
2436                         return AST_CAUSE_CALL_REJECTED;
2437                 case 604:       /* Does not exist anywhere */
2438                         return AST_CAUSE_UNALLOCATED;
2439                 case 606:       /* Not acceptable */
2440                         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2441                 default:
2442                         return AST_CAUSE_NORMAL;
2443         }
2444         /* Never reached */
2445         return 0;
2446 }
2447
2448 /*! \brief Convert Asterisk hangup causes to SIP codes
2449 \verbatim
2450  Possible values from causes.h
2451         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
2452         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
2453
2454         In addition to these, a lot of PRI codes is defined in causes.h
2455         ...should we take care of them too ?
2456
2457         Quote RFC 3398
2458
2459    ISUP Cause value                        SIP response
2460    ----------------                        ------------
2461    1  unallocated number                   404 Not Found
2462    2  no route to network                  404 Not found
2463    3  no route to destination              404 Not found
2464    16 normal call clearing                 --- (*)
2465    17 user busy                            486 Busy here
2466    18 no user responding                   408 Request Timeout
2467    19 no answer from the user              480 Temporarily unavailable
2468    20 subscriber absent                    480 Temporarily unavailable
2469    21 call rejected                        403 Forbidden (+)
2470    22 number changed (w/o diagnostic)      410 Gone
2471    22 number changed (w/ diagnostic)       301 Moved Permanently
2472    23 redirection to new destination       410 Gone
2473    26 non-selected user clearing           404 Not Found (=)
2474    27 destination out of order             502 Bad Gateway
2475    28 address incomplete                   484 Address incomplete
2476    29 facility rejected                    501 Not implemented
2477    31 normal unspecified                   480 Temporarily unavailable
2478 \endverbatim
2479 */
2480 static char *hangup_cause2sip(int cause)
2481 {
2482         switch(cause)
2483         {
2484                 case AST_CAUSE_UNALLOCATED:             /* 1 */
2485                 case AST_CAUSE_NO_ROUTE_DESTINATION:    /* 3 IAX2: Can't find extension in context */
2486                 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:    /* 2 */
2487                         return "404 Not Found";
2488                 case AST_CAUSE_CONGESTION:              /* 34 */
2489                 case AST_CAUSE_SWITCH_CONGESTION:       /* 42 */
2490                         return "503 Service Unavailable";
2491                 case AST_CAUSE_NO_USER_RESPONSE:        /* 18 */
2492                         return "408 Request Timeout";
2493                 case AST_CAUSE_NO_ANSWER:               /* 19 */
2494                         return "480 Temporarily unavailable";
2495                 case AST_CAUSE_CALL_REJECTED:           /* 21 */
2496                         return "403 Forbidden";
2497                 case AST_CAUSE_NUMBER_CHANGED:          /* 22 */
2498                         return "410 Gone";
2499                 case AST_CAUSE_NORMAL_UNSPECIFIED:      /* 31 */
2500                         return "480 Temporarily unavailable";
2501                 case AST_CAUSE_INVALID_NUMBER_FORMAT:
2502                         return "484 Address incomplete";
2503                 case AST_CAUSE_USER_BUSY:
2504                         return "486 Busy here";
2505                 case AST_CAUSE_FAILURE:
2506                         return "500 Server internal failure";
2507                 case AST_CAUSE_FACILITY_REJECTED:       /* 29 */
2508                         return "501 Not Implemented";
2509                 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
2510                         return "503 Service Unavailable";
2511                 /* Used in chan_iax2 */
2512                 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
2513                         return "502 Bad Gateway";
2514                 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:       /* Can't find codec to connect to host */
2515                         return "488 Not Acceptable Here";
2516
2517                 case AST_CAUSE_NOTDEFINED:
2518                 default:
2519                         ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
2520                         return NULL;
2521         }
2522
2523         /* Never reached */
2524         return 0;
2525 }
2526
2527
2528 /*! \brief  sip_hangup: Hangup SIP call
2529  * Part of PBX interface, called from ast_hangup */
2530 static int sip_hangup(struct ast_channel *ast)
2531 {
2532         struct sip_pvt *p = ast->tech_pvt;
2533         int needcancel = FALSE;
2534         struct ast_flags locflags = {0};
2535
2536         if (!p) {
2537                 ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
2538                 return 0;
2539         }
2540         if (option_debug && sipdebug)
2541                 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
2542
2543         ast_mutex_lock(&p->lock);
2544 #ifdef OSP_SUPPORT
2545         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
2546                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
2547         }
2548 #endif
2549         if (option_debug && sipdebug)
2550                 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
2551         update_call_counter(p, DEC_CALL_LIMIT);
2552         /* Determine how to disconnect */
2553         if (p->owner != ast) {
2554                 ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
2555                 ast_mutex_unlock(&p->lock);
2556                 return 0;
2557         }
2558         /* If the call is not UP, we need to send CANCEL instead of BYE */
2559         if (ast->_state != AST_STATE_UP)
2560                 needcancel = TRUE;
2561
2562         /* Disconnect */
2563         p = ast->tech_pvt;
2564         if (p->vad)
2565                 ast_dsp_free(p->vad);
2566
2567         p->owner = NULL;
2568         ast->tech_pvt = NULL;
2569
2570         ast_mutex_lock(&usecnt_lock);
2571         usecnt--;
2572         ast_mutex_unlock(&usecnt_lock);
2573         ast_update_use_count();
2574
2575         ast_set_flag(&locflags, SIP_NEEDDESTROY);
2576
2577         /* Start the process if it's not already started */
2578         if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
2579                 if (needcancel) {       /* Outgoing call, not up */
2580                         if (ast_test_flag(p, SIP_OUTGOING)) {
2581                                 /* stop retransmitting an INVITE that has not received a response */
2582                                 __sip_pretend_ack(p);
2583
2584                                 /* Send a new request: CANCEL */
2585                                 transmit_request_with_auth(p, SIP_CANCEL, p->ocseq, XMIT_RELIABLE, 0);
2586                                 /* Actually don't destroy us yet, wait for the 487 on our original
2587                                    INVITE, but do set an autodestruct just in case we never get it. */
2588                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
2589
2590                                 sip_scheddestroy(p, 32000);
2591                                 if ( p->initid != -1 ) {
2592                                         /* channel still up - reverse dec of inUse counter
2593                                            only if the channel is not auto-congested */
2594                                         update_call_counter(p, INC_CALL_LIMIT);
2595                                 }
2596                         } else {        /* Incoming call, not up */
2597                                 char *res;
2598                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
2599                                         transmit_response_reliable(p, res, &p->initreq);
2600                                 } else
2601                                         transmit_response_reliable(p, "603 Declined", &p->initreq);
2602                         }
2603                 } else {        /* Call is in UP state, send BYE */
2604                         if (!p->pendinginvite) {
2605                                 /* Send a hangup */
2606                                 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
2607                         } else {
2608                                 /* Note we will need a BYE when this all settles out
2609                                    but we can't send one while we have "INVITE" outstanding. */
2610                                 ast_set_flag(p, SIP_PENDINGBYE);
2611                                 ast_clear_flag(p, SIP_NEEDREINVITE);
2612                         }
2613                 }
2614         }
2615         ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);
2616         ast_mutex_unlock(&p->lock);
2617         return 0;
2618 }
2619
2620 /*! \brief Try setting codec suggested by the SIP_CODEC channel variable */
2621 static void try_suggested_sip_codec(struct sip_pvt *p)
2622 {
2623         int fmt;
2624         const char *codec;
2625
2626         codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
2627         if (!codec)
2628                 return;
2629
2630         fmt = ast_getformatbyname(codec);
2631         if (fmt) {
2632                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n", codec);
2633                 if (p->jointcapability & fmt) {
2634                         p->jointcapability &= fmt;
2635                         p->capability &= fmt;
2636                 } else
2637                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
2638         } else
2639                 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
2640         return;
2641 }
2642
2643 /*! \brief  sip_answer: Answer SIP call , send 200 OK on Invite
2644  * Part of PBX interface */
2645 static int sip_answer(struct ast_channel *ast)
2646 {
2647         int res = 0;
2648         struct sip_pvt *p = ast->tech_pvt;
2649
2650         ast_mutex_lock(&p->lock);
2651         if (ast->_state != AST_STATE_UP) {
2652 #ifdef OSP_SUPPORT
2653                 time(&p->ospstart);
2654 #endif
2655                 try_suggested_sip_codec(p);
2656
2657                 ast_setstate(ast, AST_STATE_UP);
2658                 if (option_debug)
2659                         ast_log(LOG_DEBUG, "SIP answering channel: %s\n", ast->name);
2660                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_RELIABLE);
2661         }
2662         ast_mutex_unlock(&p->lock);
2663         return res;
2664 }
2665
2666 /*! \brief Send frame to media channel (rtp) */
2667 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
2668 {
2669         struct sip_pvt *p = ast->tech_pvt;
2670         int res = 0;
2671
2672         switch (frame->frametype) {
2673         case AST_FRAME_VOICE:
2674                 if (!(frame->subclass & ast->nativeformats)) {
2675                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
2676                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
2677                         return 0;
2678                 }
2679                 if (p) {
2680                         ast_mutex_lock(&p->lock);
2681                         if (p->rtp) {
2682                                 /* If channel is not up, activate early media session */
2683                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2684                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2685                                         ast_set_flag(p, SIP_PROGRESS_SENT);
2686                                 }
2687                                 time(&p->lastrtptx);
2688                                 res =  ast_rtp_write(p->rtp, frame);
2689                         }
2690                         ast_mutex_unlock(&p->lock);
2691                 }
2692                 break;
2693         case AST_FRAME_VIDEO:
2694                 if (p) {
2695                         ast_mutex_lock(&p->lock);
2696                         if (p->vrtp) {
2697                                 /* Activate video early media */
2698                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2699                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2700                                         ast_set_flag(p, SIP_PROGRESS_SENT);
2701                                 }
2702                                 time(&p->lastrtptx);
2703                                 res =  ast_rtp_write(p->vrtp, frame);
2704                         }
2705                         ast_mutex_unlock(&p->lock);
2706                 }
2707                 break;
2708         case AST_FRAME_IMAGE:
2709                 return 0;
2710                 break;
2711         default:
2712                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
2713                 return 0;
2714         }
2715
2716         return res;
2717 }
2718
2719 /*! \brief  sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
2720         Basically update any ->owner links */
2721 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2722 {
2723         struct sip_pvt *p = newchan->tech_pvt;
2724         ast_mutex_lock(&p->lock);
2725         if (p->owner != oldchan) {
2726                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
2727                 ast_mutex_unlock(&p->lock);
2728                 return -1;
2729         }
2730         p->owner = newchan;
2731         ast_mutex_unlock(&p->lock);
2732         return 0;
2733 }
2734
2735 /*! \brief Send DTMF character on SIP channel
2736         within one call, we're able to transmit in many methods simultaneously */
2737 static int sip_senddigit(struct ast_channel *ast, char digit)
2738 {
2739         struct sip_pvt *p = ast->tech_pvt;
2740         int res = 0;
2741
2742         ast_mutex_lock(&p->lock);
2743         switch (ast_test_flag(p, SIP_DTMF)) {
2744         case SIP_DTMF_INFO:
2745                 transmit_info_with_digit(p, digit);
2746                 break;
2747         case SIP_DTMF_RFC2833:
2748                 if (p->rtp)
2749                         ast_rtp_senddigit(p->rtp, digit);
2750                 break;
2751         case SIP_DTMF_INBAND:
2752                 res = -1;
2753                 break;
2754         }
2755         ast_mutex_unlock(&p->lock);
2756         return res;
2757 }
2758
2759 /*! \brief Transfer SIP call */
2760 static int sip_transfer(struct ast_channel *ast, const char *dest)
2761 {
2762         struct sip_pvt *p = ast->tech_pvt;
2763         int res;
2764
2765         ast_mutex_lock(&p->lock);
2766         if (ast->_state == AST_STATE_RING)
2767                 res = sip_sipredirect(p, dest);
2768         else
2769                 res = transmit_refer(p, dest);
2770         ast_mutex_unlock(&p->lock);
2771         return res;
2772 }
2773
2774 /*! \brief Play indication to user
2775  * With SIP a lot of indications is sent as messages, letting the device play
2776    the indication - busy signal, congestion etc
2777    \return -1 to force ast_indicate to send indication in audio, 0 if SIP can handle the indication by sending a message
2778 */
2779 static int sip_indicate(struct ast_channel *ast, int condition)
2780 {
2781         struct sip_pvt *p = ast->tech_pvt;
2782         int res = 0;
2783
2784         ast_mutex_lock(&p->lock);
2785         switch(condition) {
2786         case AST_CONTROL_RINGING:
2787                 if (ast->_state == AST_STATE_RING) {
2788                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2789                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2790                                 /* Send 180 ringing if out-of-band seems reasonable */
2791                                 transmit_response(p, "180 Ringing", &p->initreq);
2792                                 ast_set_flag(p, SIP_RINGING);
2793                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2794                                         break;
2795                         } else {
2796                                 /* Well, if it's not reasonable, just send in-band */
2797                         }
2798                 }
2799                 res = -1;
2800                 break;
2801         case AST_CONTROL_BUSY:
2802                 if (ast->_state != AST_STATE_UP) {
2803                         transmit_response(p, "486 Busy Here", &p->initreq);
2804                         ast_set_flag(p, SIP_ALREADYGONE);
2805                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2806                         break;
2807                 }
2808                 res = -1;
2809                 break;
2810         case AST_CONTROL_CONGESTION:
2811                 if (ast->_state != AST_STATE_UP) {
2812                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2813                         ast_set_flag(p, SIP_ALREADYGONE);
2814                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2815                         break;
2816                 }
2817                 res = -1;
2818                 break;
2819         case AST_CONTROL_PROCEEDING:
2820                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2821                         transmit_response(p, "100 Trying", &p->initreq);
2822                         break;
2823                 }
2824                 res = -1;
2825                 break;
2826         case AST_CONTROL_PROGRESS:
2827                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2828                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
2829                         ast_set_flag(p, SIP_PROGRESS_SENT);
2830                         break;
2831                 }
2832                 res = -1;
2833                 break;
2834         case AST_CONTROL_HOLD:  /* The other part of the bridge are put on hold */
2835                 if (sipdebug)
2836                         ast_log(LOG_DEBUG, "Bridged channel now on hold - %s\n", p->callid);
2837                 res = -1;
2838                 break;
2839         case AST_CONTROL_UNHOLD:        /* The other part of the bridge are back from hold */
2840                 if (sipdebug)
2841                         ast_log(LOG_DEBUG, "Bridged channel is back from hold, let's talk! : %s\n", p->callid);
2842                 res = -1;
2843                 break;
2844         case AST_CONTROL_VIDUPDATE:     /* Request a video frame update */
2845                 if (p->vrtp && !ast_test_flag(p, SIP_NOVIDEO)) {
2846                         transmit_info_with_vidupdate(p);
2847                         res = 0;
2848                 } else
2849                         res = -1;
2850                 break;
2851         case -1:
2852                 res = -1;
2853                 break;
2854         default:
2855                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2856                 res = -1;
2857                 break;
2858         }
2859         ast_mutex_unlock(&p->lock);
2860         return res;
2861 }
2862
2863
2864
2865 /*! \brief Initiate a call in the SIP channel
2866         called from sip_request_call (calls from the pbx ) */
2867 static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title)
2868 {
2869         struct ast_channel *tmp;
2870         struct ast_variable *v = NULL;
2871         int fmt;
2872         int what;
2873 #ifdef OSP_SUPPORT
2874         char iabuf[INET_ADDRSTRLEN];
2875         char peer[MAXHOSTNAMELEN];
2876 #endif
2877
2878         ast_mutex_unlock(&i->lock);
2879         /* Don't hold a sip pvt lock while we allocate a channel */
2880         tmp = ast_channel_alloc(1);
2881         ast_mutex_lock(&i->lock);
2882         if (!tmp) {
2883                 ast_log(LOG_WARNING, "Unable to allocate SIP channel structure\n");
2884                 return NULL;
2885         }
2886         tmp->tech = &sip_tech;
2887         /* Select our native format based on codec preference until we receive
2888            something from another device to the contrary. */
2889         if (i->jointcapability)
2890                 what = i->jointcapability;
2891         else if (i->capability)
2892                 what = i->capability;
2893         else
2894                 what = global_capability;
2895         tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | (i->jointcapability & AST_FORMAT_VIDEO_MASK);
2896         fmt = ast_best_codec(tmp->nativeformats);
2897
2898         if (title)
2899                 ast_string_field_build(tmp, name, "SIP/%s-%04x", title, thread_safe_rand() & 0xffff);
2900         else if (strchr(i->fromdomain,':'))
2901                 ast_string_field_build(tmp, name, "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2902         else
2903                 ast_string_field_build(tmp, name, "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2904
2905         if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2906                 i->vad = ast_dsp_new();
2907                 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2908                 if (global_relaxdtmf)
2909                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2910         }
2911         if (i->rtp) {
2912                 tmp->fds[0] = ast_rtp_fd(i->rtp);
2913                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2914         }
2915         if (i->vrtp) {
2916                 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2917                 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2918         }
2919         if (state == AST_STATE_RING)
2920                 tmp->rings = 1;
2921         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2922         tmp->writeformat = fmt;
2923         tmp->rawwriteformat = fmt;
2924         tmp->readformat = fmt;
2925         tmp->rawreadformat = fmt;
2926         tmp->tech_pvt = i;
2927
2928         tmp->callgroup = i->callgroup;
2929         tmp->pickupgroup = i->pickupgroup;
2930         tmp->cid.cid_pres = i->callingpres;
2931         if (!ast_strlen_zero(i->accountcode))
2932                 ast_string_field_set(tmp, accountcode, i->accountcode);
2933         if (i->amaflags)
2934                 tmp->amaflags = i->amaflags;
2935         if (!ast_strlen_zero(i->language))
2936                 ast_string_field_set(tmp, language, i->language);
2937         if (!ast_strlen_zero(i->musicclass))
2938                 ast_string_field_set(tmp, musicclass, i->musicclass);
2939         i->owner = tmp;
2940         ast_mutex_lock(&usecnt_lock);
2941         usecnt++;
2942         ast_mutex_unlock(&usecnt_lock);
2943         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
2944         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
2945         if (!ast_strlen_zero(i->cid_num))
2946                 tmp->cid.cid_num = ast_strdup(i->cid_num);
2947         if (!ast_strlen_zero(i->cid_name))
2948                 tmp->cid.cid_name = ast_strdup(i->cid_name);
2949         if (!ast_strlen_zero(i->rdnis))
2950                 tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
2951         if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2952                 tmp->cid.cid_dnid = ast_strdup(i->exten);
2953         tmp->priority = 1;
2954         if (!ast_strlen_zero(i->uri)) {
2955                 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2956         }
2957         if (!ast_strlen_zero(i->domain)) {
2958                 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2959         }
2960         if (!ast_strlen_zero(i->useragent)) {
2961                 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2962         }
2963         if (!ast_strlen_zero(i->callid)) {
2964                 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2965         }
2966 #ifdef OSP_SUPPORT
2967         snprintf(peer, sizeof(peer), "[%s]:%d", ast_inet_ntoa(iabuf, sizeof(iabuf), i->sa.sin_addr), ntohs(i->sa.sin_port));
2968         pbx_builtin_setvar_helper(tmp, "OSPPEER", peer);
2969 #endif
2970         ast_setstate(tmp, state);
2971         if (state != AST_STATE_DOWN) {
2972                 if (ast_pbx_start(tmp)) {
2973                         ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2974                         tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
2975                         ast_hangup(tmp);
2976                         tmp = NULL;
2977                 }
2978         }
2979         /* Set channel variables for this call from configuration */
2980         for (v = i->chanvars ; v ; v = v->next)
2981                 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2982
2983         return tmp;
2984 }
2985
2986 /*! \brief Reads one line of SIP message body */
2987 static char* get_sdp_by_line(char* line, char *name, int nameLen)
2988 {
2989         if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2990                 return ast_skip_blanks(line + nameLen + 1);
2991         }
2992         return "";
2993 }
2994
2995 /*! \brief Gets all kind of SIP message bodies, including SDP,
2996    but the name wrongly applies _only_ sdp */
2997 static char *get_sdp(struct sip_request *req, char *name)
2998 {
2999         int x;
3000         int len = strlen(name);
3001         char *r;
3002
3003         for (x = 0; x < req->lines; x++) {
3004                 r = get_sdp_by_line(req->line[x], name, len);
3005                 if (r[0] != '\0')
3006                         return r;
3007         }
3008         return "";
3009 }
3010
3011
3012 static void sdpLineNum_iterator_init(int* iterator)
3013 {
3014         *iterator = 0;
3015 }
3016
3017 static char* get_sdp_iterate(int* iterator,
3018                              struct sip_request *req, char *name)
3019 {
3020         int len = strlen(name);
3021         char *r;
3022
3023         while (*iterator < req->lines) {
3024                 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
3025                 if (r[0] != '\0')
3026                         return r;
3027         }
3028         return "";
3029 }
3030
3031 static char *find_alias(const char *name, char *_default)
3032 {
3033         int x;
3034         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
3035                 if (!strcasecmp(aliases[x].fullname, name))
3036                         return aliases[x].shortname;
3037         return _default;
3038 }
3039
3040 static char *__get_header(struct sip_request *req, const char *name, int *start)
3041 {
3042         int pass;
3043
3044         /*
3045          * Technically you can place arbitrary whitespace both before and after the ':' in
3046          * a header, although RFC3261 clearly says you shouldn't before, and place just
3047          * one afterwards.  If you shouldn't do it, what absolute idiot decided it was
3048          * a good idea to say you can do it, and if you can do it, why in the hell would.
3049          * you say you shouldn't.
3050          * Anyways, pedanticsipchecking c