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