channels/chan_sip.c

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