channels/chan_sip.c

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