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