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