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