proxy.c

/*
 * proxy list & assoc. functions
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of opensips, a free SIP server.
 *
 * opensips is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * opensips is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * History:
 * -------
 *  2003-02-13  all *proxy functions are now proto aware (andrei)
 *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
 *  2007-01-25  support for DNS failover added into proxy structure;
 *              new shm functions for copy/free added (bogdan)
 */



#include "config.h"
#include "globals.h"
#include "proxy.h"
#include "error.h"
#include "dprint.h"
#include "mem/mem.h"
#include "mem/shm_mem.h"

#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>

#ifdef DNS_IP_HACK
#include "ut.h"
#endif

#include "resolve.h"
#include "ip_addr.h"
#include "globals.h"


struct proxy_l* proxies=0;

int disable_dns_failover=0;


int hostent_shm_cpy(struct hostent *dst, struct hostent* src)
{
	unsigned int len;
	int  i;
	char *p;

	len = strlen(src->h_name)+1;
	dst->h_name = (char*)shm_malloc(sizeof(char) * len);
	if (dst->h_name) strncpy(dst->h_name, src->h_name, len);
	else return -1;

	for( i=0 ; src->h_addr_list[i] ; i++ );

	dst->h_addr_list = (char**)shm_malloc
		(i * (src->h_length + sizeof(char*)) + sizeof(char*));
	if (dst->h_addr_list==NULL) {
		shm_free(dst->h_name);
		return -1;
	}

	p = ((char*)dst->h_addr_list) + (i+1)*sizeof(char*);
	dst->h_addr_list[i] = 0;

	for( i-- ; i>=0 ; i-- ) {
		dst->h_addr_list[i] = p;
		memcpy( dst->h_addr_list[i], src->h_addr_list[i], src->h_length );
		p += src->h_length;
	}

	dst->h_addr = dst->h_addr_list[0];
	dst->h_addrtype = src->h_addrtype;
	dst->h_length = src->h_length;
	return 0;
}


void free_shm_hostent(struct hostent *dst)
{
	if (dst->h_name)
		shm_free(dst->h_name);
	if (dst->h_addr_list)
		shm_free(dst->h_addr_list);
}


/* copies a hostent structure*, returns 0 on success, <0 on error*/
int hostent_cpy(struct hostent *dst, struct hostent* src)
{
	unsigned int len,len2, i, r;
	int ret;

	/* start copying the host entry.. */
	/* copy h_name */
	len=strlen(src->h_name)+1;
	dst->h_name=(char*)pkg_malloc(sizeof(char) * len);
	if (dst->h_name) strncpy(dst->h_name,src->h_name, len);
	else{
		ser_error=ret=E_OUT_OF_MEM;
		goto error;
	}

	/* copy h_aliases */
	len=0;
	if (src->h_aliases)
		for (;src->h_aliases[len];len++);
	dst->h_aliases=(char**)pkg_malloc(sizeof(char*)*(len+1));
	if (dst->h_aliases==0){
		ser_error=ret=E_OUT_OF_MEM;
		pkg_free(dst->h_name);
		goto error;
	}
	memset((void*)dst->h_aliases, 0, sizeof(char*) * (len+1) );
	for (i=0;i<len;i++){
		len2=strlen(src->h_aliases[i])+1;
		dst->h_aliases[i]=(char*)pkg_malloc(sizeof(char)*len2);
		if (dst->h_aliases[i]==0){
			ser_error=ret=E_OUT_OF_MEM;
			pkg_free(dst->h_name);
			for(r=0; r<i; r++)	pkg_free(dst->h_aliases[r]);
			pkg_free(dst->h_aliases);
			goto error;
		}
		strncpy(dst->h_aliases[i], src->h_aliases[i], len2);
	}
	/* copy h_addr_list */
	len=0;
	if (src->h_addr_list)
		for (;src->h_addr_list[len];len++);
	dst->h_addr_list=(char**)pkg_malloc(sizeof(char*)*(len+1));
	if (dst->h_addr_list==0){
		ser_error=ret=E_OUT_OF_MEM;
		pkg_free(dst->h_name);
		for(r=0; dst->h_aliases[r]; r++)	pkg_free(dst->h_aliases[r]);
		pkg_free(dst->h_aliases);
		goto error;
	}
	memset((void*)dst->h_addr_list, 0, sizeof(char*) * (len+1) );
	for (i=0;i<len;i++){
		dst->h_addr_list[i]=(char*)pkg_malloc(sizeof(char)*src->h_length);
		if (dst->h_addr_list[i]==0){
			ser_error=ret=E_OUT_OF_MEM;
			pkg_free(dst->h_name);
			for(r=0; dst->h_aliases[r]; r++)	pkg_free(dst->h_aliases[r]);
			pkg_free(dst->h_aliases);
			for (r=0; r<i;r++) pkg_free(dst->h_addr_list[r]);
			pkg_free(dst->h_addr_list);
			goto error;
		}
		memcpy(dst->h_addr_list[i], src->h_addr_list[i], src->h_length);
	}

	/* copy h_addr_type & length */
	dst->h_addrtype=src->h_addrtype;
	dst->h_length=src->h_length;
	/*finished hostent copy */

	return 0;

error:
	LM_CRIT("pkg memory allocation failure\n");
	return ret;
}



void free_hostent(struct hostent *dst)
{
	int r;
	if (dst->h_name) pkg_free(dst->h_name);
	if (dst->h_aliases){
		for(r=0; dst->h_aliases[r]; r++) {
			pkg_free(dst->h_aliases[r]);
		}
		pkg_free(dst->h_aliases);
	}
	if (dst->h_addr_list){
		for (r=0; dst->h_addr_list[r];r++) {
			pkg_free(dst->h_addr_list[r]);
		}
		pkg_free(dst->h_addr_list);
	}
}



/* Creates a proxy structure out of the host, port and proto
 * uses also SRV if possible & port==0 (quick hack) */

struct proxy_l* mk_proxy(str* name, unsigned short port, unsigned short proto,
		int is_sips)
{
	struct proxy_l* p;
	struct hostent* he;

	p=(struct proxy_l*) pkg_malloc(sizeof(struct proxy_l));
	if (p==0){
		ser_error=E_OUT_OF_MEM;
		LM_CRIT("pkg memory allocation failure\n");
		goto error;
	}
	memset(p,0,sizeof(struct proxy_l));
	p->name=*name;
	p->port=port;
	p->proto=proto;

	LM_DBG("doing DNS lookup...\n");
	he = sip_resolvehost(name, &(p->port), &p->proto, is_sips,
		disable_dns_failover?0:&p->dn );
	if (!he || !he->h_addr_list[0]) {
		ser_error=E_BAD_ADDRESS;
		LM_CRIT("could not resolve hostname: \"%.*s\"%s\n",
		        name->len, name->s, he ? " (0 results)" : "");
		pkg_free(p);
		goto error;
	}
	if (hostent_cpy(&(p->host), he)!=0){
		free_dns_res( p );
		pkg_free(p);
		goto error;
	}
	return p;
error:
	return 0;
}



/* same as mk_proxy, but in shared memory
 * uses also SRV if possible & port==0 (quick hack) */
struct proxy_l* mk_proxy_from_ip(struct ip_addr* ip, unsigned short port,
		unsigned short proto)
{
	struct proxy_l* p;

	p=(struct proxy_l*) pkg_malloc(sizeof(struct proxy_l));
	if (p==0){
		LM_CRIT("pkg memory allocation failure\n");
		goto error;
	}
	memset(p,0,sizeof(struct proxy_l));

	p->port=port;
	p->proto=proto;
	p->host.h_addrtype=ip->af;
	p->host.h_length=ip->len;
	p->host.h_addr_list=pkg_malloc(2*sizeof(char*));
	if (p->host.h_addr_list==0) goto error;
	p->host.h_addr_list[1]=0;
	p->host.h_addr_list[0]=pkg_malloc(ip->len+1);
	if (p->host.h_addr_list[0]==0){
		pkg_free(p->host.h_addr_list);
		goto error;
	}

	memcpy(p->host.h_addr_list[0], ip->u.addr, ip->len);
	p->host.h_addr_list[0][ip->len]=0;

	return p;

error:
	return 0;
}



void free_proxy(struct proxy_l* p)
{
	if (p) {
		free_hostent(&p->host);
		free_dns_res( p );
	}
}


void free_shm_proxy(struct proxy_l* p)
{
	if (p) {
		free_shm_hostent(&p->host);
		free_dns_res(p);
	}
}

/* same as add_proxy, but it doesn't add the proxy to the list
 * uses also SRV if possible & port==0 (quick hack)
   works in shared memory */
struct proxy_l* mk_shm_proxy(str* name, unsigned short port, unsigned short proto,
		int is_sips)
{
	struct proxy_l* p;
	struct hostent* he;

	p=(struct proxy_l*) shm_malloc(sizeof(struct proxy_l));
	if (p==0){
		ser_error=E_OUT_OF_MEM;
		LM_CRIT("shm memory allocation failure\n");
		goto error;
	}
	memset(p,0,sizeof(struct proxy_l));
	p->name=*name;
	p->port=port;
	p->proto=proto;

	LM_DBG("doing DNS lookup...\n");
	he = sip_resolvehost(name, &(p->port), &p->proto, is_sips,
		disable_dns_failover?0:&p->dn );
	if (he==0){
		ser_error=E_BAD_ADDRESS;
		LM_CRIT("could not resolve hostname: \"%.*s\"\n", name->len, name->s);
		shm_free(p);
		goto error;
	}
	if (hostent_shm_cpy(&(p->host), he)!=0){
		free_dns_res( p );
		shm_free(p);
		goto error;
	}
	return p;
error:
	return 0;
}

/* clones a proxy into pkg memory */
struct proxy_l* clone_proxy(struct proxy_l *sp)
{
	struct proxy_l *dp;

	dp = (struct proxy_l*)pkg_malloc(sizeof(struct proxy_l));
	if (dp==NULL) {
		LM_ERR("no more pkg memory\n");
		return 0;
	}
	memset( dp , 0 , sizeof(struct proxy_l));

	dp->port = sp->port;
	dp->proto = sp->proto;
	dp->addr_idx = sp->addr_idx;

	/* clone the hostent */
	if (hostent_cpy( &dp->host, &sp->host)!=0)
		goto error0;

	/* clone the dns resolver */
	if (sp->dn) {
		dp->dn = dns_res_copy(sp->dn);
		if (dp->dn==NULL)
			goto error1;
	}

	return dp;
error1:
	free_hostent(&dp->host);
error0:
	pkg_free(dp);
	return 0;
}