channels/chan_sip.c

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