rsvp_trans.c

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

	return(rc);
}

static
int
del_interface(net_if *inf)
{
	switch(NET_GET_TYPE(inf)) {
		case NET_IF_PHY:
			switch (NET_GET_TYPE(&NET_GET_IF_PHY_ADDR(inf))) {
				case NET_ADDR_IPv4:
					return(del_if_ipv4(inf,&maddr));
#ifdef	USE_IPV6
				case NET_ADDR_IPv6:
					return(del_if_ipv6(inf,&maddr6));
#endif	/* USE_IPV6 */
				default:
					return(SYS_ERROR);
			}
		case NET_IF_VIF:
			switch (NET_GET_TYPE(&NET_GET_IF_VIF_ADDR(inf))) {
				case NET_ADDR_IPv4:
					return(del_vif_ipv4(inf));
				default:
					return(SYS_ERROR);
			}
		default:
			return(SYS_ERROR);
	}
}

static
int
send_ipv4(net_addr_type type,struct sockaddr_in *to,struct sockaddr_in *from,
	void *msg,int len,net_if *inf,u_char hops,int ra)
{
	int fd,n;
	struct msghdr hdr;

	hdr.msg_name = (void *) to;
	hdr.msg_namelen = sizeof(*to);
	hdr.msg_control = NULL;
	hdr.msg_controllen = 0;
	fd = set_ancillary_data_ipv4(&hdr,type,to,from,msg,len,inf,hops,ra);
	if (FAILED(fd))
		return(fd);
	n = sendmsg(fd,&hdr,0);
	if (FAILED(n)) {
		net_error(NET_ERROR_SYSTEM,"sendmsg");
		return(SYS_ERROR);
	}
	return(n);
}

static
int
socket_ipv4(int type,int proto,net_addr_type atype)
{
	int fd,one = 1;
	u_char on = FALSE;

	fd = socket(AF_INET,type,proto);
	if (FAILED(fd)) {
		if (type == SOCK_RAW) {
			if (rawmode) {
				net_error(NET_ERROR_USER,
					"Using UDP encapsulation\n");
				rawmode = FALSE;
			}
		}
		else
			net_error(NET_ERROR_SYSTEM,"socket");
		return(fd);
	}
	if (FAILED(setsockopt(fd,SOL_SOCKET,SO_REUSEXXXX,
			(char *) &one,sizeof(one)))) {
		net_error(NET_ERROR_SYSTEM,"SO_REUSEXXXX");
		return(failed(fd));
	}
	if (!FAILED(pid)) {
		if (FAILED(fcntl(fd, F_SETFL, (fcntl(fd, F_GETFL) | FASYNC))))
			return(failed(fd));
#ifndef	SOLARIS
		if (FAILED(fcntl(fd, F_SETOWN, pid)))
			return(failed(fd));
#endif	/* SOLARIS */
	}
	/* Ignore errors on non-multicast interfaces */
	setsockopt(fd,IPPROTO_IP,IP_MULTICAST_LOOP,(char *) &on,sizeof(on));
	if (FAILED(init_ancillary_data_ipv4(fd)))
		return(failed(fd));
	FD_SET(fd,&fset);
	protocol_type[fd] = atype;
	finalize[fd] = NULL;
	return(fd);
}

static
int
socket_recv_rsvp_ipv4(int proto)
{
	int fd;

	fd = socket_ipv4(SOCK_RAW,proto,NET_ADDR_IPv4);
		/* Side effect: sets rawmode to FALSE if fails */
	if (FAILED(fd))
		return(fd);
	if (FAILED(rsvp_on_ipv4(fd))) {
		net_error(NET_ERROR_USER,"Pre-3.3 multicast kernel\n");
		return(failed(fd));
	}
	FD_SET(fd,&rset);
	finalize[fd] = rsvp_off_ipv4;
	return(fd);
}

/*
 *	Turn on protocol 46 intercept for RSVP.
 */
static
int
rsvp_on_ipv4(int fd)
{
#ifdef	IP_ROUTER_ALERT
	int on = TRUE;

	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_ROUTER_ALERT,
			(char *) &on,sizeof(on)))) {
		net_error(NET_ERROR_SYSTEM,"IP_ROUTER_ALERT");
		return(SYS_ERROR);
	}
#else	/* IP_ROUTER_ALERT */
#ifdef	IP_RSVP_ON
	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_RSVP_ON,(char *) NULL,0))) {
		net_error(NET_ERROR_SYSTEM,"IP_RSVP_ON");
		return(SYS_ERROR);
	}
#endif	/* IP_RSVP_ON */
#endif	/* IP_ROUTER_ALERT */
	return(SYS_NOERROR);
}

static
int
rsvp_off_ipv4(int fd)
{
#ifdef	IP_ROUTER_ALERT
	int off = FALSE;

	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_ROUTER_ALERT,
			(char *) &off,sizeof(off)))) {
		net_error(NET_ERROR_SYSTEM,"IP_ROUTER_ALERT");
		return(SYS_ERROR);
	}
#else	/* IP_ROUTER_ALERT */
#ifdef	IP_RSVP_OFF
	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_RSVP_OFF,(char *) NULL,0))) {
		net_error(NET_ERROR_SYSTEM,"IP_RSVP_OFF");
		return(SYS_ERROR);
	}
#endif	/* IP_RSVP_OFF */
#endif	/* IP_ROUTER_ALERT */
	return(SYS_NOERROR);
}

static
int
socket_recv_udp_ipv4(struct sockaddr_in *addr)
{
	int fd;

	fd = socket_ipv4(SOCK_DGRAM,PF_UNSPEC,NET_ADDR_UDP_IPv4);
	if (FAILED(fd))
		return(fd);
	if (FAILED(bind(fd,(struct sockaddr *) addr,sizeof(*addr)))) {
		net_error(NET_ERROR_SYSTEM,"bind");
		return(failed(fd));
	}
	FD_SET(fd,&rset);
	return(fd);
}

static
int
join_multicast_ipv4(int fd,net_if *inf,struct in_addr *g)
{
	struct ip_mreq mreq;

	mreq.imr_multiaddr = *g;
	mreq.imr_interface = NET_GET_ADDR_IPv4(&NET_GET_IF_PHY_ADDR(inf));
	/* Ignore errors on non-multicast interfaces */
	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_ADD_MEMBERSHIP,
			(char *) &mreq,sizeof(mreq))))
		return(SYS_NOERROR);
	finalize[fd] = drop_all_multicast_ipv4;
	return(SYS_NOERROR);
}

static
int
drop_multicast_ipv4(int fd,net_if *inf,struct in_addr *g)
{
	struct ip_mreq mreq;

	mreq.imr_multiaddr = *g;
	mreq.imr_interface = NET_GET_ADDR_IPv4(&NET_GET_IF_PHY_ADDR(inf));
	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_DROP_MEMBERSHIP,
			(char *) &mreq,sizeof(mreq)))) {
		net_error(NET_ERROR_SYSTEM,"IP_DROP_MEMBERSHIP");
		return(SYS_ERROR);
	}
	return(SYS_NOERROR);
}

static
int
drop_all_multicast_ipv4(int fd)
{
	/* FIX: Finish */
	return(SYS_ERROR);
}

/*
 *	Use ancillary data to specific outgoing network interface,
 *	source address, hop count, and router alert option.  This
 *	function returns the file descriptor to use for the send
 *	operation.
 */

static
int
init_ancillary_data_ipv4(int fd)
{
	int on = TRUE;

#ifdef	IP_PKTINFO
	if (FAILED(setsockopt(fd,IPPROTO_IP,IP_PKTINFO,
			(char *) &on,sizeof(on)))) {
		net_error(NET_ERROR_SYSTEM,"IP_PKTINFO");
		return(SYS_ERROR);
	}
#endif	/* IP_PKTINFO */
	return(SYS_NOERROR);
}

#ifdef	USE_IPV6

static
int
send_ipv6(net_addr_type type,struct sockaddr_in6 *to,struct sockaddr_in6 *from,
	void *msg,int len,net_if *inf,u_char hops,int ra)
{
	int fd,n;
	struct msghdr hdr;

	hdr.msg_name = (void *) to;
	hdr.msg_namelen = sizeof(*to);
	hdr.msg_control = NULL;
	hdr.msg_controllen = 0;
	fd = set_ancillary_data_ipv6(&hdr,type,to,from,msg,len,inf,hops,ra);
	if (FAILED(fd))
		return(fd);
	n = sendmsg(fd,&hdr,0);
	if (FAILED(n)) {
		net_error(NET_ERROR_SYSTEM,"sendmsg-1");
		return(SYS_ERROR);
	}
	return(n);
}

static
int
socket_ipv6(int type,int proto,net_addr_type atype)
{
	int fd,one = 1;
	u_char on = FALSE;

	fd = socket(AF_INET6,type,proto);
	if (FAILED(fd)) {
		if (type == SOCK_RAW) {
			if (rawmode) {
				net_error(NET_ERROR_USER,
					"Using UDP encapsulation\n");
				rawmode = FALSE;
			}
		}
		else
			net_error(NET_ERROR_SYSTEM,"socket");
		return(fd);
	}
	if (FAILED(setsockopt(fd,SOL_SOCKET,SO_REUSEXXXX,
			(char *) &one,sizeof(one)))) {
		net_error(NET_ERROR_SYSTEM,"SO_REUSEXXXX");
		return(failed(fd));
	}
	if (!FAILED(pid)) {
		if (FAILED(fcntl(fd, F_SETFL, (fcntl(fd, F_GETFL) | FASYNC))))
			return(failed(fd));
#ifndef	SOLARIS
		if (FAILED(fcntl(fd, F_SETOWN, pid)))
			return(failed(fd));
#endif	/* SOLARIS */
	}
	/* Ignore errors on non-multicast interfaces */
	setsockopt(fd,IPPROTO_IPV6,IPV6_MULTICAST_LOOP,
		(char *) &on,sizeof(on));
	if (FAILED(init_ancillary_data_ipv6(fd)))
		return(failed(fd));
	FD_SET(fd,&fset);
	protocol_type[fd] = atype;
	finalize[fd] = NULL;
	return(fd);
}

static
int
socket_recv_rsvp_ipv6(int proto)
{
	int fd;

	fd = socket_ipv6(SOCK_RAW,proto,NET_ADDR_IPv6);
	if (FAILED(fd))
		return(fd);
	if (FAILED(rsvp_on_ipv6(fd))) {
		net_error(NET_ERROR_USER,"Pre-3.3 multicast kernel\n");
		return(failed(fd));
	}
	FD_SET(fd,&rset);
	finalize[fd] = rsvp_off_ipv6;
	return(fd);
}

static
int
rsvp_on_ipv6(int fd)
{
#ifdef	IPV6_ROUTER_ALERT
	int on = TRUE;

	if (FAILED(setsockopt(fd,IPPROTO_IPV6,IPV6_ROUTER_ALERT,
			(char *) &on,sizeof(on)))) {
		net_error(NET_ERROR_SYSTEM,"IPV6_ROUTER_ALERT");
		return(SYS_ERROR);
	}
#else	/* IPV6_ROUTER_ALERT */
#ifdef	IPV6_RSVP_ON
	if (FAILED(setsockopt(fd,IPPROTO_IPV6,IPV6_RSVP_ON,(char *) NULL,0))) {
		net_error(NET_ERROR_SYSTEM,"IPV6_RSVP_ON");
		return(SYS_ERROR);
	}
#endif	/* IPV6_RSVP_ON */
#endif	/* IPV6_ROUTER_ALERT */
	return(SYS_NOERROR);
}

static
int
rsvp_off_ipv6(int fd)
{
#ifdef	IPV6_ROUTER_ALERT
	int off = FALSE;

	if (FAILED(setsockopt(fd,IPPROTO_IPV6,IPV6_ROUTER_ALERT,
			(char *) &off,sizeof(off)))) {
		net_error(NET_ERROR_SYSTEM,"IPV6_ROUTER_ALERT");
		return(SYS_ERROR);
	}
#else	/* IPV6_ROUTER_ALERT */
#ifdef	IPV6_RSVP_OFF
	if (FAILED(setsockopt(fd,IPPROTO_IPV6,IPV6_RSVP_OFF,(char *) NULL,0))) {
		net_error(NET_ERROR_SYSTEM,"IPV6_RSVP_OFF");
		return(SYS_ERROR);
	}
#endif	/* IPV6_RSVP_OFF */
#endif	/* IPV6_ROUTER_ALERT */
	return(SYS_NOERROR);
}

static
int
socket_recv_udp_ipv6(struct sockaddr_in6 *addr)
{
	int fd;

	fd = socket_ipv6(SOCK_DGRAM,PF_UNSPEC,NET_ADDR_UDP_IPv6);
	if (FAILED(fd))
		return(fd);
	if (FAILED(bind(fd,(struct sockaddr *) addr,sizeof(*addr)))) {
		net_error(NET_ERROR_SYSTEM,"bind");
		return(failed(fd));
	}
	FD_SET(fd,&rset);
	return(fd);
}

static
int
join_multicast_ipv6(int fd,net_if *inf,struct in6_addr *g)
{
	struct ipv6_mreq mreq;

	mreq.ipv6mr_multiaddr = *g;
#ifdef	WORKAROUNDS
	mreq.ipv6mr_interface = NET_GET_ADDR_IPv6(&NET_GET_IF_PHY_ADDR(inf));
#else	/* WORKAROUNDS */
	mreq.ipv6mr_interface = NET_GET_IF_PHY_ID(inf);
#endif	/* WORKAROUNDS */
	/* Ignore errors on non-multicast interfaces */
	setsockopt(fd,IPPROTO_IPV6,IPV6_ADD_MEMBERSHIP,
		(char *) &mreq,sizeof(mreq));
	finalize[fd] = drop_all_multicast_ipv6;
	return(SYS_NOERROR);
}

static
int
drop_multicast_ipv6(int fd,net_if *inf,struct in6_addr *g)
{
	struct ipv6_mreq mreq;

	mreq.ipv6mr_multiaddr = *g;
#ifdef	WORKAROUNDS
	mreq.ipv6mr_interface = NET_GET_ADDR_IPv6(&NET_GET_IF_PHY_ADDR(inf));
#else	/* WORKAROUNDS */
	mreq.ipv6mr_interface = NET_GET_IF_PHY_ID(inf);
#endif	/* WORKAROUNDS */
	if (FAILED(setsockopt(fd,IPPROTO_IPV6,IPV6_DROP_MEMBERSHIP,
			(char *) &mreq,sizeof(mreq)))) {
		net_error(NET_ERROR_SYSTEM,"IPV6_DROP_MEMBERSHIP");
		return(SYS_ERROR);
	}
	return(SYS_NOERROR);
}

static
int
drop_all_multicast_ipv6(int fd)
{
	/* FIX: Finish */
	return(SYS_ERROR);
}

static
int
init_ancillary_data_ipv6(int fd)
{
	int on = TRUE;

#ifdef	IPV6_PKTINFO
	if (FAILED(setsockopt(fd,IPPROTO_IPV6,IPV6_PKTINFO,
			(char *) &on,sizeof(on)))) {
		net_error(NET_ERROR_SYSTEM,"IPV6_PKTINFO");
		return(SYS_ERROR);
	}
#endif	/* IPV6_PKTINFO */
	return(SYS_NOERROR);
}

#endif	/* USE_IPV6 */

#ifdef	IP_PKTINFO

/*	receive(): Read input from given file descriptor, and set
 *	incoming interface *inf and source address *from.
 *
 *	Use ancillary data to get incoming network interface.
 */
static
int
receive(int fd,net_addr *from,void *msg,int len,net_if *inf)
{
	int n;
	struct iovec iov;
	struct msghdr hdr;
	struct cmsghdr *chdr;
	struct in_pktinfo *p;
	net_addr addr;
	char buffer[10240];
#ifdef	USE_IPV6
	struct in6_pktinfo *p6;
#endif	/* USE_IPV6 */

	hdr.msg_name = (void *) &NET_GET_ADDR(from);
	hdr.msg_namelen = sizeof(NET_GET_ADDR(from));
	hdr.msg_control = buffer;
	hdr.msg_controllen = sizeof(buffer);
	hdr.msg_iov = &iov;
	hdr.msg_iovlen = 1;
	iov.iov_base = msg;
	iov.iov_len = len;
	n = recvmsg(fd,&hdr,0);
	if (FAILED(n))
		return(n);
	adjust(from,protocol_type[fd]);
	*inf = unknown;
	if (hdr.msg_controllen == 0)
		return(n);
	for (chdr = CMSG_FIRSTHDR(&hdr); chdr != NULL;
			chdr = CMSG_NXTHDR(&hdr,chdr)) {
		if (chdr->cmsg_len == 0)
			continue;
		switch (chdr->cmsg_level) {
			case IPPROTO_IP:
				if (chdr->cmsg_type != IP_PKTINFO)
					break;
				p = (struct in_pktinfo *) CMSG_DATA(chdr);
				if (p->ipi_ifindex == 0)
					break;
				NET_SET_ADDR_IPv4(&addr,
					((struct sockaddr_in *)
					if_indextoaddr(p->ipi_ifindex,
					AF_INET))->sin_addr);
				NET_SET_IF_PHY(inf,addr,p->ipi_ifindex);
				break;
#ifdef	USE_IPV6
			case IPPROTO_IPV6:
				if (chdr->cmsg_type != IPV6_PKTINFO)
					break;
				p6 = (struct in6_pktinfo *) CMSG_DATA(chdr);
				if (p6->ipi6_ifindex == 0)
					break;
				NET_SET_ADDR_IPv6(&addr,
					((struct sockaddr_in6 *)
					if_indextoaddr(p6->ipi6_ifindex,
					AF_INET6))->sin6_addr);
				NET_SET_IF_PHY(inf,addr,p6->ipi6_ifindex);
				break;
#endif	/* USE_IPV6 */
			default:
				break;
		}
	}
	return(n);
}

#endif	/* IP_PKTINFO */

#ifdef	IP_DSTOPTS

static
int
set_ancillary_data_ipv4(struct msghdr *hdr,net_addr_type type,
	struct sockaddr_in *to,struct sockaddr_in *from,
	void *msg,int len,net_if *inf,u_char hops,int ra)
{
	/* FIX: fill in hdr->msg_control */
	return(ulist[type]);
}

static
int
add_if_ipv4(net_if *inf,struct in_addr *g)
{
	int status = SYS_NOERROR;

	/* Receive Multicast RSVP/UDP/IPv4 (Specified Interface) */
	if (FAILED(join_multicast_ipv4(fd_pu,inf,g)))
		status = SYS_ERROR;
	if (!rawmode) {
		if (FAILED(join_multicast_ipv4(fd_pup,inf,g)))
			status = SYS_ERROR;
	}
	return(status);
}

static
int
del_if_ipv4(net_if *inf,struct in_addr *g)
{
	int status = SYS_NOERROR;

	/* Receive Multicast RSVP/UDP/IPv4 (Specified Interface) */
	if (FAILED(drop_multicast_ipv4(fd_pu,inf,g)))
		status = SYS_ERROR;
	if (!rawmode) {
		if (FAILED(drop_multicast_ipv4(fd_pup,inf,g)))
			status = SYS_ERROR;
	}
	return(status);
}

static
int
add_vif_ipv4(net_if *inf)
{
	/* FIX: Finish */
	return(SYS_ERROR);
}

static
int
del_vif_ipv4(net_if *inf)
{
	/* FIX: Finish */
	return(SYS_ERROR);
}

/*
 *	Perform initialization and shutdown.
 */

static
int
#ifdef	USE_IPV6
initialize(int pu,int pup,struct in_addr *g,struct in6_addr *g6)
#else	/* USE_IPV6 */
initialize(int pu,int pup,struct in_addr *g)
#endif	/* USE_IPV6 */
{
	return(SYS_NOERROR);
}

#ifdef	USE_IPV6

static
int
init_ancillary_data_ipv6(int fd)
{
	/* FIX: setsockopt(s) for ancillary data (IPV6_PKTINFO) */
	return(SYS_ERROR);
}

static
int
set_ancillary_data_ipv6(struct msghdr *hdr,net_addr_type type,
	struct sockaddr_in6 *to,struct sockaddr_in6 *from,
	void *msg,int len,net_if *inf,u_char hops,int ra)
{
	/* FIX: fill in hdr->msg_control */
	return(ulist[type]);
}

static
int
add_if_ipv6(net_if *inf,struct in6_addr *g)
{
	int status = SYS_NOERROR;

	/* Receive Multicast RSVP/UDP/IPv6 (Specified Interface) */
	if (FAILED(join_multicast_ipv6(fd6_pu,inf,g)))
		status = SYS_ERROR;
	if (!rawmode) {
		if (FAILED(join_multicast_ipv6(fd6_pup,inf,g)))
			status = SYS_ERROR;
	}
	return(status);
}

static
int
del_if_ipv6(net_if *inf,struct in6_addr *g)