rsvp_socks.c

radius协议源码÷The Radius Stack will connect to a Radius Server. This stack implementation is built upo

struct hostent *
gethostbyname2(const char *name,int af)
{
	switch (af) {
		case AF_INET:
			return(gethostbyname(name));
#ifdef	USE_IPV6
		case AF_INET6:
			return(hostname2addr(name,AF_INET6));
#endif	/* USE_IPV6 */
		default:
			return(NULL);
	}
	return(NULL);
}

#endif	/* sun */

struct if_attributes *
if_attributes(unsigned int n)
{
#ifdef	__FreeBSD__

	unsigned int i,flags,mtu;
	struct if_attributes *l;
	struct sockaddr *s;
	char name[IFNAMSIZ];

	if (if_indextoname(n,name) == NULL)
		return(NULL);
	flags = if_indextoflags(n);
	mtu = if_indextomtu(n);
	l = ifap[--n];
	i = 0;
	for(s = l->addr; s != NULL; s = (++l)->addr) {
		l->flags = flags;
		l->mtu = mtu;
		switch (s->sa_family) {
			case AF_INET:
				l->prefix = PREFIX(((struct sockaddr_in *)
					prefixes[n][i])->sin_addr.s_addr);
				break;
#ifdef	USE_IPV6
			case AF_INET6:
				l->prefix = PREFIX(((struct sockaddr_in6 *)
					prefixes[n][i])->sin6_addr);
				break;
#endif	/* USE_IPV6 */
			default:
				l->prefix = 0;
				break;
		}
		i++;
	}
	return(ifap[n]);

#else	/* __FreeBSD__ */

	static struct if_attributes ret[2];

	ret[0].addr = if_indextoaddr(n,AF_UNSPEC);
	ret[0].prefix = if_indextoprefix(n);
	ret[0].flags = if_indextoflags(n);
	ret[0].mtu = if_indextomtu(n);
	ret[1].addr = NULL;

#if	(defined(sun) && defined(USE_IPV6))
	if (ret[0].addr->sa_family == AF_INET6) {
		int fd;
		struct v6preinforeq ifr6;

		if (if_indextoname(n,ifr6.v6pr_name) == NULL)
			return(ret);
		fd = socket(_AF_INET,SOCK_DGRAM,PF_UNSPEC);
		if (FAILED(fd))
			return(ret);
		if (FAILED(ioctl(fd,SIOCGIFV6PREINFO,(caddr_t) &ifr6))) {
			close(fd);
			return(ret);
		}
		close(fd);
		if (!(ifr6.v6pr_flags & LV6IF_ADDRESSED))
			ret[0].addr = NULL;
	}
#endif	/* (defined(sun) && defined(USE_IPV6)) */

	return(ret);

#endif 	/* __FreeBSD__ */
}

unsigned int
if_addrtoindex(struct sockaddr *s)
{
	struct if_nameindex *p,*q;
	struct if_attributes *l;
	struct sockaddr *s2;

	p = if_nameindex();
	if (p == NULL)
		return(0);
	for (q = p;q->if_name != NULL; q++) {
		l = if_attributes(q->if_index);
		for(s2 = l->addr; s2 != NULL; s2 = (++l)->addr)
			if (net_sockaddr_equal(s,s2)) {
				if_freenameindex(p);
				return(q->if_index);
			}
	}
	if_freenameindex(p);
	return(0);
}

struct sockaddr *
if_indextoaddr(unsigned int index,int af)
{
#ifdef	__FreeBSD__

	struct sockaddr *s;
	struct if_attributes *l;

	l = if_attributes(index);
	/* FIX: choose BEST address ? */
	for(s = l->addr; s != NULL; s = (++l)->addr)
		if ((af == AF_UNSPEC) || (af == s->sa_family))
			return(s);
	return(NULL);

#else	/* __FreeBSD__ */

#ifdef	linux

	linux_init();
	if (index >= MAX_INTERFACES)
		return(NULL);
	return(ifap[index].addr);

#else	/* linux */

	int fd;
	static struct ifreq ifr;
#ifdef	USE_IPV6
	static struct IFREQADDR ifr6;
	static struct sockaddr_in6 sin;

	if (if_indextoname(index,ifr6.IF_ADDRNAME) == NULL)
		return(NULL);
	fd = socket(_AF_INET,SOCK_DGRAM,PF_UNSPEC);
	if (FAILED(fd))
		return(NULL);
	if (FAILED(ioctl(fd,_SIOCGIFADDR,(caddr_t) &ifr6))) {
		close(fd);
		return(NULL);
	}
	close(fd);
	if (!IN6_ARE_ADDR_EQUAL(&ifr6.IF_ADDRADDR,&in6addr_any)) {
		if ((af != AF_UNSPEC) && (af != AF_INET6))
			return(NULL);
		NET_SOCKADDR_IPv6(&sin,ifr6.IF_ADDRADDR);
		return((struct sockaddr *) &sin);
	}
#endif	/* USE_IPV6 */
	if (if_indextoname(index,ifr.ifr_name) == NULL)
		return(NULL);
	fd = socket(AF_INET,SOCK_DGRAM,PF_UNSPEC);
	if (FAILED(fd))
		return(NULL);
	if (FAILED(ioctl(fd,SIOCGIFADDR,(caddr_t) &ifr))) {
		close(fd);
		return(NULL);
	}
	close(fd);
	if ((af != AF_UNSPEC) && (af != AF_INET))
		return(NULL);
	return((struct sockaddr *) &ifr.ifr_addr);

#endif	/* linux */

#endif 	/* __FreeBSD__ */
}

#ifndef	__FreeBSD__

static
int
if_indextoprefix(unsigned int n)
{
#ifdef	linux

	if (n >= MAX_INTERFACES)
		return(0);
	if (ifap[n].addr == NULL)
		return(0);
	return(ifap[n].prefix);

#else	/* linux */

	int fd,ret = 0;
	struct sockaddr *s;
	struct ifreq ifr;
#ifdef	USE_IPV6
	struct IFREQMASK ifr6;
#endif	/* USE_IPV6 */

	s = if_indextoaddr(n,AF_UNSPEC);
	if (s == NULL)
		return(ret);
	fd = socket(_AF_INET,SOCK_DGRAM,PF_UNSPEC);
	if (FAILED(fd))
		return(ret);
	switch (s->sa_family) {
		case AF_INET:
			if_indextoname(n,ifr.ifr_name);
			if (FAILED(ioctl(fd,SIOCGIFNETMASK,(caddr_t) &ifr)))
				break;
			ret = PREFIX(((struct sockaddr_in *) &ifr.ifr_addr)
                                ->sin_addr.s_addr);
			break;
#ifdef	USE_IPV6
		case AF_INET6:
			if_indextoname(n,ifr6.IF_MASKNAME);
			if (FAILED(ioctl(fd,SIOCGIFNETMASK6,(caddr_t) &ifr6)))
				break;
			ret = PREFIX6(ifr6.IF_MASKADDR);
			break;
#endif	/* USE_IPV6 */
		default:
			break;
	}
	close(fd);
	return(ret);

#endif	/* linux */
}

#endif	/* __FreeBSD__ */

static
unsigned int
if_indextoflags(unsigned int n)
{
#ifdef	linux

	if (n >= MAX_INTERFACES)
		return(0);
	if (ifap[n].addr == NULL)
		return(0);
	return(ifap[n].flags);

#else	/* linux */

	int fd,ret = 0;
	struct ifreq ifr;

	fd = socket(_AF_INET,SOCK_DGRAM,PF_UNSPEC);
	if (FAILED(fd))
		return(ret);
	if_indextoname(n,ifr.ifr_name);
	if (!FAILED(ioctl(fd,SIOCGIFFLAGS,(caddr_t) &ifr)))
		ret = ifr.ifr_flags;
	close(fd);
	return(ret);

#endif	/* linux */
}

static
unsigned int
if_indextomtu(unsigned int n)
{
#ifdef	linux

	if (n >= MAX_INTERFACES)
		return(0);
	if (ifap[n].addr == NULL)
		return(0);
	return(ifap[n].mtu);

#else	/* linux */

	int fd,ret = 0;
	struct ifreq ifr;

	fd = socket(_AF_INET,SOCK_DGRAM,PF_UNSPEC);
	if (FAILED(fd))
		return(ret);
	if_indextoname(n,ifr.ifr_name);
	if (!FAILED(ioctl(fd,SIOCGIFMTU,(caddr_t) &ifr)))
		ret = ifr.ifr_metric;
	close(fd);
	return(ret);

#endif	/* linux */
}

#ifndef	linux

static
unsigned int
prefix(unsigned char *p,unsigned int n)
{
	unsigned int i,sum = 0;

	for (i = 0;i < n; i++)
		if (BSET_ISSET(i,p))
			sum++;
	return(sum);
}

#endif	/* linux */

const char *
net_inaddr_print(const char *s,int af)
{
	static char buffer[MAX_ADDRSTRLEN];

	switch (af) {
		case AF_INET:
			return(inet_ntop(AF_INET,
				(struct in_addr *) s,
				buffer,sizeof(buffer)));
#ifdef	USE_IPV6
		case AF_INET6:
			return(inet_ntop(AF_INET6,
				(struct in6_addr *) s,
				buffer,sizeof(buffer)));
#endif	/* USE_IPV6 */
		default:
			return(NULL);
	}
}

const char *
net_inaddr_host(const char *s,int af)
{
	struct hostent *hp;

	switch (af) {
		case AF_INET:
			hp = gethostbyaddr(s,sizeof(struct in_addr),AF_INET);
			if (hp == NULL)
				return(net_inaddr_print(s,af));
			return(hp->h_name);
#ifdef	USE_IPV6
		case AF_INET6:
			hp = gethostbyaddr(s,sizeof(struct in6_addr),AF_INET6);
			if (hp == NULL)
				return(net_inaddr_print(s,af));
			return(hp->h_name);
#endif	/* USE_IPV6 */
		default:
			return(NULL);
	}
}

int
net_sockaddr_equal(const struct sockaddr *x,const struct sockaddr *y)
{ 
	if (x->sa_family != y->sa_family)
		return(FALSE);
	switch (x->sa_family) {
		case AF_INET:
			if (!IN_ARE_ADDR_EQUAL(
					&((struct sockaddr_in *) x)->sin_addr,
					&((struct sockaddr_in *) y)->sin_addr))
				return(FALSE);
			return(((struct sockaddr_in *) x)->sin_port ==
				((struct sockaddr_in *) y)->sin_port);
#ifdef	USE_IPV6
		case AF_INET6:
			if (!IN6_ARE_ADDR_EQUAL(
					&((struct sockaddr_in6 *) x)->sin6_addr,
					&((struct sockaddr_in6 *) y)->sin6_addr))
				return(FALSE);
			return(((struct sockaddr_in6 *) x)->sin6_port ==
				((struct sockaddr_in6 *) y)->sin6_port);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

const char *
net_sockaddr_print(const struct sockaddr *s)
{
	static char buffer[MAX_ADDRPORTSTRLEN],buffer2[MAX_ADDRSTRLEN];

	switch (s->sa_family) {
		case AF_INET:
			sprintf(buffer,"%s/%hu",inet_ntop(AF_INET,
				&((struct sockaddr_in *) s)->sin_addr,
				buffer2,sizeof(buffer2)),
				ntohs(((struct sockaddr_in *) s)->sin_port));
			return(buffer);
#ifdef	USE_IPV6
		case AF_INET6:
			sprintf(buffer,"%s/%hu",inet_ntop(AF_INET6,
				&((struct sockaddr_in6 *) s)->sin6_addr,
				buffer2,sizeof(buffer2)),
				ntohs(((struct sockaddr_in6 *) s)->sin6_port));
			return(buffer);
#endif	/* USE_IPV6 */
		default:
			return(NULL);
	}
}

int
net_addr_equal(const net_addr *x,const net_addr *y)
{
	if (NET_UNEQUAL_TYPE(x,y))
		return(FALSE);
	switch (NET_GET_TYPE(x)) {
		case NET_ADDR_IPv4:
			return(IN_ARE_ADDR_EQUAL(&NET_GET_ADDR_IPv4(x),
				&NET_GET_ADDR_IPv4(y)));
		case NET_ADDR_UDP_IPv4:
			return(memcmp(&NET_GET_ADDR_UDP_IPv4(x),
				&NET_GET_ADDR_UDP_IPv4(y),
				sizeof(NET_GET_ADDR_UDP_IPv4(x))) == 0);
#ifdef	USE_IPV6
		case NET_ADDR_IPv6:
			return(IN6_ARE_ADDR_EQUAL(&NET_GET_ADDR_IPv6(x),
				&NET_GET_ADDR_IPv6(y)));
		case NET_ADDR_UDP_IPv6:
			return(memcmp(&NET_GET_ADDR_UDP_IPv6(x),
				&NET_GET_ADDR_UDP_IPv6(y),
				sizeof(NET_GET_ADDR_UDP_IPv6(x))) == 0);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

int
net_addr_is_multicast(const net_addr *addr)
{
	switch (NET_GET_TYPE(addr)) {
		case NET_ADDR_IPv4:
			return(IN_IS_ADDR_MULTICAST(
				&NET_GET_ADDR_IPv4(addr)));
		case NET_ADDR_UDP_IPv4:
			return(IN_IS_ADDR_MULTICAST(
				&NET_GET_ADDR_UDP_IPv4(addr).sin_addr));
#ifdef	USE_IPV6
		case NET_ADDR_IPv6:
			return(IN6_IS_ADDR_MULTICAST(
				&NET_GET_ADDR_IPv6(addr)));
		case NET_ADDR_UDP_IPv6:
			return(IN6_IS_ADDR_MULTICAST(
				&NET_GET_ADDR_UDP_IPv6(addr).sin6_addr));
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

net_addr *
net_addr_ip(net_addr *addr)
{
	static net_addr addr2;

	switch (NET_GET_TYPE(addr)) {
		case NET_ADDR_UDP_IPv4:
			NET_SET_ADDR_IPv4(&addr2,
				NET_GET_ADDR_UDP_IPv4(addr).sin_addr);
			return(&addr2);
#ifdef	USE_IPV6
		case NET_ADDR_UDP_IPv6:
			NET_SET_ADDR_IPv6(&addr2,
				NET_GET_ADDR_UDP_IPv6(addr).sin6_addr);
			return(&addr2);
#endif	/* USE_IPV6 */
		default:
			addr2 = *addr;
			return(&addr2);
	}
}

int
net_addr_assign(net_addr *addr,const struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			NET_SET_ADDR_IPv4(addr,
				((struct sockaddr_in *) s)->sin_addr);
			return(TRUE);
#ifdef	USE_IPV6
		case AF_INET6:
			NET_SET_ADDR_IPv6(addr,
				((struct sockaddr_in6 *) s)->sin6_addr);
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

int
net_addr_assign_udp(net_addr *addr,const struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			NET_SET_ADDR_UDP_IPv4(addr,*(struct sockaddr_in *) s);
			return(TRUE);
#ifdef	USE_IPV6
		case AF_INET6:
			NET_SET_ADDR_UDP_IPv6(addr,*(struct sockaddr_in6 *) s);
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

/*	Given character string containing host name, do DNS lookup(s)
 *	to convert to net_addr.
 */
int
net_addr_ascii(net_addr *addr,const char *str)
{
	struct hostent *hp;
	struct in_addr in;
#ifdef	USE_IPV6
	struct in6_addr in6;
#endif	/* USE_IPV6 */

	if (inet_pton(AF_INET,str,&in) == 1) {
		NET_SET_ADDR_IPv4(addr,in);
		return(TRUE);
	}
	hp = gethostbyname2(str,AF_INET);
	if (hp != NULL) {
		memcpy(&in,hp->h_addr,hp->h_length);
		NET_SET_ADDR_IPv4(addr,in);
		return(TRUE);
	}
#ifdef	USE_IPV6
	if (inet_pton(AF_INET6,str,&in6) == 1) {
		NET_SET_ADDR_IPv6(addr,in6);
		return(TRUE);
	}
	hp = gethostbyname2(str,AF_INET6);
	if (hp != NULL) {
		memcpy(&in6,hp->h_addr,hp->h_length);
		NET_SET_ADDR_IPv6(addr,in6);
		return(TRUE);
	}
#endif	/* USE_IPV6 */
	return(FALSE);
}

/*	Make printable numeric ("dotted decimal") format from net-addr.
 */
const char *
net_addr_print(const net_addr *addr)
{
	static char buffer[MAX_ADDRPORTSTRLEN],buffer2[MAX_ADDRSTRLEN];

	switch(NET_GET_TYPE(addr)) {
		case NET_ADDR_IPv4:
			return(inet_ntop(AF_INET,&NET_GET_ADDR_IPv4(addr),
				buffer,sizeof(buffer)));
		case NET_ADDR_UDP_IPv4:
			sprintf(buffer,"%s/%hu",inet_ntop(AF_INET,
				&NET_GET_ADDR_UDP_IPv4(addr).sin_addr,
				buffer2,sizeof(buffer2)),