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