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