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