/*--------------------------------------------------------------------*/
static int sip_patch_topvia(sip_ticket_t *ticket) {
osip_via_t *via;
if((via = osip_list_get(&(ticket->sipmsg->vias), 0)) != NULL) {
/* clone Via header */
/* set new IP (from IP) */
osip_free(via->host);
via->host=osip_malloc(IPSTRING_SIZE);
snprintf(via->host, IPSTRING_SIZE, "%s",
utils_inet_ntoa(ticket->from.sin_addr));
via->host[IPSTRING_SIZE-1] ='\0';
/* set new port number */
osip_free(via->port);
via->port=osip_malloc(6); /* 5 digits + \0 */
snprintf(via->port, 5, "%u", ntohs(ticket->from.sin_port));
via->port[5-1] ='\0';
DEBUGC(DBCLASS_PLUGIN, "plugin_fix_bogus_via: -> %s:%s",
via->host, via->port);
}
return STS_SUCCESS;
}
/*
* SIP_ADD_MYVIA
*
* interface == IF_OUTBOUND, IF_INBOUND
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*/
int sip_add_myvia (sip_ticket_t *ticket, int interface) {
struct in_addr addr;
char tmp[URL_STRING_SIZE];
osip_via_t *via;
int sts;
char branch_id[VIA_BRANCH_SIZE];
char *myaddr;
if (get_interface_ip(interface, &addr) != STS_SUCCESS) {
return STS_FAILURE;
}
sts = sip_calculate_branch_id(ticket, branch_id);
myaddr=utils_inet_ntoa(addr);
sprintf(tmp, "SIP/2.0/UDP %s:%i;branch=%s",
myaddr, configuration.sip_listen_port,
branch_id);
DEBUGC(DBCLASS_BABBLE,"adding VIA:%s",tmp);
sts = osip_via_init(&via);
if (sts!=0) return STS_FAILURE; /* allocation failed */
sts = osip_via_parse(via, tmp);
if (sts!=0) return STS_FAILURE;
osip_list_add(ticket->sipmsg->vias,via,0);
return STS_SUCCESS;
}
/*
* sends an UDP datagram to the specified destination
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*/
int sipsock_send(struct in_addr addr, int port, int protocol,
char *buffer, int size) {
struct sockaddr_in dst_addr;
int sts;
/* first time: allocate a socket for sending */
if (sip_udp_socket == 0) {
ERROR("SIP socket not allocated");
return STS_FAILURE;
}
if (buffer == NULL) {
ERROR("sipsock_send got NULL buffer");
return STS_FAILURE;
}
if (protocol != PROTO_UDP) {
ERROR("sipsock_send: only UDP supported by now");
return STS_FAILURE;
}
dst_addr.sin_family = AF_INET;
memcpy(&dst_addr.sin_addr.s_addr, &addr, sizeof(struct in_addr));
dst_addr.sin_port= htons(port);
DEBUGC(DBCLASS_NET,"send UDP packet to %s: %i", utils_inet_ntoa(addr),port);
DUMP_BUFFER(DBCLASS_NETTRAF, buffer, size);
sts = sendto(sip_udp_socket, buffer, size, 0,
(const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
if (sts == -1) {
if (errno != ECONNREFUSED) {
ERROR("sendto() [%s:%i size=%i] call failed: %s",
utils_inet_ntoa(addr),
port, size, strerror(errno));
return STS_FAILURE;
}
DEBUGC(DBCLASS_BABBLE,"sendto() [%s:%i] call failed: %s",
utils_inet_ntoa(addr), port, strerror(errno));
}
return STS_SUCCESS;
}
/*
* check if a given request is addressed to local. I.e. it is addressed
* to the proxy itself (IP of my inbound or outbound interface, same port)
*
* RETURNS
* STS_TRUE if the request is addressed local
* STS_FALSE otherwise
*/
int is_sipuri_local (sip_ticket_t *ticket) {
osip_message_t *sip=ticket->sipmsg;
int found;
struct in_addr addr_uri, addr_myself;
int port;
int i;
if (sip==NULL) {
ERROR("called is_sipuri_local with NULL sip");
return STS_FALSE;
}
if (!sip || !sip->req_uri) {
ERROR("is_sipuri_local: no request URI present");
return STS_FALSE;
}
DEBUGC(DBCLASS_DNS,"check for local SIP URI %s:%s",
sip->req_uri->host? sip->req_uri->host : "*NULL*",
sip->req_uri->port? sip->req_uri->port : "*NULL*");
if (utils_inet_aton(sip->req_uri->host, &addr_uri) == 0) {
/* need name resolution */
get_ip_by_host(sip->req_uri->host, &addr_uri);
}
found=0;
for (i=0; i<2; i++) {
/*
* search my in/outbound interfaces
*/
DEBUGC(DBCLASS_BABBLE,"resolving IP of interface %s",
(i==IF_INBOUND)? "inbound":"outbound");
if (get_interface_ip(i, &addr_myself) != STS_SUCCESS) {
continue;
}
/* check the extracted HOST against my own host addresses */
if (sip->req_uri->port) {
port=atoi(sip->req_uri->port);
} else {
port=SIP_PORT;
}
if ( (memcmp(&addr_myself, &addr_uri, sizeof(addr_myself))==0) &&
(port == configuration.sip_listen_port) ) {
DEBUG("address match [%s]", utils_inet_ntoa(addr_uri));
found=1;
break;
}
}
DEBUGC(DBCLASS_DNS, "SIP URI is %slocal", found? "":"not ");
return (found)? STS_TRUE : STS_FALSE;
}
/*
* read a message from SIP listen socket (UDP datagram)
*
* RETURNS number of bytes read
* from is modified to return the sockaddr_in of the sender
*/
int sipsock_read(int fd, void *buf, size_t bufsize,
struct sockaddr_in *from, int *protocol) {
int count;
socklen_t fromlen;
/* start of AU4D00875 by d00107688 to support bind 2008-10-15*/
if (fd < 0)
{
count = 0;
return count;
}
/* end of AU4D00875 by d00107688 to support bind 2008-10-15*/
fromlen=sizeof(struct sockaddr_in);
*protocol = PROTO_UDP; /* up to now, unly UDP */
#if 0
count=recvfrom(sip_udp_socket, buf, bufsize, 0,
(struct sockaddr *)from, &fromlen);
#else
/*BEGIN 3092906251 s00201037 2013-10-15 added*/
count=recvfrom(fd, buf, bufsize, 0,
from, &fromlen);
// count=recvfrom(fd, buf, bufsize, 0,
// (struct sockaddr *)from, &fromlen);
/*END 3092906251 s00201037 2013-10-15 added*/
#endif
if (count<0) {
WARN("recvfrom() returned error [%s]",strerror(errno));
*protocol = PROTO_UNKN;
}
DEBUGC(DBCLASS_NET,"received UDP packet from %s, count=%i",
utils_inet_ntoa(from->sin_addr), count);
DUMP_BUFFER(DBCLASS_NETTRAF, buf, count);
/*BEGIN 3092906251 s00201037 2013-10-15 added*/
lansrcport = 0;
lansrcport = ntohs(from->sin_port);
lansrcip = htonl(inet_addr(utils_inet_ntoa(from->sin_addr)));
/*END 3092906251 s00201037 2013-10-15 added*/
return count;
}
/*
* Should return with 0 on success.
* If return status is != 0, siproxd will complain with an
* an ERROR() but continue.
*/
int custom_fw_control(fw_ctl_t fwdata) {
static char tmp[256];
tmp[0]='\0';
switch (fwdata.action) {
case ACT_START_RTP:
strcat(tmp, "ACT_START_RTP: ");
break;
case ACT_STOP_RTP:
strcat(tmp, "ACT_STOP_RTP: ");
break;
default:
strcat(tmp, "ACT_unknown: ");
break;
}
switch (fwdata.direction) {
case DIR_IN:
strcat(tmp, "DIR_IN ");
break;
case DIR_OUT:
strcat(tmp, "DIR_OUT ");
break;
default:
strcat(tmp, "DIR_unknown ");
break;
}
sprintf(&tmp[strlen(tmp)],"[lcl %s:%i] ",
utils_inet_ntoa(fwdata.local_ipaddr),
fwdata.local_port);
sprintf(&tmp[strlen(tmp)],"[rem %s:%i] ",
utils_inet_ntoa(fwdata.remote_ipaddr),
fwdata.remote_port);
INFO("CUSTOM: %s", tmp);
return 0;
}
/*
* check if a given osip_via_t is local. I.e. its address is owned
* by my inbound or outbound interface
*
* RETURNS
* STS_TRUE if the given VIA is one of my interfaces
* STS_FALSE otherwise
*/
int is_via_local (osip_via_t *via) {
int sts, found;
struct in_addr addr_via, addr_myself;
int port;
int i;
if (via==NULL) {
ERROR("called is_via_local with NULL via");
return STS_FALSE;
}
DEBUGC(DBCLASS_BABBLE,"via name %s",via->host);
if (utils_inet_aton(via->host,&addr_via) == 0) {
/* need name resolution */
sts=get_ip_by_host(via->host, &addr_via);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_DNS, "is_via_local: cannot resolve VIA [%s]",
via->host);
return STS_FAILURE;
}
}
found=0;
for (i=0; i<2; i++) {
/*
* search my in/outbound interfaces
*/
DEBUGC(DBCLASS_BABBLE,"resolving IP of interface %s",
(i==IF_INBOUND)? "inbound":"outbound");
if (get_interface_ip(i, &addr_myself) != STS_SUCCESS) {
continue;
}
/* check the extracted VIA against my own host addresses */
if (via->port) port=atoi(via->port);
else port=SIP_PORT;
if ( (memcmp(&addr_myself, &addr_via, sizeof(addr_myself))==0) &&
(port == configuration.sip_listen_port) ) {
DEBUG("got address match [%s]", utils_inet_ntoa(addr_via));
found=1;
break;
}
}
return (found)? STS_TRUE : STS_FALSE;
}
/*
* SIP_ADD_MYVIA
*
* interface == IF_OUTBOUND, IF_INBOUND
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*/
int sip_add_myvia (sip_ticket_t *ticket, int interface,
struct in_addr *local_ip) {
struct in_addr addr;
char tmp[URL_STRING_SIZE] = {0};
osip_via_t *via;
int sts;
char branch_id[VIA_BRANCH_SIZE];
if (local_ip == NULL) {
if (interface == IF_OUTBOUND) {
if (get_ip_by_ifname(configuration.outbound_if, &addr) != STS_SUCCESS) {
ERROR("can't find interface %s - configuration error?",
configuration.outbound_if);
return STS_FAILURE;
}
} else {
if (get_ip_by_ifname(configuration.inbound_if, &addr) != STS_SUCCESS) {
ERROR("can't find inbound interface %s - configuration error?",
configuration.inbound_if);
return STS_FAILURE;
}
}
} else {
addr = *local_ip;
}
sts = sip_calculate_branch_id(ticket, branch_id);
snprintf(tmp,URL_STRING_SIZE, "SIP/2.0/UDP %s:%i;branch=%s;", utils_inet_ntoa(addr),
configuration.sip_listen_port, branch_id);
DEBUGC(DBCLASS_BABBLE,"adding VIA:%s",tmp);
sts = osip_via_init(&via);
if (sts!=0) return STS_FAILURE; /* allocation failed */
sts = osip_via_parse(via, tmp);
if (sts!=0) return STS_FAILURE;
osip_list_add(ticket->sipmsg->vias,via,0);
return STS_SUCCESS;
}
/*
* compare_client_id:
* Compares two client_id_t structures. If both have the Contact item
* defined (not NULL), then compare it and return.
* If one (or both) do NOT have the contact item defined, then
* fall back on comparing the from_ip (IP address).
*
* returns:
* STS_SUCCESS on match
* STS_FAILURE on no match
*/
int compare_client_id(client_id_t cid1, client_id_t cid2) {
/* Prio 1: Contact - if present in both structures */
if ((cid1.idstring[0] != '\0') && (cid2.idstring[0] != '\0')) {
if (strncmp(cid1.idstring, cid2.idstring, CLIENT_ID_SIZE) == 0) {
DEBUGC(DBCLASS_BABBLE, "compare_client_id: contact match [%s]",
cid1.idstring);
return STS_SUCCESS;
}
DEBUGC(DBCLASS_BABBLE, "compare_client_id: contact NO match [%s<->%s]",
cid1.idstring, cid2.idstring);
return STS_FAILURE;
}
/* Prio 2: IP (always present) - fallback, if no ID string present. */
if (memcmp(&cid1.from_ip, &cid2.from_ip, sizeof(struct in_addr)) == 0) {
DEBUGC(DBCLASS_BABBLE, "compare_client_id: IP match [%s]",
utils_inet_ntoa(cid1.from_ip));
return STS_SUCCESS;
}
DEBUGC(DBCLASS_BABBLE, "compare_client_id: no match");
return STS_FAILURE;
}
/*
* resolve a hostname and return in_addr
* handles its own little DNS cache.
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on failure
*/
int get_ip_by_host(char *hostname, struct in_addr *addr) {
int i, j, k, idx;
time_t t1, t2;
struct hostent *hostentry;
#if defined(HAVE_GETHOSTBYNAME_R)
struct hostent result_buffer;
char tmp[GETHOSTBYNAME_BUFLEN];
#endif
int error;
static struct {
time_t expires_timestamp; /* time of expiration */
struct in_addr addr; /* IP address or 0.0.0.0 if a bad entry */
char error_count; /* counts failed resolution attempts */
char bad_entry; /* != 0 if resolving failed */
char hostname[HOSTNAME_SIZE+1];
} dns_cache[DNS_CACHE_SIZE];
static int cache_initialized=0;
if (hostname == NULL) {
ERROR("get_ip_by_host: NULL hostname requested");
return STS_FAILURE;
}
if (addr == NULL) {
ERROR("get_ip_by_host: NULL in_addr passed");
return STS_FAILURE;
}
/* first time: initialize DNS cache */
if (cache_initialized == 0) {
DEBUGC(DBCLASS_DNS, "initializing DNS cache (%i entries)", DNS_CACHE_SIZE);
memset(dns_cache, 0, sizeof(dns_cache));
cache_initialized=1;
}
time(&t1);
/* clean expired entries */
for (i=0; i<DNS_CACHE_SIZE; i++) {
if (dns_cache[i].hostname[0]=='\0') continue;
if ( (dns_cache[i].expires_timestamp) < t1 ) {
DEBUGC(DBCLASS_DNS, "cleaning DNS cache (entry %i)", i);
memset (&dns_cache[i], 0, sizeof(dns_cache[0]));
}
}
/*
* search requested entry in cache
*/
idx=0;
for (i=0; i<DNS_CACHE_SIZE; i++) {
if (dns_cache[i].hostname[0]=='\0') continue; /* empty */
if (strcasecmp(hostname, dns_cache[i].hostname) == 0) { /* match */
memcpy(addr, &dns_cache[i].addr, sizeof(struct in_addr));
if (dns_cache[i].bad_entry) {
DEBUGC(DBCLASS_DNS, "DNS lookup - blacklisted from cache: %s",
hostname);
return STS_FAILURE;
}
if (dns_cache[i].error_count > 0) {
DEBUGC(DBCLASS_DNS, "DNS lookup - previous resolution failed: %s"
", attempt %i", hostname, dns_cache[i].error_count);
idx=i;
break;
}
DEBUGC(DBCLASS_DNS, "DNS lookup - from cache: %s -> %s",
hostname, utils_inet_ntoa(*addr));
return STS_SUCCESS;
}
}
/* I did not find it in cache, so I have to resolve it */
error = 0;
/* need to deal with reentrant versions of gethostbyname_r()
* as we may use threads... */
#if defined(HAVE_GETHOSTBYNAME_R)
/* gethostbyname_r() with 3 arguments (e.g. osf/1) */
#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
gethostbyname_r(hostname, /* the FQDN */
&result_buffer, /* the result buffer */
&hostentry
);
if (hostentry == NULL) error = h_errno;
/* gethostbyname_r() with 5 arguments (e.g. solaris, linux libc5) */
#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
hostentry = gethostbyname_r(hostname, /* the FQDN */
&result_buffer, /* the result buffer */
tmp,
GETHOSTBYNAME_BUFLEN,
&error);
/* gethostbyname_r() with 6 arguments (e.g. linux glibc) */
#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
gethostbyname_r(hostname, /* the FQDN */
&result_buffer, /* the result buffer */
tmp,
GETHOSTBYNAME_BUFLEN,
&hostentry,
&error);
#else
#error "gethostbyname_r() with 3, 5 or 6 arguments supported only"
#endif
#elif defined(HAVE_GETHOSTBYNAME)
hostentry=gethostbyname(hostname);
if (hostentry == NULL) error = h_errno;
#else
#error "need gethostbyname() or gethostbyname_r()"
#endif
/* Here I have 'hostentry' and 'error' */
if (hostentry==NULL) {
/*
* Some errors just tell us that there was no IP resolvable.
* From the manpage:
* HOST_NOT_FOUND
* The specified host is unknown.
* NO_ADDRESS or NO_DATA
* The requested name is valid but does not have an IP
* address.
*/
if ((error == HOST_NOT_FOUND) ||
(error == NO_ADDRESS) ||
(error == NO_DATA)) {
#ifdef HAVE_HSTRERROR
DEBUGC(DBCLASS_DNS, "gethostbyname(%s) failed: h_errno=%i [%s]",
hostname, h_errno, hstrerror(error));
#else
DEBUGC(DBCLASS_DNS, "gethostbyname(%s) failed: h_errno=%i",
hostname, error);
#endif
} else {
#ifdef HAVE_HSTRERROR
ERROR("gethostbyname(%s) failed: h_errno=%i [%s]",
hostname, h_errno, hstrerror(h_errno));
#else
ERROR("gethostbyname(%s) failed: h_errno=%i",hostname, h_errno);
#endif
}
}
if (hostentry) {
memcpy(addr, hostentry->h_addr, sizeof(struct in_addr));
DEBUGC(DBCLASS_DNS, "DNS lookup - resolved: %s -> %s",
hostname, utils_inet_ntoa(*addr));
}
/* if we already have the entry, skip finding a new empty one */
if (idx == 0) {
/*
* find an empty slot in the cache
*/
j=0;
k=0;
t1=INT_MAX;
t2=INT_MAX;
for (i=0; i<DNS_CACHE_SIZE; i++) {
if (dns_cache[i].hostname[0]=='\0') break;
if ((dns_cache[i].expires_timestamp < t1) &&
(dns_cache[i].bad_entry == 0)) {
/* remember oldest good entry */
t1=dns_cache[i].expires_timestamp;
j=i;
} else
if (dns_cache[i].expires_timestamp < t2) {
/* remember oldest bad entry */
t2=dns_cache[i].expires_timestamp;
k=i;
}
}
/* if no empty slot found, victimize oldest one.
* Give preference to the oldest "bad" entry if
* one exists */
if (i >= DNS_CACHE_SIZE) {
if (k > 0) i=k;
else i=j;
}
idx=i;
memset(&dns_cache[idx], 0, sizeof(dns_cache[0]));
}
/*
* store the result in the cache
*/
DEBUGC(DBCLASS_DNS, "DNS lookup - store into cache, entry %i)", idx);
strncpy(dns_cache[idx].hostname, hostname, HOSTNAME_SIZE);
dns_cache[idx].expires_timestamp = time(NULL) + DNS_GOOD_AGE;
if (hostentry) {
memcpy(&dns_cache[idx].addr, addr, sizeof(struct in_addr));
dns_cache[idx].error_count = 0;
dns_cache[idx].bad_entry = 0;
} else {
dns_cache[idx].error_count++;
DEBUGC(DBCLASS_DNS, "DNS lookup - errcnt=%i", dns_cache[idx].error_count);
if (dns_cache[idx].error_count >= DNS_ATTEMPTS) {
DEBUGC(DBCLASS_DNS, "DNS lookup - blacklisting entry");
dns_cache[idx].expires_timestamp = time(NULL) + DNS_BAD_AGE;
dns_cache[idx].bad_entry = 1;
}
return STS_FAILURE;
}
return STS_SUCCESS;
}
/*
* handles register requests and updates the URL mapping table
*
* RETURNS:
* STS_SUCCESS : successfully registered
* STS_FAILURE : registration failed
* STS_NEED_AUTH : authentication needed
*/
int register_client(sip_ticket_t *ticket, int force_lcl_masq) {
int i, j, n, sts;
int expires;
time_t time_now;
osip_contact_t *contact;
osip_uri_t *url1_to, *url1_contact=NULL;
osip_uri_t *url2_to;
osip_header_t *expires_hdr;
osip_uri_param_t *expires_param=NULL;
/*
* Authorization - do only if I'm not just acting as outbound proxy
* but am ment to be the registrar
*/
if (force_lcl_masq == 0) {
/*
* RFC 3261, Section 16.3 step 6
* Proxy Behavior - Request Validation - Proxy-Authorization
*/
sts = authenticate_proxy(ticket->sipmsg);
if (sts == STS_FAILURE) {
/* failed */
WARN("proxy authentication failed for %s@%s",
(ticket->sipmsg->to->url->username)?
ticket->sipmsg->to->url->username : "******",
ticket->sipmsg->to->url->host);
return STS_FAILURE;
} else if (sts == STS_NEED_AUTH) {
/* needed */
DEBUGC(DBCLASS_REG,"proxy authentication needed for %s@%s",
ticket->sipmsg->to->url->username,
ticket->sipmsg->to->url->host);
return STS_NEED_AUTH;
}
}
/*
fetch 1st Via entry and remember this address. Incoming requests
for the registered address have to be passed on to that host.
To: -> address to be registered
Contact: -> host is reachable there
Note: in case of un-REGISTER, the contact header may
contain '*' only - which means "all registrations
made by this UA"
=> Mapping is
To: <1--n> Contact
*/
time(&time_now);
DEBUGC(DBCLASS_BABBLE,"sip_register:");
/*
* First make sure, we have a proper Contact header:
* - url
* - url -> hostname
*
* Libosip parses an:
* "Contact: *"
* the following way (Note: Display name!! and URL is NULL)
* (gdb) p *((osip_contact_t*)(sip->contacts.node->element))
* $5 = {displayname = 0x8af8848 "*", url = 0x0, gen_params = 0x8af8838}
*/
osip_message_get_contact(ticket->sipmsg, 0, &contact);
if ((contact == NULL) ||
(contact->url == NULL) ||
(contact->url->host == NULL)) {
/* Don't have required Contact fields.
This may be a Registration query or unregistering all registered
records for this UA. We should simply forward this request to its
destination. However, if this is an unregistration from a client
that is not registered (Grandstream "unregister at startup" option)
-> How do I handle this one?
Right now we do a direction lookup and if this fails we generate
an OK message by ourself (fake) */
DEBUGC(DBCLASS_REG, "empty Contact header - "
"seems to be a registration query");
sts = sip_find_direction(ticket, NULL);
if (sts != STS_SUCCESS) {
/* answer the request myself. Most likely this is an UNREGISTER
* request when the client just booted */
sts = register_response(ticket, STS_SUCCESS);
return STS_SIP_SENT;
}
return STS_SUCCESS;
}
url1_contact=contact->url;
/* evaluate Expires Header field */
osip_message_get_expires(ticket->sipmsg, 0, &expires_hdr);
/*
* look for an Contact expires parameter - in case of REGISTER
* these two are equal. The Contact expires has higher priority!
*/
if (ticket->sipmsg->contacts.node &&
ticket->sipmsg->contacts.node->element) {
osip_contact_param_get_byname(
(osip_contact_t*) ticket->sipmsg->contacts.node->element,
EXPIRES, &expires_param);
}
if (expires_param && expires_param->gvalue) {
/* get expires from contact Header */
expires=atoi(expires_param->gvalue);
if ((expires < 0) || (expires >= UINT_MAX ))
expires=configuration.default_expires;
} else if (expires_hdr && expires_hdr->hvalue) {
/* get expires from expires Header */
expires=atoi(expires_hdr->hvalue);
if ((expires < 0) || (expires >= UINT_MAX ))
expires=configuration.default_expires;
} else {
char tmp[16];
/* it seems, the expires field is not present everywhere... */
DEBUGC(DBCLASS_REG,"no 'expires' header found - set time to %i sec",
configuration.default_expires);
expires=configuration.default_expires;
sprintf(tmp,"%i",expires);
osip_message_set_expires(ticket->sipmsg, tmp);
}
url1_to=ticket->sipmsg->to->url;
/*
* REGISTER
*/
if (expires > 0) {
DEBUGC(DBCLASS_REG,"register: %s@%s expires=%i seconds",
(url1_contact->username) ? url1_contact->username : "******",
(url1_contact->host) ? url1_contact->host : "*NULL*",
expires);
/*
* Update registration. There are two possibilities:
* - already registered, then update the existing record
* - not registered, then create a new record
*/
j=-1;
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) {
if (j < 0) j=i; /* remember first hole */
continue;
}
url2_to=urlmap[i].reg_url;
/* check address-of-record ("public address" of user) */
if (compare_url(url1_to, url2_to)==STS_SUCCESS) {
DEBUGC(DBCLASS_REG, "found entry for %s@%s <-> %s@%s at "
"slot=%i, exp=%li",
(url1_contact->username) ? url1_contact->username : "******",
(url1_contact->host) ? url1_contact->host : "*NULL*",
(url2_to->username) ? url2_to->username : "******",
(url2_to->host) ? url2_to->host : "*NULL*",
i, (long)urlmap[i].expires-time_now);
break;
}
}
if ( (j < 0) && (i >= URLMAP_SIZE) ) {
/* oops, no free entries left... */
ERROR("URLMAP is full - registration failed");
return STS_FAILURE;
}
if (i >= URLMAP_SIZE) {
/* entry not existing, create new one */
i=j;
/* write entry */
urlmap[i].active=1;
/* Contact: field */
osip_uri_clone( ((osip_contact_t*)
(ticket->sipmsg->contacts.node->element))->url,
&urlmap[i].true_url);
/* To: field */
osip_uri_clone( ticket->sipmsg->to->url,
&urlmap[i].reg_url);
DEBUGC(DBCLASS_REG,"create new entry for %s@%s <-> %s@%s at slot=%i",
(url1_contact->username) ? url1_contact->username : "******",
(url1_contact->host) ? url1_contact->host : "*NULL*",
(urlmap[i].reg_url->username) ? urlmap[i].reg_url->username : "******",
(urlmap[i].reg_url->host) ? urlmap[i].reg_url->host : "*NULL*",
i);
/*
* try to figure out if we ought to do some masquerading
*/
osip_uri_clone( ticket->sipmsg->to->url,
&urlmap[i].masq_url);
n=configuration.mask_host.used;
if (n != configuration.masked_host.used) {
ERROR("# of mask_host is not equal to # of masked_host in config!");
n=0;
}
DEBUG("%i entries in MASK config table", n);
for (j=0; j<n; j++) {
DEBUG("compare [%s] <-> [%s]",configuration.mask_host.string[j],
ticket->sipmsg->to->url->host);
if (strcmp(configuration.mask_host.string[j],
ticket->sipmsg->to->url->host)==0)
break;
}
if (j<n) {
/* we are masquerading this UA, replace the host part of the url */
DEBUGC(DBCLASS_REG,"masquerading UA %s@%s as %s@%s",
(url1_contact->username) ? url1_contact->username : "******",
(url1_contact->host) ? url1_contact->host : "*NULL*",
(url1_contact->username) ? url1_contact->username : "******",
configuration.masked_host.string[j]);
urlmap[i].masq_url->host=realloc(urlmap[i].masq_url->host,
strlen(configuration.masked_host.string[j])+1);
strcpy(urlmap[i].masq_url->host, configuration.masked_host.string[j]);
}
} else { /* if new entry */
/* This is an existing entry */
/*
* Some phones (like BudgeTones *may* dynamically grab a SIP port
* so we might want to update the true_url and reg_url each time
* we get an REGISTER
*/
/* Contact: field (true_url) */
osip_uri_free(urlmap[i].true_url);
osip_uri_clone( ((osip_contact_t*)
(ticket->sipmsg->contacts.node->element))->url,
&urlmap[i].true_url);
/* To: field (reg_url) */
osip_uri_free(urlmap[i].reg_url);
osip_uri_clone( ticket->sipmsg->to->url,
&urlmap[i].reg_url);
}
/*
* for proxying: force device to be masqueraded
* as with the outbound IP (masq_url)
*/
if (force_lcl_masq) {
struct in_addr addr;
char *addrstr;
if (get_interface_ip(IF_OUTBOUND, &addr) != STS_SUCCESS) {
return STS_FAILURE;
}
/* host part */
addrstr = utils_inet_ntoa(addr);
DEBUGC(DBCLASS_REG,"masquerading UA %s@%s local %s@%s",
(url1_contact->username) ? url1_contact->username : "******",
(url1_contact->host) ? url1_contact->host : "*NULL*",
(url1_contact->username) ? url1_contact->username : "******",
addrstr);
urlmap[i].masq_url->host=realloc(urlmap[i].masq_url->host,
strlen(addrstr)+1);
strcpy(urlmap[i].masq_url->host, addrstr);
/* port number if required */
if (configuration.sip_listen_port != SIP_PORT) {
urlmap[i].masq_url->port=realloc(urlmap[i].masq_url->port, 16);
sprintf(urlmap[i].masq_url->port, "%i",
configuration.sip_listen_port);
}
}
/* give some safety margin for the next update */
if (expires > 0) expires+=30;
/* update registration timeout */
urlmap[i].expires=time_now+expires;
/*
* un-REGISTER
*/
} else { /* expires > 0 */
/*
* Remove registration
* Siproxd will ALWAYS remove ALL bindings for a given
* address-of-record
*/
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
url2_to=urlmap[i].reg_url;
if (compare_url(url1_to, url2_to)==STS_SUCCESS) {
DEBUGC(DBCLASS_REG, "removing registration for %s@%s at slot=%i",
(url2_to->username) ? url2_to->username : "******",
(url2_to->host) ? url2_to->host : "*NULL*", i);
urlmap[i].expires=0;
break;
}
}
}
return STS_SUCCESS;
}
/*
* get_ip_by_ifname:
* fetches own IP address by its interface name
*
* STS_SUCCESS on returning a valid IP and interface is UP
* STS_FAILURE if interface is DOWN or other problem
*/
int get_ip_by_ifname(char *ifname, struct in_addr *retaddr) {
struct in_addr ifaddr; /* resulting IP */
int i, j;
int ifflags=0, isup=0;
time_t t;
static struct {
time_t timestamp;
struct in_addr ifaddr; /* IP */
int isup; /* interface is UP */
char ifname[IFNAME_SIZE+1];
} ifaddr_cache[IFADR_CACHE_SIZE];
static int cache_initialized=0;
#ifdef HAVE_GETIFADDRS
struct ifaddrs *ifa;
struct ifaddrs *ifa_list;
#else
struct ifreq ifr;
struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
int sockfd;
#endif
if (ifname == NULL) {
WARN("get_ip_by_ifname: got NULL ifname passed - please check config"
"file ('if_inbound' and 'if_outbound')");
return STS_FAILURE;
}
/* first time: initialize ifaddr cache */
if (cache_initialized == 0) {
DEBUGC(DBCLASS_DNS, "initializing ifaddr cache (%i entries)",
IFADR_CACHE_SIZE);
memset(ifaddr_cache, 0, sizeof(ifaddr_cache));
cache_initialized=1;
}
if (retaddr) memset(retaddr, 0, sizeof(struct in_addr));
time(&t);
/* clean expired entries */
for (i=0; i<IFADR_CACHE_SIZE; i++) {
if (ifaddr_cache[i].ifname[0]=='\0') continue;
if ( (ifaddr_cache[i].timestamp+IFADR_MAX_AGE) < t ) {
DEBUGC(DBCLASS_DNS, "cleaning ifaddr cache (entry %i)", i);
memset (&ifaddr_cache[i], 0, sizeof(ifaddr_cache[0]));
}
}
/*
* search requested entry in cache
*/
for (i=0; i<IFADR_CACHE_SIZE; i++) {
if (ifaddr_cache[i].ifname[0]=='\0') continue;
if (strcmp(ifname, ifaddr_cache[i].ifname) == 0) { /* match */
if (retaddr) memcpy(retaddr, &ifaddr_cache[i].ifaddr,
sizeof(struct in_addr));
DEBUGC(DBCLASS_DNS, "ifaddr lookup - from cache: %s -> %s %s",
ifname, utils_inet_ntoa(ifaddr_cache[i].ifaddr),
(ifaddr_cache[i].isup)? "UP":"DOWN");
return (ifaddr_cache[i].isup)? STS_SUCCESS: STS_FAILURE;
} /* if */
} /* for i */
/* not found in cache, go and get it */
#ifdef HAVE_GETIFADDRS
if (getifaddrs(&ifa_list)) {
ERROR("Error in getifaddrs: %s",strerror(errno));
return STS_FAILURE;
}
i=0; /* use "found" marker */
for (ifa = ifa_list; ifa != NULL; ifa = ifa->ifa_next) {
DEBUGC(DBCLASS_BABBLE,"getifaddrs - %s / %s, ifa_addr=%p, addrfamily=%i",
ifname, ifa->ifa_name,ifa->ifa_addr,
(ifa->ifa_addr)?ifa->ifa_addr->sa_family:-1);
if (ifa && ifa->ifa_name && ifa->ifa_addr &&
ifa->ifa_addr->sa_family == AF_INET &&
strcmp(ifa->ifa_name, ifname) == 0) {
/* found the entry */
i=1;
memcpy(&ifaddr, &((struct sockaddr_in*)ifa->ifa_addr)->sin_addr, sizeof(struct in_addr));
ifflags=ifa->ifa_flags;
DEBUGC(DBCLASS_BABBLE,"getifaddrs - MATCH, sin_addr=%s",
utils_inet_ntoa(ifaddr));
break;
}
}
freeifaddrs(ifa_list);
if (i==0) {
DEBUGC(DBCLASS_DNS,"Interface %s not found.", ifname);
return STS_FAILURE;
}
#else
memset(&ifr, 0, sizeof(ifr));
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
ERROR("Error in socket: %s",strerror(errno));
return STS_FAILURE;
}
/*&&&*/DEBUGC(DBCLASS_BABBLE,"&&&6 ifname=0x%p",ifname);
strcpy(ifr.ifr_name, ifname);
sin->sin_family = AF_INET;
/* get interface flags */
if(ioctl(sockfd, SIOCGIFFLAGS, &ifr) != 0) {
ERROR("Error in ioctl SIOCGIFFLAGS: %s [%s]",
strerror(errno), ifname);
close(sockfd);
return STS_FAILURE;
}
ifflags=ifr.ifr_flags;
/*&&&*/DEBUGC(DBCLASS_BABBLE,"&&&7 ifname=0x%p",ifname);
/* get address */
if(ioctl(sockfd, SIOCGIFADDR, &ifr) != 0) {
ERROR("Error in ioctl SIOCGIFADDR: %s (interface %s)",
strerror(errno), ifname);
close(sockfd);
return STS_FAILURE;
}
/*&&&*/DEBUGC(DBCLASS_BABBLE,"&&&8 ifname=0x%p",ifname);
memcpy(&ifaddr, &sin->sin_addr, sizeof(struct in_addr));
/*&&&*/DEBUGC(DBCLASS_BABBLE,"&&&9 ifname=0x%p",ifname);
close(sockfd);
#endif
if (ifflags & IFF_UP) isup=1;
else isup=0;
DEBUGC(DBCLASS_DNS, "get_ip_by_ifname: if %s has IP:%s (flags=%x) %s",
ifname, utils_inet_ntoa(ifaddr), ifflags,
(isup)? "UP":"DOWN");
/*
*find an empty slot in the cache
*/
j=0;
for (i=0; i<IFADR_CACHE_SIZE; i++) {
if (ifaddr_cache[i].ifname[0]=='\0') break;
if (ifaddr_cache[i].timestamp < t) {
/* remember oldest entry */
t=ifaddr_cache[i].timestamp;
j=i;
}
}
/* if no empty slot found, take oldest one */
if (i >= IFADR_CACHE_SIZE) i=j;
/*
* store the result in the cache
*/
DEBUGC(DBCLASS_DNS, "ifname lookup - store into cache, entry %i)", i);
memset(&ifaddr_cache[i], 0, sizeof(ifaddr_cache[0]));
strncpy(ifaddr_cache[i].ifname, ifname, IFNAME_SIZE);
ifaddr_cache[i].timestamp=t;
memcpy(&ifaddr_cache[i].ifaddr, &ifaddr, sizeof(struct in_addr));
ifaddr_cache[i].isup=isup;
if (retaddr) memcpy(retaddr, &ifaddr, sizeof(struct in_addr));
return (isup)? STS_SUCCESS : STS_FAILURE;
}
/*
* PROXY_REQUEST
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*
* RFC3261
* Section 16.3: Proxy Behavior - Request Validation
* 1. Reasonable Syntax
* 2. URI scheme
* 3. Max-Forwards
* 4. (Optional) Loop Detection
* 5. Proxy-Require
* 6. Proxy-Authorization
*
* Section 16.6: Proxy Behavior - Request Forwarding
* 1. Make a copy of the received request
* 2. Update the Request-URI
* 3. Update the Max-Forwards header field
* 4. Optionally add a Record-route header field value
* 5. Optionally add additional header fields
* 6. Postprocess routing information
* 7. Determine the next-hop address, port, and transport
* 8. Add a Via header field value
* 9. Add a Content-Length header field if necessary
* 10. Forward the new request
* 11. Set timer C
*/
int proxy_request (sip_ticket_t *ticket) {
int i;
int sts;
int type;
struct in_addr sendto_addr;
osip_uri_t *url;
int port;
char *buffer;
int buflen;
osip_message_t *request;
struct sockaddr_in *from;
DEBUGC(DBCLASS_PROXY,"proxy_request");
if (ticket==NULL) {
ERROR("proxy_request: called with NULL ticket");
return STS_FAILURE;
}
request=ticket->sipmsg;
from=&ticket->from;
/*
* RFC 3261, Section 16.4
* Proxy Behavior - Route Information Preprocessing
* (process Route header)
*/
route_preprocess(ticket);
/*
* figure out whether this is an incoming or outgoing request
* by doing a lookup in the registration table.
*/
#define _OLD_DIRECTION_EVALUATION 0
#if _OLD_DIRECTION_EVALUATION
type = 0;
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* incoming request ('to' == 'masq') || (('to' == 'reg') && !REGISTER)*/
if ((compare_url(request->to->url, urlmap[i].masq_url)==STS_SUCCESS) ||
(!MSG_IS_REGISTER(request) &&
(compare_url(request->to->url, urlmap[i].reg_url)==STS_SUCCESS))) {
type=REQTYP_INCOMING;
DEBUGC(DBCLASS_PROXY,"incoming request from %s@%s from outbound",
request->from->url->username? request->from->url->username:"******",
request->from->url->host? request->from->url->host: "*NULL*");
break;
}
/* outgoing request ('from' == 'reg') */
if (compare_url(request->from->url, urlmap[i].reg_url)==STS_SUCCESS) {
type=REQTYP_OUTGOING;
DEBUGC(DBCLASS_PROXY,"outgoing request from %s@%s from inbound",
request->from->url->username? request->from->url->username:"******",
request->from->url->host? request->from->url->host: "*NULL*");
break;
}
}
#else
type = 0;
/*
* did I receive the telegram from a REGISTERED host?
* -> it must be an OUTGOING request
*/
for (i=0; i<URLMAP_SIZE; i++) {
struct in_addr tmp_addr;
if (urlmap[i].active == 0) continue;
if (get_ip_by_host(urlmap[i].true_url->host, &tmp_addr) == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY, "proxy_request: cannot resolve host [%s]",
urlmap[i].true_url);
} else {
DEBUGC(DBCLASS_PROXY, "proxy_request: reghost:%s ip:%s",
urlmap[i].true_url->host, utils_inet_ntoa(from->sin_addr));
if (memcmp(&tmp_addr, &from->sin_addr, sizeof(tmp_addr)) == 0) {
type=REQTYP_OUTGOING;
break;
}
}
}
/*
* is the telegram directed to an internally registered host?
* -> it must be an INCOMING request
*/
if (type == 0) {
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* RFC3261:
* 'To' contains a display name (Bob) and a SIP or SIPS URI
* (sip:[email protected]) towards which the request was originally
* directed. Display names are described in RFC 2822 [3].
*/
/* So this means, that we must check the SIP URI supplied with the
* INVITE method, as this points to the real wanted target.
* Q: does there exist a situation where the SIP URI itself does
* point to "somewhere" but the To: points to the correct UA?
* So for now, we just look at both of them (SIP URI and To: header)
*/
/* incoming request (SIP URI == 'masq') || ((SIP URI == 'reg') && !REGISTER)*/
if ((compare_url(request->req_uri, urlmap[i].masq_url)==STS_SUCCESS) ||
(!MSG_IS_REGISTER(request) &&
(compare_url(request->req_uri, urlmap[i].reg_url)==STS_SUCCESS))) {
type=REQTYP_INCOMING;
break;
}
/* incoming request ('to' == 'masq') || (('to' == 'reg') && !REGISTER)*/
if ((compare_url(request->to->url, urlmap[i].masq_url)==STS_SUCCESS) ||
(!MSG_IS_REGISTER(request) &&
(compare_url(request->to->url, urlmap[i].reg_url)==STS_SUCCESS))) {
type=REQTYP_INCOMING;
break;
}
}
}
#endif
ticket->direction=type;
/*
* logging of passing calls
*/
if (configuration.log_calls) {
osip_uri_t *cont_url = NULL;
if (!osip_list_eol(request->contacts, 0))
cont_url = ((osip_contact_t*)(request->contacts->node->element))->url;
/* INVITE */
if (MSG_IS_INVITE(request)) {
if (cont_url) {
INFO("%s Call from: %s@%s",
(type==REQTYP_INCOMING) ? "Incoming":"Outgoing",
cont_url->username ? cont_url->username:"******",
cont_url->host ? cont_url->host : "*NULL*");
} else {
INFO("%s Call (w/o contact header) from: %s@%s",
(type==REQTYP_INCOMING) ? "Incoming":"Outgoing",
request->from->url->username ?
request->from->url->username:"******",
request->from->url->host ?
request->from->url->host : "*NULL*");
}
/* BYE / CANCEL */
} else if (MSG_IS_BYE(request) || MSG_IS_CANCEL(request)) {
if (cont_url) {
INFO("Ending Call from: %s@%s",
cont_url->username ? cont_url->username:"******",
cont_url->host ? cont_url->host : "*NULL*");
} else {
INFO("Ending Call (w/o contact header) from: %s@%s",
request->from->url->username ?
request->from->url->username:"******",
request->from->url->host ?
request->from->url->host : "*NULL*");
}
}
} /* log_calls */
/*
* RFC 3261, Section 16.6 step 1
* Proxy Behavior - Request Forwarding - Make a copy
*/
/* nothing to do here, copy is ready in 'request'*/
/* get destination address */
url=osip_message_get_uri(request);
switch (type) {
/*
* from an external host to the internal masqueraded host
*/
case REQTYP_INCOMING:
DEBUGC(DBCLASS_PROXY,"incoming request from %s@%s from outbound",
request->from->url->username? request->from->url->username:"******",
request->from->url->host? request->from->url->host: "*NULL*");
/*
* RFC 3261, Section 16.6 step 2
* Proxy Behavior - Request Forwarding - Request-URI
* (rewrite request URI to point to the real host)
*/
/* 'i' still holds the valid index into the URLMAP table */
if (check_rewrite_rq_uri(request) == STS_TRUE) {
proxy_rewrite_request_uri(request, i);
}
/* if this is CANCEL/BYE request, stop RTP proxying */
if (MSG_IS_BYE(request) || MSG_IS_CANCEL(request)) {
/* stop the RTP proxying stream(s) */
rtp_stop_fwd(osip_message_get_call_id(request), DIR_INCOMING);
rtp_stop_fwd(osip_message_get_call_id(request), DIR_OUTGOING);
/* check for incoming request */
} else if (MSG_IS_INVITE(request)) {
/* Rewrite the body */
sts = proxy_rewrite_invitation_body(request, DIR_INCOMING);
} else if (MSG_IS_ACK(request)) {
/* Rewrite the body */
sts = proxy_rewrite_invitation_body(request, DIR_INCOMING);
}
break;
/*
* from the internal masqueraded host to an external host
*/
case REQTYP_OUTGOING:
DEBUGC(DBCLASS_PROXY,"outgoing request from %s@%s from inbound",
request->from->url->username? request->from->url->username:"******",
request->from->url->host? request->from->url->host: "*NULL*");
/*
* RFC 3261, Section 16.6 step 2
* Proxy Behavior - Request Forwarding - Request-URI
*/
/* nothing to do for an outgoing request */
/* if it is addressed to myself, then it must be some request
* method that I as a proxy do not support. Reject */
#if 0
/* careful - an internal UA might send an request to another internal UA.
This would be caught here, so don't do this. This situation should be
caught in the default part of the CASE statement below */
if (is_sipuri_local(ticket) == STS_TRUE) {
WARN("unsupported request [%s] directed to proxy from %s@%s -> %s@%s",
request->sip_method? request->sip_method:"*NULL*",
request->from->url->username? request->from->url->username:"******",
request->from->url->host? request->from->url->host : "*NULL*",
url->username? url->username : "******",
url->host? url->host : "*NULL*");
sip_gen_response(ticket, 403 /*forbidden*/);
return STS_FAILURE;
}
#endif
/* rewrite Contact header to represent the masqued address */
sip_rewrite_contact(ticket, DIR_OUTGOING);
/* if an INVITE, rewrite body */
if (MSG_IS_INVITE(request)) {
sts = proxy_rewrite_invitation_body(request, DIR_OUTGOING);
} else if (MSG_IS_ACK(request)) {
sts = proxy_rewrite_invitation_body(request, DIR_OUTGOING);
}
/* if this is CANCEL/BYE request, stop RTP proxying */
if (MSG_IS_BYE(request) || MSG_IS_CANCEL(request)) {
/* stop the RTP proxying stream(s) */
rtp_stop_fwd(osip_message_get_call_id(request), DIR_INCOMING);
rtp_stop_fwd(osip_message_get_call_id(request), DIR_OUTGOING);
}
break;
default:
DEBUGC(DBCLASS_PROXY, "request [%s] from/to unregistered UA "
"(RQ: %s@%s -> %s@%s)",
request->sip_method? request->sip_method:"*NULL*",
request->from->url->username? request->from->url->username:"******",
request->from->url->host? request->from->url->host : "*NULL*",
url->username? url->username : "******",
url->host? url->host : "*NULL*");
/*
* we may end up here for two reasons:
* 1) An incomming request (from outbound) that is directed to
* an unknown (not registered) local UA
* 2) an outgoing request from a local UA that is not registered.
*
* Case 1) we should probably answer with "404 Not Found",
* case 2) more likely a "403 Forbidden"
*
* How about "408 Request Timeout" ?
*
*/
sip_gen_response(ticket, 408 /* Request Timeout */);
return STS_FAILURE;
}
/*
* RFC 3261, Section 16.6 step 3
* Proxy Behavior - Request Forwarding - Max-Forwards
* (if Max-Forwards header exists, decrement by one, if it does not
* exist, add a new one with value SHOULD be 70)
*/
{
osip_header_t *max_forwards;
int forwards_count = DEFAULT_MAXFWD;
char mfwd[8];
osip_message_get_max_forwards(request, 0, &max_forwards);
if (max_forwards == NULL) {
sprintf(mfwd, "%i", forwards_count);
osip_message_set_max_forwards(request, mfwd);
} else {
if (max_forwards->hvalue) {
forwards_count = atoi(max_forwards->hvalue);
forwards_count -=1;
osip_free (max_forwards->hvalue);
}
sprintf(mfwd, "%i", forwards_count);
max_forwards->hvalue = osip_strdup(mfwd);
}
DEBUGC(DBCLASS_PROXY,"setting Max-Forwards=%s",mfwd);
}
/*
* RFC 3261, Section 16.6 step 4
* Proxy Behavior - Request Forwarding - Add a Record-route header
*/
/*
* for ALL incoming requests, include my Record-Route header.
* The local UA will probably send its answer to the topmost
* Route Header (8.1.2 of RFC3261)
*/
if (type == REQTYP_INCOMING) {
DEBUGC(DBCLASS_PROXY,"Adding my Record-Route");
route_add_recordroute(ticket);
} else {
/*
* outgoing packets must not have my record route header, as
* this likely will contain a private IP address (my inbound).
*/
DEBUGC(DBCLASS_PROXY,"Purging Record-Routes (outgoing packet)");
route_purge_recordroute(ticket);
}
/*
* RFC 3261, Section 16.6 step 5
* Proxy Behavior - Request Forwarding - Add Additional Header Fields
*/
/* NOT IMPLEMENTED (optional) */
/*
* RFC 3261, Section 16.6 step 6
* Proxy Behavior - Request Forwarding - Postprocess routing information
*
* If the copy contains a Route header field, the proxy MUST
* inspect the URI in its first value. If that URI does not
* contain an lr parameter, the proxy MUST modify the copy as
* follows:
*
* - The proxy MUST place the Request-URI into the Route header
* field as the last value.
*
* - The proxy MUST then place the first Route header field value
* into the Request-URI and remove that value from the Route
* header field.
*/
#if 0
route_postprocess(ticket);
#endif
/*
* RFC 3261, Section 16.6 step 7
* Proxy Behavior - Determine Next-Hop Address
*/
/*&&&& priority probably should be:
* 1) Route header
* 2) fixed outbound proxy
* 3) SIP URI
*/
/*
* fixed or domain outbound proxy defined ?
*/
if ((type == REQTYP_OUTGOING) &&
(sip_find_outbound_proxy(ticket, &sendto_addr, &port) == STS_SUCCESS)) {
DEBUGC(DBCLASS_PROXY, "proxy_request: have outbound proxy %s:%i",
utils_inet_ntoa(sendto_addr), port);
/*
* Route present?
* If so, fetch address from topmost Route: header and remove it.
*/
} else if ((type == REQTYP_OUTGOING) &&
(request->routes && !osip_list_eol(request->routes, 0))) {
sts=route_determine_nexthop(ticket, &sendto_addr, &port);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY, "proxy_request: route_determine_nexthop failed");
return STS_FAILURE;
}
DEBUGC(DBCLASS_PROXY, "proxy_request: have Route header to %s:%i",
utils_inet_ntoa(sendto_addr), port);
/*
* destination from SIP URI
*/
} else {
/* get the destination from the SIP URI */
sts = get_ip_by_host(url->host, &sendto_addr);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY, "proxy_request: cannot resolve URI [%s]",
url->host);
return STS_FAILURE;
}
if (url->port) {
port=atoi(url->port);
} else {
port=SIP_PORT;
}
DEBUGC(DBCLASS_PROXY, "proxy_request: have SIP URI to %s:%i",
url->host, port);
}
/*
* RFC 3261, Section 16.6 step 8
* Proxy Behavior - Add a Via header field value
*/
/* add my Via header line (outbound interface)*/
if (type == REQTYP_INCOMING) {
sts = sip_add_myvia(ticket, IF_INBOUND);
if (sts == STS_FAILURE) {
ERROR("adding my inbound via failed!");
}
} else {
sts = sip_add_myvia(ticket, IF_OUTBOUND);
if (sts == STS_FAILURE) {
ERROR("adding my outbound via failed!");
return STS_FAILURE;
}
}
/*
* RFC 3261, Section 16.6 step 9
* Proxy Behavior - Add a Content-Length header field if necessary
*/
/* not necessary, already in message and we do not support TCP */
/*
* RFC 3261, Section 16.6 step 10
* Proxy Behavior - Forward the new request
*/
sts = sip_message_to_str(request, &buffer, &buflen);
if (sts != 0) {
ERROR("proxy_request: sip_message_to_str failed");
return STS_FAILURE;
}
sipsock_send(sendto_addr, port, ticket->protocol,
buffer, buflen);
osip_free (buffer);
/*
* RFC 3261, Section 16.6 step 11
* Proxy Behavior - Set timer C
*/
/* NOT IMPLEMENTED - does this really apply for stateless proxies? */
return STS_SUCCESS;
}
/*
* PROXY_REWRITE_INVITATION_BODY
*
* rewrites the outgoing INVITATION request or response packet
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*/
int proxy_rewrite_invitation_body(osip_message_t *mymsg, int direction){
osip_body_t *body;
sdp_message_t *sdp;
struct in_addr map_addr, addr_sess, addr_media, outside_addr, inside_addr;
int sts;
char *bodybuff;
int bodybuflen;
char clen[8]; /* content length: probably never more than 7 digits !*/
int map_port, msg_port;
int media_stream_no;
sdp_connection_t *sdp_conn;
sdp_media_t *sdp_med;
int rtp_direction=0;
int have_c_media=0;
if (configuration.rtp_proxy_enable == 0) return STS_SUCCESS;
/*
* get SDP structure
*/
sts = osip_message_get_body(mymsg, 0, &body);
if (sts != 0) {
#if 0
if ((MSG_IS_RESPONSE_FOR(mymsg,"INVITE")) &&
(MSG_IS_STATUS_1XX(mymsg))) {
/* 1xx responses *MAY* contain SDP data */
DEBUGC(DBCLASS_PROXY, "rewrite_invitation_body: "
"no body found in message");
return STS_SUCCESS;
} else {
/* INVITE request and 200 response *MUST* contain SDP data */
ERROR("rewrite_invitation_body: no body found in message");
return STS_FAILURE;
}
#else
DEBUGC(DBCLASS_PROXY, "rewrite_invitation_body: "
"no body found in message");
return STS_SUCCESS;
#endif
}
sts = sip_body_to_str(body, &bodybuff, &bodybuflen);
if (sts != 0) {
ERROR("rewrite_invitation_body: unable to sip_body_to_str");
}
sts = sdp_message_init(&sdp);
sts = sdp_message_parse (sdp, bodybuff);
if (sts != 0) {
ERROR("rewrite_invitation_body: unable to sdp_message_parse body");
DUMP_BUFFER(-1, bodybuff, bodybuflen);
osip_free(bodybuff);
sdp_message_free(sdp);
return STS_FAILURE;
}
osip_free(bodybuff);
if (configuration.debuglevel)
{ /* just dump the buffer */
char *tmp, *tmp2;
int tmplen;
sts = osip_message_get_body(mymsg, 0, &body);
sts = sip_body_to_str(body, &tmp, &tmplen);
osip_content_length_to_str(mymsg->content_length, &tmp2);
DEBUG("Body before rewrite (clen=%s, strlen=%i):\n%s\n----",
tmp2, tmplen, tmp);
osip_free(tmp);
osip_free(tmp2);
}
/*
* RTP proxy: get ready and start forwarding
* start forwarding for each media stream ('m=' item in SIP message)
*/
/* get outbound address */
if (get_interface_ip(IF_OUTBOUND, &outside_addr) != STS_SUCCESS) {
sdp_message_free(sdp);
return STS_FAILURE;
}
/* get inbound address */
if (get_interface_ip(IF_INBOUND, &inside_addr) != STS_SUCCESS) {
sdp_message_free(sdp);
return STS_FAILURE;
}
/* figure out what address to use for RTP masquerading */
if (MSG_IS_REQUEST(mymsg)) {
if (direction == DIR_INCOMING) {
memcpy(&map_addr, &inside_addr, sizeof (map_addr));
rtp_direction = DIR_OUTGOING;
} else {
memcpy(&map_addr, &outside_addr, sizeof (map_addr));
rtp_direction = DIR_INCOMING;
}
} else /* MSG_IS_REPONSE(mymsg) */ {
if (direction == DIR_INCOMING) {
memcpy(&map_addr, &inside_addr, sizeof (map_addr));
rtp_direction = DIR_OUTGOING;
} else {
memcpy(&map_addr, &outside_addr, sizeof (map_addr));
rtp_direction = DIR_INCOMING;
}
}
DEBUGC(DBCLASS_PROXY, "proxy_rewrite_invitation_body: SIP[%s %s] RTP[%s %s]",
MSG_IS_REQUEST(mymsg)? "RQ" : "RS",
(direction==DIR_INCOMING)? "IN" : "OUT",
(rtp_direction==DIR_INCOMING)? "IN" : "OUT",
utils_inet_ntoa(map_addr));
/*
* first, check presence of a 'c=' item on session level
*/
if (sdp->c_connection==NULL || sdp->c_connection->c_addr==NULL) {
/*
* No 'c=' on session level, search on media level now
*
* According to RFC2327, ALL media description must
* include a 'c=' item now:
*/
media_stream_no=0;
while (!sdp_message_endof_media(sdp, media_stream_no)) {
/* check if n'th media stream is present */
if (sdp_message_c_addr_get(sdp, media_stream_no, 0) == NULL) {
ERROR("SDP: have no 'c=' on session level and neither "
"on media level (media=%i)",media_stream_no);
sdp_message_free(sdp);
return STS_FAILURE;
}
media_stream_no++;
} /* while */
}
/* Required 'c=' items ARE present */
/*
* rewrite 'c=' item on session level if present and not yet done.
* remember the original address in addr_sess
*/
memset(&addr_sess, 0, sizeof(addr_sess));
if (sdp->c_connection && sdp->c_connection->c_addr) {
sts = get_ip_by_host(sdp->c_connection->c_addr, &addr_sess);
if (sts == STS_FAILURE) {
ERROR("SDP: cannot resolve session 'c=' host [%s]",
sdp->c_connection->c_addr);
sdp_message_free(sdp);
return STS_FAILURE;
}
/*
* Rewrite
* an IP address of 0.0.0.0 means *MUTE*, don't rewrite such
*/
if (strcmp(sdp->c_connection->c_addr, "0.0.0.0") != 0) {
osip_free(sdp->c_connection->c_addr);
sdp->c_connection->c_addr=osip_malloc(HOSTNAME_SIZE);
sprintf(sdp->c_connection->c_addr, "%s", utils_inet_ntoa(map_addr));
} else {
/* 0.0.0.0 - don't rewrite */
DEBUGC(DBCLASS_PROXY, "proxy_rewrite_invitation_body: "
"got a MUTE c= record (on session level - legal?)");
}
}
/*
* rewrite 'o=' item (originator) on session level if present.
*/
if (sdp->o_addrtype && sdp->o_addr) {
if (strcmp(sdp->o_addrtype, "IP4") != 0) {
ERROR("got IP6 in SDP originator - not yet suported by siproxd");
sdp_message_free(sdp);
return STS_FAILURE;
}
osip_free(sdp->o_addr);
sdp->o_addr=osip_malloc(HOSTNAME_SIZE);
sprintf(sdp->o_addr, "%s", utils_inet_ntoa(map_addr));
}
/*
* loop through all media descritions,
* start RTP proxy and rewrite them
*/
for (media_stream_no=0;;media_stream_no++) {
/* check if n'th media stream is present */
if (sdp_message_m_port_get(sdp, media_stream_no) == NULL) break;
/*
* check if a 'c=' item is present in this media description,
* if so -> rewrite it
*/
memset(&addr_media, 0, sizeof(addr_media));
have_c_media=0;
sdp_conn=sdp_message_connection_get(sdp, media_stream_no, 0);
if (sdp_conn && sdp_conn->c_addr) {
if (strcmp(sdp_conn->c_addr, "0.0.0.0") != 0) {
sts = get_ip_by_host(sdp_conn->c_addr, &addr_media);
have_c_media=1;
/* have a valid address */
osip_free(sdp_conn->c_addr);
sdp_conn->c_addr=osip_malloc(HOSTNAME_SIZE);
sprintf(sdp_conn->c_addr, "%s", utils_inet_ntoa(map_addr));
} else {
/* 0.0.0.0 - don't rewrite */
DEBUGC(DBCLASS_PROXY, "proxy_rewrite_invitation_body: got a "
"MUTE c= record (media level)");
}
}
/* start an RTP proxying stream */
if (sdp_message_m_port_get(sdp, media_stream_no)) {
msg_port=atoi(sdp_message_m_port_get(sdp, media_stream_no));
if (msg_port > 0) {
osip_uri_t *cont_url = NULL;
char *client_id=NULL;
/* try to get some additional UA specific unique ID.
* Try:
* 1) User part of Contact header
* 2) Host part of Contact header (will be different
* between internal UA and external UA)
*/
if (!osip_list_eol(mymsg->contacts, 0))
cont_url = ((osip_contact_t*)(mymsg->contacts->node->element))->url;
if (cont_url) {
client_id=cont_url->username;
if (client_id == NULL) client_id=cont_url->host;
}
/*
* do we have a 'c=' item on media level?
* if not, use the same as on session level
*/
if (have_c_media == 0) {
memcpy(&addr_media, &addr_sess, sizeof(addr_sess));
}
/*
* Am I running in front of the routing device? Then I cannot
* use the external IP to bind a listen socket to, so force
* the use of my inbound IP for listening.
*/
if ((rtp_direction == DIR_INCOMING) &&
(configuration.outbound_host) &&
(strcmp(configuration.outbound_host, "")!=0)) {
DEBUGC(DBCLASS_PROXY, "proxy_rewrite_invitation_body: "
"in-front-of-NAT-Router");
memcpy(&map_addr, &inside_addr, sizeof (map_addr));
}
sts = rtp_start_fwd(osip_message_get_call_id(mymsg),
client_id,
rtp_direction,
media_stream_no,
map_addr, &map_port,
addr_media, msg_port);
if (sts == STS_SUCCESS) {
/* and rewrite the port */
sdp_med=osip_list_get(sdp->m_medias, media_stream_no);
if (sdp_med && sdp_med->m_port) {
osip_free(sdp_med->m_port);
sdp_med->m_port=osip_malloc(8); /* 5 digits, \0 + align */
sprintf(sdp_med->m_port, "%i", map_port);
DEBUGC(DBCLASS_PROXY, "proxy_rewrite_invitation_body: "
"m= rewrote port to [%i]",map_port);
} else {
ERROR("rewriting port in m= failed sdp_med=%p, "
"m_number_of_port=%p", sdp_med, sdp_med->m_port);
}
} /* sts == success */
} /* if msg_port > 0 */
} else {
/* no port defined - skip entry */
WARN("no port defined in m=(media) stream_no=%i", media_stream_no);
continue;
}
} /* for media_stream_no */
/* remove old body */
sts = osip_list_remove(mymsg->bodies, 0);
osip_body_free(body);
/* dump new body */
sdp_message_to_str(sdp, &bodybuff);
bodybuflen=strlen(bodybuff);
/* free sdp structure */
sdp_message_free(sdp);
/* include new body */
sip_message_set_body(mymsg, bodybuff, bodybuflen);
if (sts != 0) {
ERROR("rewrite_invitation_body: unable to sip_message_set_body body");
}
/* free content length resource and include new one*/
osip_content_length_free(mymsg->content_length);
mymsg->content_length=NULL;
sprintf(clen,"%i",bodybuflen);
sts = osip_message_set_content_length(mymsg, clen);
/* free old body */
osip_free(bodybuff);
if (configuration.debuglevel)
{ /* just dump the buffer */
char *tmp, *tmp2;
int tmplen;
sts = osip_message_get_body(mymsg, 0, &body);
sts = sip_body_to_str(body, &tmp, &tmplen);
osip_content_length_to_str(mymsg->content_length, &tmp2);
DEBUG("Body after rewrite (clen=%s, strlen=%i):\n%s\n----",
tmp2, tmplen, tmp);
osip_free(tmp);
osip_free(tmp2);
}
return STS_SUCCESS;
}
/*
* start an rtp stream on the proxy
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*/
int rtp_relay_start_fwd (osip_call_id_t *callid, char *client_id,
int rtp_direction,
int media_stream_no, struct in_addr local_ipaddr,
int *local_port, struct in_addr remote_ipaddr,
int remote_port) {
static int prev_used_port = 0;
int num_ports;
int i2, i, j;
int sock, port;
int freeidx;
int sts=STS_SUCCESS;
int tos;
osip_call_id_t cid;
if (callid == NULL) {
ERROR("rtp_relay_start_fwd: callid is NULL!");
return STS_FAILURE;
}
if (client_id == NULL) {
ERROR("rtp_relay_start_fwd: did not get a client ID!");
return STS_FAILURE;
}
/*
* life insurance: check size of received call_id strings
* I don't know what the maximum allowed size within SIP is,
* so if this test fails maybe it's just necessary to increase
* the constants CALLIDNUM_SIZE and/or CALLIDHOST_SIZE.
*/
if (callid->number && strlen(callid->number) > CALLIDNUM_SIZE) {
ERROR("rtp_relay_start_fwd: received callid number "
"has too many characters (%i, max=%i)",
strlen(callid->number),CALLIDNUM_SIZE);
return STS_FAILURE;
}
if (callid->host && strlen(callid->host) > CALLIDHOST_SIZE) {
ERROR("rtp_relay_start_fwd: received callid host "
"has too many characters (%i, max=%i)",
strlen(callid->host),CALLIDHOST_SIZE);
return STS_FAILURE;
}
if (client_id && strlen(client_id) > CLIENT_ID_SIZE) {
ERROR("rtp_relay_start_fwd: client ID has too many characters "
"(%i, max=%i) (maybe you need to increase CLIENT_ID_SIZE",
strlen(client_id),CLIENT_ID_SIZE);
return STS_FAILURE;
}
DEBUGC(DBCLASS_RTP,"rtp_relay_start_fwd: starting RTP proxy "
"stream for: %s@%s[%s] (%s) #=%i",
callid->number, callid->host, client_id,
((rtp_direction == DIR_INCOMING) ? "incoming RTP" : "outgoing RTP"),
media_stream_no);
/* lock mutex */
#define return is_forbidden_in_this_code_section
pthread_mutex_lock(&rtp_proxytable_mutex);
/*
* !! We now have a locked MUTEX! It is forbidden to return() from
* !! here up to the end of this funtion where the MUTEX is
* !! unlocked again.
* !! Per design, a mutex is locked (for one purpose) at *exactly one*
* !! place in the code and unlocked also at *exactly one* place.
* !! this minimizes the risk of deadlocks.
*/
/*
* figure out, if this is an request to start an RTP proxy stream
* that is already existing (identified by SIP Call-ID, direction,
* media_stream_no and some other client unique thing).
* This can be due to UDP repetitions of the INVITE request...
*/
for (i=0; i<RTPPROXY_SIZE; i++) {
cid.number = rtp_proxytable[i].callid_number;
cid.host = rtp_proxytable[i].callid_host;
if (rtp_proxytable[i].rtp_rx_sock &&
(compare_callid(callid, &cid) == STS_SUCCESS) &&
(rtp_proxytable[i].direction == rtp_direction) &&
(rtp_proxytable[i].media_stream_no == media_stream_no) &&
(strcmp(rtp_proxytable[i].client_id, client_id) == 0)) {
/*
* The RTP port number reported by the UA MAY change
* for a given media stream
* (seen with KPhone during HOLD/unHOLD)
* Also the destination IP may change during a re-Invite
* (seen with Sipphone.com, re-Invites when using
* the SIP - POTS gateway [SIP Minutes]
*/
/* Port number */
if (rtp_proxytable[i].remote_port != remote_port) {
DEBUGC(DBCLASS_RTP,"RTP port number changed %i -> %i",
rtp_proxytable[i].remote_port, remote_port);
rtp_proxytable[i].remote_port = remote_port;
}
/* IP address */
if (memcmp(&rtp_proxytable[i].remote_ipaddr, &remote_ipaddr,
sizeof(remote_ipaddr))) {
DEBUGC(DBCLASS_RTP,"RTP IP address changed to %s",
utils_inet_ntoa(remote_ipaddr));
memcpy (&rtp_proxytable[i].remote_ipaddr, &remote_ipaddr,
sizeof(remote_ipaddr));
}
/* return the already known local port number */
DEBUGC(DBCLASS_RTP,"RTP stream already active (remaddr=%s, "
"remport=%i, lclport=%i, id=%s, #=%i)",
utils_inet_ntoa(remote_ipaddr),
rtp_proxytable[i].remote_port,
rtp_proxytable[i].local_port,
rtp_proxytable[i].callid_number,
rtp_proxytable[i].media_stream_no);
*local_port=rtp_proxytable[i].local_port;
sts = STS_SUCCESS;
goto unlock_and_exit;
}
}
/*
* find first free slot in rtp_proxytable
*/
freeidx=-1;
for (j=0; j<RTPPROXY_SIZE; j++) {
if (rtp_proxytable[j].rtp_rx_sock==0) {
freeidx=j;
break;
}
}
/* rtp_proxytable port pool full? */
if (freeidx == -1) {
ERROR("rtp_relay_start_fwd: rtp_proxytable is full!");
sts = STS_FAILURE;
goto unlock_and_exit;
}
/* TODO: randomize the port allocation - start at a random offset to
search in the allowed port range (so some modulo stuff w/
random start offset
- for i=x to (p1-p0)+x; p=p0+mod(x,p1-p0) */
/* find a local port number to use and bind to it */
sock=0;
port=0;
if ((prev_used_port < configuration.rtp_port_low) ||
(prev_used_port > configuration.rtp_port_high)) {
prev_used_port = configuration.rtp_port_high;
}
num_ports = configuration.rtp_port_high - configuration.rtp_port_low + 1;
for (i2 = (prev_used_port - configuration.rtp_port_low + 1);
i2 < (num_ports + prev_used_port - configuration.rtp_port_low + 1);
i2 += 2) {
i = (i2%num_ports) + configuration.rtp_port_low;
for (j=0; j<RTPPROXY_SIZE; j++) {
/* check if port already in use */
if ((memcmp(&rtp_proxytable[j].local_ipaddr,
&local_ipaddr, sizeof(struct in_addr))== 0) &&
(rtp_proxytable[j].local_port == i) ) break;
}
/* port is available, try to allocate */
if (j == RTPPROXY_SIZE) {
port=i;
sock=sockbind(local_ipaddr, port, 0);
/* if success break, else try further on */
if (sock) break;
}
} /* for i */
prev_used_port = port;
DEBUGC(DBCLASS_RTP,"rtp_relay_start_fwd: addr=%s, port=%i, sock=%i "
"freeidx=%i", utils_inet_ntoa(local_ipaddr), port, sock, freeidx);
/* found an unused port? No -> RTP port pool fully allocated */
if ((port == 0) || (sock == 0)) {
ERROR("rtp_relay_start_fwd: no RTP port available or bind() failed");
sts = STS_FAILURE;
goto unlock_and_exit;
}
/* set DSCP value, need to be ROOT */
if (configuration.rtp_dscp) {
int uid,euid;
uid=getuid();
euid=geteuid();
DEBUGC(DBCLASS_RTP,"uid=%i, euid=%i", uid, euid);
if (uid != euid) seteuid(0);
if (geteuid()==0) {
/* now I'm root */
if (!(configuration.rtp_dscp & ~0x3f)) {
tos = (configuration.rtp_dscp << 2) & 0xff;
if(setsockopt(sock, SOL_IP, IP_TOS, &tos, sizeof(tos))) {
ERROR("rtp_relay_start_fwd: setsockopt() failed while "
"setting DSCP value: ", strerror(errno));
}
} else {
ERROR("rtp_relay_start_fwd: Invalid DSCP value %d",
configuration.rtp_dscp);
configuration.rtp_dscp = 0; /* inhibit further attempts */
}
} else {
/* could not get root */
WARN("siproxd not started as root - cannot set DSCP value");
configuration.rtp_dscp = 0; /* inhibit further attempts */
}
/* drop privileges */
if (uid != euid) seteuid(euid);
}
/* write entry into rtp_proxytable slot (freeidx) */
rtp_proxytable[freeidx].rtp_rx_sock=sock;
if (callid->number) {
strcpy(rtp_proxytable[freeidx].callid_number, callid->number);
} else {
rtp_proxytable[freeidx].callid_number[0]='\0';
}
if (callid->host) {
strcpy(rtp_proxytable[freeidx].callid_host, callid->host);
} else {
rtp_proxytable[freeidx].callid_host[0]='\0';
}
if (client_id) {
strcpy(rtp_proxytable[freeidx].client_id, client_id);
} else {
rtp_proxytable[freeidx].client_id[0]='\0';
}
rtp_proxytable[freeidx].direction = rtp_direction;
rtp_proxytable[freeidx].media_stream_no = media_stream_no;
memcpy(&rtp_proxytable[freeidx].local_ipaddr,
&local_ipaddr, sizeof(struct in_addr));
rtp_proxytable[freeidx].local_port=port;
memcpy(&rtp_proxytable[freeidx].remote_ipaddr,
&remote_ipaddr, sizeof(struct in_addr));
rtp_proxytable[freeidx].remote_port=remote_port;
time(&rtp_proxytable[freeidx].timestamp);
*local_port=port;
/* call to firewall API */
fwapi_start_rtp(rtp_proxytable[freeidx].direction,
rtp_proxytable[freeidx].local_ipaddr,
rtp_proxytable[freeidx].local_port,
rtp_proxytable[freeidx].remote_ipaddr,
rtp_proxytable[freeidx].remote_port);
/* prepare FD set for next select operation */
rtp_recreate_fdset();
/* wakeup/signal rtp_proxythread from select() hibernation */
if (!pthread_equal(rtpproxy_tid, pthread_self()))
pthread_kill(rtpproxy_tid, SIGALRM);
unlock_and_exit:
/* unlock mutex */
pthread_mutex_unlock(&rtp_proxytable_mutex);
#undef return
return sts;
}
/*
* PROXY_RESPONSE
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
* RFC3261
* Section 16.7: Proxy Behavior - Response Processing
* 1. Find the appropriate response context
* 2. Update timer C for provisional responses
* 3. Remove the topmost Via
* 4. Add the response to the response context
* 5. Check to see if this response should be forwarded immediately
* 6. When necessary, choose the best final response from the
* response context
* 7. Aggregate authorization header field values if necessary
* 8. Optionally rewrite Record-Route header field values
* 9. Forward the response
* 10. Generate any necessary CANCEL requests
*
*/
int proxy_response (sip_ticket_t *ticket) {
int i;
int sts;
int type;
struct in_addr sendto_addr;
osip_via_t *via;
int port;
char *buffer;
int buflen;
osip_message_t *response;
struct sockaddr_in *from;
DEBUGC(DBCLASS_PROXY,"proxy_response");
if (ticket==NULL) {
ERROR("proxy_response: called with NULL ticket");
return STS_FAILURE;
}
response=ticket->sipmsg;
from=&ticket->from;
/*
* RFC 3261, Section 16.7 step 3
* Proxy Behavior - Response Processing - Remove my Via header field value
*/
/* remove my Via header line */
sts = sip_del_myvia(ticket);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY,"not addressed to my VIA, ignoring response");
return STS_FAILURE;
}
/*
* figure out if this is an request coming from the outside
* world to one of our registered clients
*/
/* Ahhrghh...... a response seems to have NO contact information...
* so let's take FROM instead...
* the TO and FROM headers are EQUAL to the request - that means
* they are swapped in their meaning for a response...
*/
#if _OLD_DIRECTION_EVALUATION
type = 0;
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* incoming response ('from' == 'masq') || ('from' == 'reg') */
if ((compare_url(response->from->url, urlmap[i].reg_url)==STS_SUCCESS) ||
(compare_url(response->from->url, urlmap[i].masq_url)==STS_SUCCESS)) {
type=RESTYP_INCOMING;
DEBUGC(DBCLASS_PROXY,"incoming response for %s@%s from outbound",
response->from->url->username? response->from->url->username:"******",
response->from->url->host? response->from->url->host : "*NULL*");
break;
}
/* outgoing response ('to' == 'reg') || ('to' == 'masq' ) */
if ((compare_url(response->to->url, urlmap[i].masq_url)==STS_SUCCESS) ||
(compare_url(response->to->url, urlmap[i].reg_url)==STS_SUCCESS)){
type=RESTYP_OUTGOING;
DEBUGC(DBCLASS_PROXY,"outgoing response for %s@%s from inbound",
response->from->url->username ?
response->from->url->username : "******",
response->from->url->host ?
response->from->url->host : "*NULL*");
break;
}
}
#else
type = 0;
/*
* did I receive the telegram from a REGISTERED host?
* -> it must be an OUTGOING response
*/
for (i=0; i<URLMAP_SIZE; i++) {
struct in_addr tmp_addr;
if (urlmap[i].active == 0) continue;
if (get_ip_by_host(urlmap[i].true_url->host, &tmp_addr) == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY, "proxy_response: cannot resolve host [%s]",
urlmap[i].true_url);
} else {
DEBUGC(DBCLASS_PROXY, "proxy_response: reghost:%s ip:%s",
urlmap[i].true_url->host, utils_inet_ntoa(from->sin_addr));
if (memcmp(&tmp_addr, &from->sin_addr, sizeof(tmp_addr)) == 0) {
type=RESTYP_OUTGOING;
break;
}
}
}
/*
* is the telegram directed to an internal registered host?
* -> it must be an INCOMING response
*/
if (type == 0) {
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* incoming response ('from' == 'masq') || ('from' == 'reg') */
if ((compare_url(response->from->url, urlmap[i].reg_url)==STS_SUCCESS) ||
(compare_url(response->from->url, urlmap[i].masq_url)==STS_SUCCESS)) {
type=RESTYP_INCOMING;
break;
}
}
}
/* &&&& Open Issue &&&&
it has been seen with cross-provider calls that the FROM may be 'garbled'
(e.g [email protected] for calls made sipphone -> FWD)
How can we deal with this? Should I take into consideration the 'Via'
headers? This is the only clue I have, pointing to the *real* UA.
Maybe I should put in a 'siproxd' ftag value to recognize it as a header
inserted by myself
*/
if ((type == 0) && (!osip_list_eol(response->vias, 0))) {
osip_via_t *via;
struct in_addr addr_via, addr_myself;
int port_via, port_ua;
/* get the via address */
via = (osip_via_t *) osip_list_get (response->vias, 0);
DEBUGC(DBCLASS_PROXY, "proxy_response: check via [%s] for "
"registered UA",via->host);
sts=get_ip_by_host(via->host, &addr_via);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_DNS, "proxy_response: cannot resolve VIA [%s]",
via->host);
} else {
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* incoming response (1st via in list points to a registered UA) */
sts=get_ip_by_host(urlmap[i].true_url->host, &addr_myself);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_DNS, "proxy_response: cannot resolve "
"true_url [%s]", via->host);
continue;
}
port_via=0;
if (via->port) port_via=atoi(via->port);
if (port_via <= 0) port_via=SIP_PORT;
port_ua=0;
if (urlmap[i].true_url->port)
port_ua=atoi(urlmap[i].true_url->port);
if (port_ua <= 0) port_ua=SIP_PORT;
DEBUGC(DBCLASS_BABBLE, "proxy_response: checking for registered "
"host [%s:%i] <-> [%s:%i]",
urlmap[i].true_url->host, port_ua,
via->host, port_via);
if ((memcmp(&addr_myself, &addr_via, sizeof(addr_myself))==0) &&
(port_via == port_ua)) {
type=RESTYP_INCOMING;
break;
}
}
}
}
#endif
ticket->direction=type;
/*
* ok, we got a response that we are allowed to process.
*/
switch (type) {
/*
* from an external host to the internal masqueraded host
*/
case RESTYP_INCOMING:
DEBUGC(DBCLASS_PROXY,"incoming response for %s@%s from outbound",
response->from->url->username? response->from->url->username:"******",
response->from->url->host? response->from->url->host : "*NULL*");
/*
* Response for INVITE - deal with RTP data in body and
* start RTP proxy stream(s). In case
* of a negative answer, stop RTP stream
*/
if (MSG_IS_RESPONSE_FOR(response,"INVITE")) {
/* positive response, start RTP stream */
if ((MSG_IS_STATUS_1XX(response)) ||
(MSG_IS_STATUS_2XX(response))) {
if (configuration.rtp_proxy_enable == 1) {
sts = proxy_rewrite_invitation_body(response, DIR_INCOMING);
}
/* negative - stop a possibly started RTP stream */
} else if ((MSG_IS_STATUS_4XX(response)) ||
(MSG_IS_STATUS_5XX(response)) ||
(MSG_IS_STATUS_6XX(response))) {
rtp_stop_fwd(osip_message_get_call_id(response), DIR_INCOMING);
rtp_stop_fwd(osip_message_get_call_id(response), DIR_OUTGOING);
}
} /* if INVITE */
/*
* Response for REGISTER - special handling of Contact header
*/
if (MSG_IS_RESPONSE_FOR(response,"REGISTER")) {
/*
* REGISTER returns *my* Contact header information.
* Rewrite Contact header back to represent the true address.
* Other responses do return the Contact header of the sender.
*/
sip_rewrite_contact(ticket, DIR_INCOMING);
}
/*
* Response for SUBSCRIBE
*
* HACK for Grandstream SIP phones (with newer firmware like 1.0.4.40):
* They send a SUBSCRIBE request to the registration server. In
* case of beeing registering directly to siproxd, this request of
* course will eventually be forwarded back to the same UA.
* Grandstream then does reply with an '202' response (A 202
* response merely indicates that the subscription has been
* understood, and that authorization may or may not have been
* granted), which then of course is forwarded back to the phone.
* Ans it seems that the Grandstream can *not* *handle* this
* response, as it immediately sends another SUBSCRIBE request.
* And this games goes on and on and on...
*
* As a workaround we will transform any 202 response to a
* '404 unknown destination'
*
*/
{
osip_header_t *ua_hdr=NULL;
osip_message_get_user_agent(response, 0, &ua_hdr);
if (ua_hdr && ua_hdr->hvalue &&
(osip_strncasecmp(ua_hdr->hvalue,"grandstream", 11)==0) &&
(MSG_IS_RESPONSE_FOR(response,"SUBSCRIBE")) &&
(MSG_TEST_CODE(response, 202))) {
DEBUGC(DBCLASS_PROXY, "proxy_response: Grandstream hack 202->404");
response->status_code=404;
}
}
break;
/*
* from the internal masqueraded host to an external host
*/
case RESTYP_OUTGOING:
DEBUGC(DBCLASS_PROXY,"outgoing response for %s@%s from inbound",
response->from->url->username ?
response->from->url->username : "******",
response->from->url->host ?
response->from->url->host : "*NULL*");
/* rewrite Contact header to represent the masqued address */
sip_rewrite_contact(ticket, DIR_OUTGOING);
/*
* If an 2xx OK or 1xx response, answer to an INVITE request,
* rewrite body
*
* In case of a negative answer, stop RTP stream
*/
if (MSG_IS_RESPONSE_FOR(response,"INVITE")) {
/* positive response, start RTP stream */
if ((MSG_IS_STATUS_1XX(response)) ||
(MSG_IS_STATUS_2XX(response))) {
/* This is an outgoing response, therefore an outgoing stream */
sts = proxy_rewrite_invitation_body(response, DIR_OUTGOING);
/* megative - stop a possibly started RTP stream */
} else if ((MSG_IS_STATUS_4XX(response)) ||
(MSG_IS_STATUS_5XX(response)) ||
(MSG_IS_STATUS_6XX(response))) {
rtp_stop_fwd(osip_message_get_call_id(response), DIR_INCOMING);
rtp_stop_fwd(osip_message_get_call_id(response), DIR_OUTGOING);
}
} /* if INVITE */
break;
default:
DEBUGC(DBCLASS_PROXY, "response from/to unregistered UA (%s@%s)",
response->from->url->username? response->from->url->username:"******",
response->from->url->host? response->from->url->host : "*NULL*");
return STS_FAILURE;
}
/*
* for ALL incoming response include my Record-Route header.
* The local UA will probably send its answer to the topmost
* Route Header (8.1.2 of RFC3261)
*/
if (type == RESTYP_INCOMING) {
DEBUGC(DBCLASS_PROXY,"Adding my Record-Route");
route_add_recordroute(ticket);
} else {
/*
* outgoing packets must not have my record route header, as
* this likely will contain a private IP address (my inbound).
*/
DEBUGC(DBCLASS_PROXY,"Purging Record-Routes (outgoing packet)");
route_purge_recordroute(ticket);
}
/*
* Determine Next-Hop Address
*/
/*&&&& priority probably should be:
* 1) Route header
* 2) fixed outbound proxy
* 3) SIP URI
*/
/*
* check if we need to send to an outbound proxy
*/
if ((type == RESTYP_OUTGOING) &&
(sip_find_outbound_proxy(ticket, &sendto_addr, &port) == STS_SUCCESS)) {
DEBUGC(DBCLASS_PROXY, "proxy_response: have outbound proxy %s:%i",
utils_inet_ntoa(sendto_addr), port);
/*
* Route present?
* If so, fetch address from topmost Route: header and remove it.
*/
} else if ((type == RESTYP_OUTGOING) &&
(response->routes && !osip_list_eol(response->routes, 0))) {
sts=route_determine_nexthop(ticket, &sendto_addr, &port);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY, "proxy_response: route_determine_nexthop failed");
return STS_FAILURE;
}
DEBUGC(DBCLASS_PROXY, "proxy_response: have Route header to %s:%i",
utils_inet_ntoa(sendto_addr), port);
} else {
/* get target address and port from VIA header */
via = (osip_via_t *) osip_list_get (response->vias, 0);
if (via == NULL) {
ERROR("proxy_response: list_get via failed");
return STS_FAILURE;
}
sts = get_ip_by_host(via->host, &sendto_addr);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_PROXY, "proxy_response: cannot resolve VIA [%s]",
via->host);
return STS_FAILURE;
}
if (via->port) {
port=atoi(via->port);
} else {
port=SIP_PORT;
}
}
sts = sip_message_to_str(response, &buffer, &buflen);
if (sts != 0) {
ERROR("proxy_response: sip_message_to_str failed");
return STS_FAILURE;
}
sipsock_send(sendto_addr, port, ticket->protocol,
buffer, buflen);
osip_free (buffer);
return STS_SUCCESS;
}
int main (int argc, char *argv[])
{
int sts;
int i;
int buflen;
int access;
char buff [BUFFER_SIZE];
sip_ticket_t ticket;
extern char *optarg; /* Defined in libc getopt and unistd.h */
int ch1;
char configfile[64]="siproxd"; /* basename of configfile */
int config_search=1; /* search the config file */
int cmdline_debuglevel=0;
char *pidfilename=NULL;
struct sigaction act;
log_set_stderr(1);
/*
* setup signal handlers
*/
act.sa_handler=sighandler;
sigemptyset(&act.sa_mask);
act.sa_flags=SA_RESTART;
if (sigaction(SIGTERM, &act, NULL)) {
ERROR("Failed to install SIGTERM handler");
}
if (sigaction(SIGINT, &act, NULL)) {
ERROR("Failed to install SIGINT handler");
}
if (sigaction(SIGUSR2, &act, NULL)) {
ERROR("Failed to install SIGUSR2 handler");
}
/*
* prepare default configuration
*/
make_default_config();
log_set_pattern(configuration.debuglevel);
/*
* parse command line
*/
{
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"config", required_argument, NULL, 'c'},
{"debug", required_argument, NULL, 'd'},
{"pid-file", required_argument, NULL,'p'},
{0,0,0,0}
};
while ((ch1 = getopt_long(argc, argv, "hc:d:p:",
long_options, &option_index)) != -1) {
#else /* ! HAVE_GETOPT_LONG */
while ((ch1 = getopt(argc, argv, "hc:d:p:")) != -1) {
#endif
switch (ch1) {
case 'h': /* help */
DEBUGC(DBCLASS_CONFIG,"option: help");
fprintf(stderr,str_helpmsg);
exit(0);
break;
case 'c': /* load config file */
DEBUGC(DBCLASS_CONFIG,"option: config file=%s",optarg);
i=sizeof(configfile)-1;
strncpy(configfile,optarg,i-1);
configfile[i]='\0';
config_search=0;
break;
case 'd': /* set debug level */
DEBUGC(DBCLASS_CONFIG,"option: set debug level: %s",optarg);
cmdline_debuglevel=atoi(optarg);
log_set_pattern(cmdline_debuglevel);
break;
case 'p':
pidfilename = optarg;
break;
default:
DEBUGC(DBCLASS_CONFIG,"no command line options");
break;
}
}
}
/*
* Init stuff
*/
INFO(PACKAGE"-"VERSION"-"BUILDSTR" "UNAME" starting up");
/* read the config file */
if (read_config(configfile, config_search) == STS_FAILURE) exit(1);
/* if a debug level > 0 has been given on the commandline use its
value and not what is in the config file */
if (cmdline_debuglevel != 0) {
configuration.debuglevel=cmdline_debuglevel;
}
/*
* open a the pwfile instance, so we still have access after
* we possibly have chroot()ed to somewhere.
*/
if (configuration.proxy_auth_pwfile) {
siproxd_passwordfile = fopen(configuration.proxy_auth_pwfile, "r");
} else {
siproxd_passwordfile = NULL;
}
/* set debug level as desired */
log_set_pattern(configuration.debuglevel);
log_set_listen_port(configuration.debugport);
/* change user and group IDs */
secure_enviroment();
/* daemonize if requested to */
if (configuration.daemonize) {
DEBUGC(DBCLASS_CONFIG,"daemonizing");
if (fork()!=0) exit(0);
setsid();
if (fork()!=0) exit(0);
log_set_stderr(0);
INFO("daemonized, pid=%i", getpid());
}
/* write PID file of main thread */
if (pidfilename == NULL) pidfilename = configuration.pid_file;
if (pidfilename) {
FILE *pidfile;
DEBUGC(DBCLASS_CONFIG,"creating PID file [%s]", pidfilename);
sts=unlink(configuration.pid_file);
if ((sts==0) ||(errno == ENOENT)) {
if ((pidfile=fopen(pidfilename, "w"))) {
fprintf(pidfile,"%i\n",(int)getpid());
fclose(pidfile);
} else {
WARN("couldn't create new PID file: %s", strerror(errno));
}
} else {
WARN("couldn't delete old PID file: %s", strerror(errno));
}
}
/* initialize the RTP proxy */
sts=rtpproxy_init();
if (sts != STS_SUCCESS) {
ERROR("unable to initialize RTP proxy - aborting");
exit(1);
}
/* init the oSIP parser */
parser_init();
/* listen for incoming messages */
sts=sipsock_listen();
if (sts == STS_FAILURE) {
/* failure to allocate SIP socket... */
ERROR("unable to bind to SIP listening socket - aborting");
exit(1);
}
/* initialize the registration facility */
register_init();
/*
* silence the log - if so required...
*/
log_set_silence(configuration.silence_log);
INFO(PACKAGE"-"VERSION"-"BUILDSTR" "UNAME" started");
/*****************************
* Main loop
*****************************/
while (!exit_program) {
DEBUGC(DBCLASS_BABBLE,"going into sipsock_wait\n");
while (sipsock_wait()<=0) {
/* got no input, here by timeout. do aging */
register_agemap();
/* TCP log: check for a connection */
log_tcp_connect();
/* dump memory stats if requested to do so */
if (dmalloc_dump) {
dmalloc_dump=0;
#ifdef DMALLOC
INFO("SIGUSR2 - DMALLOC statistics is dumped");
dmalloc_log_stats();
dmalloc_log_unfreed();
#else
INFO("SIGUSR2 - DMALLOC support is not compiled in");
#endif
}
if (exit_program) goto exit_prg;
}
/*
* got input, process
*/
DEBUGC(DBCLASS_BABBLE,"back from sipsock_wait");
ticket.direction=0;
buflen=sipsock_read(&buff, sizeof(buff)-1, &ticket.from,
&ticket.protocol);
buff[buflen]='\0';
/*
* evaluate the access lists (IP based filter)
*/
access=accesslist_check(ticket.from);
if (access == 0) {
DEBUGC(DBCLASS_ACCESS,"access for this packet was denied");
continue; /* there are no resources to free */
}
/*
* integrity checks
*/
sts=security_check_raw(buff, buflen);
if (sts != STS_SUCCESS) {
DEBUGC(DBCLASS_SIP,"security check (raw) failed");
continue; /* there are no resources to free */
}
/*
* init sip_msg
*/
sts=osip_message_init(&ticket.sipmsg);
ticket.sipmsg->message=NULL;
if (sts != 0) {
ERROR("osip_message_init() failed... this is not good");
continue; /* skip, there are no resources to free */
}
/*
* RFC 3261, Section 16.3 step 1
* Proxy Behavior - Request Validation - Reasonable Syntax
* (parse the received message)
*/
sts=sip_message_parse(ticket.sipmsg, buff, buflen);
if (sts != 0) {
ERROR("sip_message_parse() failed... this is not good");
DUMP_BUFFER(-1, buff, buflen);
goto end_loop; /* skip and free resources */
}
/*
* integrity checks - parsed buffer
*/
sts=security_check_sip(&ticket);
if (sts != STS_SUCCESS) {
ERROR("security_check_sip() failed... this is not good");
DUMP_BUFFER(-1, buff, buflen);
goto end_loop; /* skip and free resources */
}
/*
* RFC 3261, Section 16.3 step 2
* Proxy Behavior - Request Validation - URI scheme
* (check request URI and refuse with 416 if not understood)
*/
/* NOT IMPLEMENTED */
/*
* RFC 3261, Section 16.3 step 3
* Proxy Behavior - Request Validation - Max-Forwards check
* (check Max-Forwards header and refuse with 483 if too many hops)
*/
{
osip_header_t *max_forwards;
int forwards_count = DEFAULT_MAXFWD;
osip_message_get_max_forwards(ticket.sipmsg, 0, &max_forwards);
if (max_forwards && max_forwards->hvalue) {
forwards_count = atoi(max_forwards->hvalue);
}
DEBUGC(DBCLASS_PROXY,"checking Max-Forwards (=%i)",forwards_count);
if (forwards_count <= 0) {
DEBUGC(DBCLASS_SIP, "Forward count reached 0 -> 483 response");
sip_gen_response(&ticket, 483 /*Too many hops*/);
goto end_loop; /* skip and free resources */
}
}
/*
* RFC 3261, Section 16.3 step 4
* Proxy Behavior - Request Validation - Loop Detection check
* (check for loop and return 482 if a loop is detected)
*/
if (check_vialoop(&ticket) == STS_TRUE) {
/* make sure we don't end up in endless loop when detecting
* an loop in an "loop detected" message - brrr */
if (MSG_IS_RESPONSE(ticket.sipmsg) &&
MSG_TEST_CODE(ticket.sipmsg, 482)) {
DEBUGC(DBCLASS_SIP,"loop in loop-response detected, ignoring");
} else {
DEBUGC(DBCLASS_SIP,"via loop detected, ignoring request");
sip_gen_response(&ticket, 482 /*Loop detected*/);
}
goto end_loop; /* skip and free resources */
}
/*
* RFC 3261, Section 16.3 step 5
* Proxy Behavior - Request Validation - Proxy-Require check
* (check Proxy-Require header and return 420 if unsupported option)
*/
/* NOT IMPLEMENTED */
/*
* RFC 3261, Section 16.5
* Proxy Behavior - Determining Request Targets
*/
/* NOT IMPLEMENTED */
DEBUGC(DBCLASS_SIP,"received SIP type %s:%s",
(MSG_IS_REQUEST(ticket.sipmsg))? "REQ" : "RES",
(MSG_IS_REQUEST(ticket.sipmsg) ?
((ticket.sipmsg->sip_method)?
ticket.sipmsg->sip_method : "NULL") :
((ticket.sipmsg->reason_phrase) ?
ticket.sipmsg->reason_phrase : "NULL")));
/*********************************
* The message did pass all the
* tests above and is now ready
* to be proxied.
* Before we do so, we apply some
* additional preprocessing
*********************************/
/* Dial shortcuts */
if (configuration.pi_shortdial) {
sts = plugin_shortdial(&ticket);
if (sts == STS_SIP_SENT) goto end_loop;
}
/*********************************
* finally proxy the message.
* This includes the masquerading
* of the local UA and starting/
* stopping the RTP proxy for this
* call
*********************************/
/*
* if a REQ REGISTER, check if it is directed to myself,
* or am I just the outbound proxy but no registrar.
* - If I'm the registrar, register & generate answer
* - If I'm just the outbound proxy, register, rewrite & forward
*/
if (MSG_IS_REGISTER(ticket.sipmsg) &&
MSG_IS_REQUEST(ticket.sipmsg)) {
if (access & ACCESSCTL_REG) {
osip_uri_t *url;
struct in_addr addr1, addr2, addr3;
int dest_port;
url = osip_message_get_uri(ticket.sipmsg);
dest_port= (url->port)?atoi(url->port):SIP_PORT;
if ( (get_ip_by_host(url->host, &addr1) == STS_SUCCESS) &&
(get_interface_ip(IF_INBOUND,&addr2) == STS_SUCCESS) &&
(get_interface_ip(IF_OUTBOUND,&addr3) == STS_SUCCESS)) {
if ((configuration.sip_listen_port == dest_port) &&
((memcmp(&addr1, &addr2, sizeof(addr1)) == 0) ||
(memcmp(&addr1, &addr3, sizeof(addr1)) == 0))) {
/* I'm the registrar, send response myself */
sts = register_client(&ticket, 0);
sts = register_response(&ticket, sts);
} else {
/* I'm just the outbound proxy */
DEBUGC(DBCLASS_SIP,"proxying REGISTER request to:%s",
url->host);
sts = register_client(&ticket, 1);
if (sts == STS_SUCCESS) {
sts = proxy_request(&ticket);
}
}
} else {
sip_gen_response(&ticket, 408 /*request timeout*/);
}
} else {
WARN("non-authorized registration attempt from %s",
utils_inet_ntoa(ticket.from.sin_addr));
}
/*
* check if outbound interface is UP.
* If not, send back error to UA and
* skip any proxying attempt
*/
} else if (get_interface_ip(IF_OUTBOUND,NULL) !=
STS_SUCCESS) {
DEBUGC(DBCLASS_SIP, "got a %s to proxy, but outbound interface "
"is down", (MSG_IS_REQUEST(ticket.sipmsg))? "REQ" : "RES");
if (MSG_IS_REQUEST(ticket.sipmsg))
sip_gen_response(&ticket, 408 /*request timeout*/);
/*
* MSG is a request, add current via entry,
* do a lookup in the URLMAP table and
* send to the final destination
*/
} else if (MSG_IS_REQUEST(ticket.sipmsg)) {
if (access & ACCESSCTL_SIP) {
sts = proxy_request(&ticket);
} else {
INFO("non-authorized request received from %s",
utils_inet_ntoa(ticket.from.sin_addr));
}
/*
* MSG is a response, remove current via and
* send to the next VIA in chain
*/
} else if (MSG_IS_RESPONSE(ticket.sipmsg)) {
if (access & ACCESSCTL_SIP) {
sts = proxy_response(&ticket);
} else {
INFO("non-authorized response received from %s",
utils_inet_ntoa(ticket.from.sin_addr));
}
/*
* unsupported message
*/
} else {
ERROR("received unsupported SIP type %s %s",
(MSG_IS_REQUEST(ticket.sipmsg))? "REQ" : "RES",
ticket.sipmsg->sip_method);
}
/*********************************
* Done with proxying. Message
* has been sent to its destination.
*********************************/
/*
* free the SIP message buffers
*/
end_loop:
osip_message_free(ticket.sipmsg);
} /* while TRUE */
exit_prg:
/* save current known SIP registrations */
register_save();
INFO("properly terminating siproxd");
/* remove PID file */
if (pidfilename) {
DEBUGC(DBCLASS_CONFIG,"deleting PID file [%s]", pidfilename);
sts=unlink(pidfilename);
if (sts != 0) {
WARN("couldn't delete old PID file: %s", strerror(errno));
}
}
/* END */
return 0;
} /* main */
/*
* Signal handler
*
* this one is called asynchronously whevener a registered
* signal is applied. Just set a flag and don't do any funny
* things here.
*/
static void sighandler(int sig) {
if (sig==SIGTERM) exit_program=1;
if (sig==SIGINT) exit_program=1;
if (sig==SIGUSR2) dmalloc_dump=1;
return;
}
/*
* main() of rtpproxy
*/
static void *rtpproxy_main(void *arg) {
struct timeval tv;
fd_set fdset;
int fd_max;
time_t t, last_t=0;
int i, sts;
int num_fd;
osip_call_id_t callid;
static char rtp_buff[RTP_BUFFER_SIZE];
int count;
memcpy(&fdset, &master_fdset, sizeof(fdset));
fd_max=master_fd_max;
/* loop forever... */
for (;;) {
tv.tv_sec = 5;
tv.tv_usec = 0;
num_fd=select(fd_max+1, &fdset, NULL, NULL, &tv);
pthread_testcancel();
if ((num_fd<0) && (errno==EINTR)) {
/*
* wakeup due to a change in the proxy table:
* lock mutex, copy master FD set and unlock
*/
pthread_mutex_lock(&rtp_proxytable_mutex);
memcpy(&fdset, &master_fdset, sizeof(fdset));
fd_max=master_fd_max;
pthread_mutex_unlock(&rtp_proxytable_mutex);
continue;
}
time(&t);
/*
* LOCK the MUTEX
*/
pthread_mutex_lock(&rtp_proxytable_mutex);
/* check for data available and send to destination */
for (i=0;(i<RTPPROXY_SIZE) && (num_fd>0);i++) {
if ( (rtp_proxytable[i].rtp_rx_sock != 0) &&
FD_ISSET(rtp_proxytable[i].rtp_rx_sock, &fdset) ) {
/* yup, have some data to send */
num_fd--;
/* read from sock rtp_proxytable[i].sock*/
count=read(rtp_proxytable[i].rtp_rx_sock, rtp_buff, RTP_BUFFER_SIZE);
/* check if something went banana */
if (count < 0) {
/*
* It has been seen on linux 2.2.x systems that for some
* reason (ICMP issue? -> below) inside the RTP relay, select()
* claims that a certain file descriptor has data available to
* read, a subsequent call to read() or recv() then does block!!
* So lets make the FD's we are going to use non-blocking, so
* we will at least survive and not run into a deadlock.
*
* We catch this here with this workaround (pronounce "HACK")
* and hope that next time we pass by it will be ok again.
*/
if (errno == EAGAIN) {
/* I may want to remove this WARNing */
WARN("read() [fd=%i, %s:%i] would block, but select() "
"claimed to be readable!",
rtp_proxytable[i].rtp_rx_sock,
utils_inet_ntoa(rtp_proxytable[i].local_ipaddr),
rtp_proxytable[i].local_port);
continue;
}
/*
* I *MAY* receive ICMP destination unreachable messages when I
* try to send RTP traffic to a destination that is in HOLD
* (better: is not listening on the UDP port where I send
* my RTP data to).
* So I should *not* do this - or ignore errors originating
* by this -> ECONNREFUSED
*
* Note: This error is originating from a previous send() on the
* same socket and has nothing to do with the read() we have
* done above!
*/
if (errno != ECONNREFUSED) {
/* some other error that I probably want to know about */
int j;
WARN("read() [fd=%i, %s:%i] returned error [%i:%s]",
rtp_proxytable[i].rtp_rx_sock,
utils_inet_ntoa(rtp_proxytable[i].local_ipaddr),
rtp_proxytable[i].local_port, errno, strerror(errno));
for (j=0; j<RTPPROXY_SIZE;j++) {
DEBUGC(DBCLASS_RTP, "%i - rx:%i tx:%i %s@%s dir:%i "
"lp:%i, rp:%i rip:%s",
j,
rtp_proxytable[j].rtp_rx_sock,
rtp_proxytable[j].rtp_tx_sock,
rtp_proxytable[j].callid_number,
rtp_proxytable[j].callid_host,
rtp_proxytable[j].direction,
rtp_proxytable[j].local_port,
rtp_proxytable[j].remote_port,
utils_inet_ntoa(rtp_proxytable[j].remote_ipaddr));
} /* for j */
} /* if errno != ECONNREFUSED */
} /* count < 0 */
/*
* forwarding an RTP packet only makes sense if we really
* have got some data in it (count > 0)
*/
if (count > 0) {
/* find the corresponding TX socket */
if (rtp_proxytable[i].rtp_tx_sock == 0) {
int j;
int rtp_direction = rtp_proxytable[i].direction;
int media_stream_no = rtp_proxytable[i].media_stream_no;
callid.number = rtp_proxytable[i].callid_number;
callid.host = rtp_proxytable[i].callid_host;
for (j=0;(j<RTPPROXY_SIZE);j++) {
char *client_id = rtp_proxytable[i].client_id;
osip_call_id_t cid;
cid.number = rtp_proxytable[j].callid_number;
cid.host = rtp_proxytable[j].callid_host;
/* match on:
* - same call ID
* - same media stream
* - opposite direction
* - different client ID
*/
if ( (rtp_proxytable[j].rtp_rx_sock != 0) &&
(compare_callid(&callid, &cid) == STS_SUCCESS) &&
(media_stream_no == rtp_proxytable[j].media_stream_no) &&
(rtp_direction != rtp_proxytable[j].direction) &&
(strcmp(rtp_proxytable[j].client_id, client_id) != 0) ) {
rtp_proxytable[i].rtp_tx_sock = rtp_proxytable[j].rtp_rx_sock;
DEBUGC(DBCLASS_RTP, "connected entry %i (fd=%i) <-> entry %i (fd=%i)",
j, rtp_proxytable[j].rtp_rx_sock,
i, rtp_proxytable[i].rtp_rx_sock);
break;
}
}
} /* rtp_tx_sock == 0 */
if (rtp_proxytable[i].rtp_tx_sock != 0) {
/* write to dest via socket rtp_tx_sock */
struct sockaddr_in dst_addr;
dst_addr.sin_family = AF_INET;
memcpy(&dst_addr.sin_addr.s_addr,
&rtp_proxytable[i].remote_ipaddr,
sizeof(struct in_addr));
dst_addr.sin_port= htons(rtp_proxytable[i].remote_port);
sts = sendto(rtp_proxytable[i].rtp_tx_sock, rtp_buff,
count, 0, (const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
if (sts == -1) {
if (errno != ECONNREFUSED) {
ERROR("sendto() [%s:%i size=%i] call failed: %s",
utils_inet_ntoa(rtp_proxytable[i].remote_ipaddr),
rtp_proxytable[i].remote_port, count, strerror(errno));
/* if sendto() fails with bad filedescriptor,
* this means that the opposite stream has been
* canceled or timed out.
* we should then cancel this stream as well.*/
WARN("stopping opposite stream");
/* don't lock the mutex, as we own the lock */
callid.number=rtp_proxytable[i].callid_number;
callid.host=rtp_proxytable[i].callid_host;
rtp_relay_stop_fwd(&callid, rtp_proxytable[i].direction, 1);
}
}
}
} /* count > 0 */
/* update timestamp of last usage */
rtp_proxytable[i].timestamp=t;
}
} /* for i */
/*
* age and clean rtp_proxytable (check every 10 seconds)
*/
if (t > (last_t+10) ) {
last_t = t;
for (i=0;i<RTPPROXY_SIZE; i++) {
if ( (rtp_proxytable[i].rtp_rx_sock != 0) &&
((rtp_proxytable[i].timestamp+configuration.rtp_timeout)<t)) {
/* this one has expired, clean it up */
callid.number=rtp_proxytable[i].callid_number;
callid.host=rtp_proxytable[i].callid_host;
DEBUGC(DBCLASS_RTP,"RTP stream rx_sock=%i tx_sock=%i "
"%s@%s (idx=%i) has expired",
rtp_proxytable[i].rtp_rx_sock,
rtp_proxytable[i].rtp_tx_sock,
callid.number, callid.host, i);
/* don't lock the mutex, as we own the lock already here */
rtp_relay_stop_fwd(&callid, rtp_proxytable[i].direction, 1);
}
}
} /* if (t>...) */
/* copy master FD set */
memcpy(&fdset, &master_fdset, sizeof(fdset));
fd_max=master_fd_max;
/*
* UNLOCK the MUTEX
*/
pthread_mutex_unlock(&rtp_proxytable_mutex);
} /* for(;;) */
return NULL;
}
/*
* binds to SIP UDP socket for listening to incoming packets
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
*/
int sipsock_listen (void) {
struct in_addr ipaddr;
/* start of AU4D00875 by d00107688 to support bind 2008-10-15*/
struct in_addr wanipaddr;
/* end of AU4D00875 by d00107688 to support bind 2008-10-15*/
int i = 0;
memset(&ipaddr, 0, sizeof(ipaddr));
/* start of AU4D00875 by d00107688 to support bind 2008-10-15*/
memset(&wanipaddr, 0, sizeof(wanipaddr));
if (STS_FAILURE == get_ip_by_ifname(configuration.outbound_if, &wanipaddr))
{
ERROR("%s ip: %s", configuration.inbound_if, utils_inet_ntoa(wanipaddr));
ERROR("can not get the ip , please check it.......");
}
else
{
g_lsockFlg = 1;
}
/* end of AU4D00875 by d00107688 to support bind 2008-10-15*/
/* start of AU4D00875 by d00107688 to support bind 2008-10-15*/
if (1 == g_lsockFlg)
{
sip_udp_socket = sockbind(ipaddr, configuration.sip_listen_port, 1);
sip_udp_wan_socket = sockbind(wanipaddr, wanport, 1);
if (0 == sip_udp_wan_socket)
{
for (i = 0; i < 5; i++)
{
wanport += (i * 10 + i);
sip_udp_wan_socket = sockbind(wanipaddr, wanport, 1);
if (0 == sip_udp_wan_socket)
{
ERROR("bind in port: %d error", wanport);
continue;
}
else
{
break;
}
}
}
if ((0 == sip_udp_socket) || (0 == sip_udp_wan_socket))
{
ERROR("socket bind error");
return STS_FAILURE; /* failure */
}
}
else
{
sip_udp_socket = sockbind(ipaddr, configuration.sip_listen_port, 1);
if (sip_udp_socket == 0) return STS_FAILURE; /* failure*/
}
INFO("bound to port %i", configuration.sip_listen_port);
DEBUGC(DBCLASS_NET,"bound socket %i",sip_udp_socket);
/* end of AU4D00875 by d00107688 to support bind 2008-10-15*/
return STS_SUCCESS;
}
/*
* sends an UDP datagram to the specified destination
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE on error
* 函数修改说明:
* 修改人: l67187
* 修改目的: 解决代理和绑定时没有默认路由，sip alg无法工作的问题
* 修改方案: 在报文发送时，bind上网关发送侧的ip地址，使用网关源地址路由
* 具体修改: 原alg 使用 初始化时创建的 sip_udp_socket，绑定了空地址
* 无法再次绑定，修改后，在该函数中不在使用 sip_udp_socket发送报文
* 而是重新创建一个socket发送，之后就关闭释放资源
*/
int sipsock_send(struct in_addr addr, int port, int protocol,
char *buffer, int size) {
struct sockaddr_in dst_addr;
struct sockaddr_in stLocalAddr;
int sock;
int sts = -1;
/* first time: allocate a socket for sending
if (sip_udp_socket == 0) {
ERROR("SIP socket not allocated");
return STS_FAILURE;
}
*/
if (buffer == NULL) {
ERROR("sipsock_send got NULL buffer");
return STS_FAILURE;
}
if (protocol != PROTO_UDP) {
ERROR("sipsock_send: only UDP supported by now");
return STS_FAILURE;
}
if (1 == g_lsockFlg)
{
dst_addr.sin_family = AF_INET;
memcpy(&dst_addr.sin_addr.s_addr, &addr, sizeof(struct in_addr));
dst_addr.sin_port= htons(port);
if ((1 == IpisInNet(utils_inet_ntoa(addr), g_acBrIpAddr, g_acBrMask))
|| (1 == IpisInNet(utils_inet_ntoa(addr), g_acPPPoEIpAddr, g_acPPPoEMask)))
{
sts = sendto(sip_udp_socket, buffer, size, 0,
(const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
}
else /* wan 侧 */
{
// TODO: 这里需要优化，目前PPPoE代理的时候没有默认路由
// 因此需要进行判断，如果没有默认路由那么就需要使用使用sip_udp_wan_socket
// 发包，否则一直使用 sip_udp_socket 发包
// if (没有默认路由)
if (0 != sip_udp_wan_socket)
{
sts = sendto(sip_udp_wan_socket, buffer, size, 0,
(const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
}
else if (0 == sip_udp_wan_socket)
{
sts = sendto(sip_udp_socket, buffer, size, 0,
(const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
}
else
{
ERROR("no proper socket fd to send out");
}
}
if (sts == -1) {
if (errno != ECONNREFUSED) {
ERROR("sendto() [%s:%i size=%i] call failed: %s",
utils_inet_ntoa(addr),
port, size, strerror(errno));
return STS_FAILURE;
}
DEBUGC(DBCLASS_BABBLE,"sendto() [%s:%i] call failed: %s",
utils_inet_ntoa(addr), port, strerror(errno));
}
}
else
{
sock=socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0) {
printsip("Sip: socket() call failed: %s",strerror(errno));
return STS_FAILURE;
}
dst_addr.sin_family = AF_INET;
memcpy(&dst_addr.sin_addr.s_addr, &addr, sizeof(struct in_addr));
dst_addr.sin_port= htons(port);
DEBUGC(DBCLASS_NET,"send UDP packet to %s: %i", utils_inet_ntoa(addr),port);
printsip("Sip:send UDP packet to %s: %i\r\n", utils_inet_ntoa(addr),port);
DUMP_BUFFER(DBCLASS_NETTRAF, buffer, size);
/* 本地发送源 */
bzero(&stLocalAddr, 0);
/* 目的ip为LAN侧ip */
if ((1 == IpisInNet(utils_inet_ntoa(addr), g_acBrIpAddr, g_acBrMask))
|| (1 == IpisInNet(utils_inet_ntoa(addr), g_acPPPoEIpAddr, g_acPPPoEMask)))
{
get_ip_by_ifname(configuration.inbound_if, &stLocalAddr.sin_addr);
}
else
{
get_ip_by_ifname(configuration.outbound_if, &stLocalAddr.sin_addr);
}
/*
if (g_lPacketDir == 0)
{
get_ip_by_ifname(configuration.outbound_if,&stLocalAddr.sin_addr);
// stLocalAddr.sin_port = htons(atoi(pszLocalPort));
}
else
{
get_ip_by_ifname(configuration.inbound_if,&stLocalAddr.sin_addr);
// stLocalAddr.sin_port = htons(atoi(pszLocalPort));
}
*/
stLocalAddr.sin_family = AF_INET;
if (bind(sock, (struct sockaddr *)&stLocalAddr, sizeof(stLocalAddr)) < 0)
{
perror("bind");
}
else
{
printsip("Sip: bind src ip:[%s]\r\n", inet_ntoa(stLocalAddr.sin_addr));
}
// if (0 != sip_udp_socket)
#if 0
if ((1 == IpisInNet(utils_inet_ntoa(addr), g_acBrIpAddr, g_acBrMask))
|| (1 == IpisInNet(utils_inet_ntoa(addr), g_acPPPoEIpAddr, g_acPPPoEMask)))
#else
if (0)
#endif
{
sts = sendto(sock, buffer, size, 0,
(const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
}
else if (0 != sip_udp_socket)
{
sts = sendto(sip_udp_socket, buffer, size, 0,
(const struct sockaddr *)&dst_addr,
(socklen_t)sizeof(dst_addr));
}
else
{
printf("no proper socket found \r\n");
}
if (sts == -1) {
if (errno != ECONNREFUSED) {
ERROR("sendto() [%s:%i size=%i] call failed: %s",
utils_inet_ntoa(addr),
port, size, strerror(errno));
close(sock);
return STS_FAILURE;
}
DEBUGC(DBCLASS_BABBLE,"sendto() [%s:%i] call failed: %s",
utils_inet_ntoa(addr), port, strerror(errno));
}
close(sock);
}
return STS_SUCCESS;
}
/*
* check if a given request is addressed to local. I.e. it is addressed
* to the proxy itself (IP of my inbound or outbound interface, same port)
*
* RETURNS
* STS_TRUE if the request is addressed local
* STS_FALSE otherwise
*/
int is_sipuri_local (sip_ticket_t *ticket) {
osip_message_t *sip=ticket->sipmsg;
int found;
struct in_addr addr_uri, addr_myself;
char *my_interfaces[]=
{ configuration.inbound_if, configuration.outbound_if, (char*)-1 };
int port;
int i;
char *ptr;
if (sip==NULL) {
ERROR("called is_sipuri_local with NULL sip");
return STS_FALSE;
}
if (!sip || !sip->req_uri) {
ERROR("is_sipuri_local: no request URI present");
return STS_FALSE;
}
DEBUGC(DBCLASS_DNS,"check for local SIP URI %s:%s",
sip->req_uri->host? sip->req_uri->host : "*NULL*",
sip->req_uri->port? sip->req_uri->port : "*NULL*");
if (utils_inet_aton(sip->req_uri->host, &addr_uri) == 0) {
/* need name resolution */
get_ip_by_host(sip->req_uri->host, &addr_uri);
}
found=0;
for (i=0; ; i++) {
/*
* try to search by interface name first
*/
ptr=my_interfaces[i];
if (ptr==(char*)-1) break; /* end of list mark */
if (ptr) {
DEBUGC(DBCLASS_BABBLE,"resolving IP of interface %s",ptr);
if (get_ip_by_ifname(ptr, &addr_myself) != STS_SUCCESS) {
ERROR("can't find interface %s - configuration error?", ptr);
continue;
}
}
/* check the extracted HOST against my own host addresses */
if (sip->req_uri->port) {
port=atoi(sip->req_uri->port);
} else {
port=SIP_PORT;
}
if ( (memcmp(&addr_myself, &addr_uri, sizeof(addr_myself))==0) &&
(port == configuration.sip_listen_port) ) {
DEBUG("address match [%s]", utils_inet_ntoa(addr_uri));
found=1;
break;
}
}
DEBUGC(DBCLASS_DNS, "SIP URI is %slocal", found? "":"not ");
return (found)? STS_TRUE : STS_FALSE;
}
/*
* check if a given osip_via_t is local. I.e. its address is owned
* by my inbound or outbound interface
*
* RETURNS
* STS_TRUE if the given VIA is one of my interfaces
* STS_FALSE otherwise
*/
int is_via_local (osip_via_t *via, struct in_addr *local_ip) {
int sts, found;
struct in_addr addr_via, addr_myself;
char *my_interfaces[]=
{ configuration.inbound_if, configuration.outbound_if, (char*)-1 };
int port;
int i;
char *ptr;
if (via==NULL) {
ERROR("called is_via_local with NULL via");
return STS_FALSE;
}
DEBUGC(DBCLASS_BABBLE,"via name %s",via->host);
if (utils_inet_aton(via->host,&addr_via) == 0) {
/* need name resolution */
sts=get_ip_by_host(via->host, &addr_via);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_DNS, "is_via_local: cannot resolve VIA [%s]",
via->host);
return STS_FAILURE;
}
}
/* check the extracted VIA against my own host addresses */
if (via->port) port=atoi(via->port);
else port=SIP_PORT;
/* Check local_ip if defined */
if (local_ip) {
if ( (memcmp(&addr_via, local_ip, sizeof(addr_via))==0) &&
(port == configuration.sip_listen_port) ) {
DEBUGC(DBCLASS_BABBLE,"via is local due to local_ip");
return STS_TRUE;
}
}
found=0;
for (i=0; ; i++) {
/*
* try to search by interface name first
*/
ptr=my_interfaces[i];
if (ptr==(char*)-1) break; /* end of list mark */
if (ptr) {
DEBUGC(DBCLASS_BABBLE,"resolving IP of interface %s",ptr);
if (get_ip_by_ifname(ptr, &addr_myself) != STS_SUCCESS) {
ERROR("can't find interface %s - configuration error?", ptr);
continue;
}
}
if ( (memcmp(&addr_myself, &addr_via, sizeof(addr_myself))==0) &&
(port == configuration.sip_listen_port) ) {
DEBUG("got address match [%s]", utils_inet_ntoa(addr_via));
found=1;
break;
}
}
return (found)? STS_TRUE : STS_FALSE;
}
/*
* SIP_IS_OUTGOING
*
* Figures out if this is an outgoing or incoming request/response.
* The direction is stored in the ticket->direction property.
*
* RETURNS
* STS_SUCCESS on success
* STS_FAILURE if unable to determine
*/
int sip_find_direction(sip_ticket_t *ticket, int *urlidx) {
int type;
int i, sts;
struct sockaddr_in *from;
osip_message_t *request;
osip_message_t *response;
from=&ticket->from;
request=ticket->sipmsg;
response=ticket->sipmsg;
type = 0;
ticket->direction = 0;
/*
* did I receive the telegram from a REGISTERED host?
* -> it must be an OUTGOING request
*/
for (i=0; i<URLMAP_SIZE; i++) {
struct in_addr tmp_addr;
if (urlmap[i].active == 0) continue;
if (get_ip_by_host(urlmap[i].true_url->host, &tmp_addr) == STS_FAILURE) {
DEBUGC(DBCLASS_SIP, "sip_find_direction: cannot resolve host [%s]",
urlmap[i].true_url->host);
} else {
DEBUGC(DBCLASS_SIP, "sip_find_direction: reghost:%s ip:%s",
urlmap[i].true_url->host, utils_inet_ntoa(from->sin_addr));
if (memcmp(&tmp_addr, &from->sin_addr, sizeof(tmp_addr)) == 0) {
if (MSG_IS_REQUEST(ticket->sipmsg)) {
type=REQTYP_OUTGOING;
} else {
type=RESTYP_OUTGOING;
}
break;
}
}
}
/*
* is the telegram directed to an internally registered host?
* -> it must be an INCOMING request
*/
if (type == 0) {
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* RFC3261:
* 'To' contains a display name (Bob) and a SIP or SIPS URI
* (sip:[email protected]) towards which the request was originally
* directed. Display names are described in RFC 2822 [3].
*/
/* So this means, that we must check the SIP URI supplied with the
* INVITE method, as this points to the real wanted target.
* Q: does there exist a situation where the SIP URI itself does
* point to "somewhere" but the To: points to the correct UA?
* So for now, we just look at both of them (SIP URI and To: header)
*/
if (MSG_IS_REQUEST(ticket->sipmsg)) {
/* REQUEST */
/* incoming request (SIP URI == 'masq') || ((SIP URI == 'reg') && !REGISTER)*/
if ((compare_url(request->req_uri, urlmap[i].masq_url)==STS_SUCCESS) ||
(!MSG_IS_REGISTER(request) &&
(compare_url(request->req_uri, urlmap[i].reg_url)==STS_SUCCESS))) {
type=REQTYP_INCOMING;
break;
}
/* incoming request ('to' == 'masq') || (('to' == 'reg') && !REGISTER)*/
if ((compare_url(request->to->url, urlmap[i].masq_url)==STS_SUCCESS) ||
(!MSG_IS_REGISTER(request) &&
(compare_url(request->to->url, urlmap[i].reg_url)==STS_SUCCESS))) {
type=REQTYP_INCOMING;
break;
}
} else {
/* RESPONSE */
/* incoming response ('from' == 'masq') || ('from' == 'reg') */
if ((compare_url(response->from->url, urlmap[i].reg_url)==STS_SUCCESS) ||
(compare_url(response->from->url, urlmap[i].masq_url)==STS_SUCCESS)) {
type=RESTYP_INCOMING;
break;
}
} /* is request */
} /* for i */
} /* if type == 0 */
if (MSG_IS_RESPONSE(ticket->sipmsg)) {
/* &&&& Open Issue &&&&
it has been seen with cross-provider calls that the FROM may be 'garbled'
(e.g [email protected] for calls made sipphone -> FWD)
How can we deal with this? Should I take into consideration the 'Via'
headers? This is the only clue I have, pointing to the *real* UA.
Maybe I should put in a 'siproxd' ftag value to recognize it as a header
inserted by myself
*/
if ((type == 0) && (!osip_list_eol(response->vias, 0))) {
osip_via_t *via;
struct in_addr addr_via, addr_myself;
int port_via, port_ua;
/* get the via address */
via = (osip_via_t *) osip_list_get (response->vias, 0);
DEBUGC(DBCLASS_SIP, "sip_find_direction: check via [%s] for "
"registered UA",via->host);
sts=get_ip_by_host(via->host, &addr_via);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_SIP, "sip_find_direction: cannot resolve VIA [%s]",
via->host);
} else {
for (i=0; i<URLMAP_SIZE; i++) {
if (urlmap[i].active == 0) continue;
/* incoming response (1st via in list points to a registered UA) */
sts=get_ip_by_host(urlmap[i].true_url->host, &addr_myself);
if (sts == STS_FAILURE) {
DEBUGC(DBCLASS_SIP, "sip_find_direction: cannot resolve "
"true_url [%s]", via->host);
continue;
}
port_via=0;
if (via->port) port_via=atoi(via->port);
if (port_via <= 0) port_via=SIP_PORT;
port_ua=0;
if (urlmap[i].true_url->port)
port_ua=atoi(urlmap[i].true_url->port);
if (port_ua <= 0) port_ua=SIP_PORT;
DEBUGC(DBCLASS_SIP, "sip_find_direction: checking for registered "
"host [%s:%i] <-> [%s:%i]",
urlmap[i].true_url->host, port_ua,
via->host, port_via);
if ((memcmp(&addr_myself, &addr_via, sizeof(addr_myself))==0) &&
(port_via == port_ua)) {
type=RESTYP_INCOMING;
break;
}
} /* for i */
}
} /* if type == 0 */
} /* is response */
if (type == 0) {
DEBUGC(DBCLASS_SIP, "sip_find_direction: unable to determine "
"direction of SIP packet");
return STS_FAILURE;
}
ticket->direction=type;
if (urlidx) *urlidx=i;
return STS_SUCCESS;
}
