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