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