channels/chan_sip.c

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