scrapi.c

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

	FD_ZERO(set);
	for (i = 0;i < MAXSESSIONS; i++)
		if (sessions[i].status & S_OPEN)
			FD_SET(rapi_getfd(i),set);
}

scrapi_status
scrapi_get_status(const struct sockaddr *dst,int proto,
	const struct sockaddr *src)
{
	rapi_sid_t sid;
	session *sp;
	sender *s;
	rapi_filter_t *f;
	struct SOCKADDR any;
	int i,confirms = FALSE,requests = FALSE,reservations = FALSE;

	if (!scrapi_dispatch())
		return(scrapi_status_red);
	if (!scrapi_sockaddr_any(SAP(&any),dst->sa_family))
		return(scrapi_status_red);
	if ((src == NULL) || sockaddr_equal(src,SAP(&any))) {
		for (i = 0;i < MAXSESSIONS; i++) {
			sp = &sessions[i];
			if (!(sp->status & S_OPEN))
				continue;
			if (!sockaddr_equal(dst,SAP(&sp->dst)))
				continue;
			if (proto != sp->proto)
				continue;
			if (sp->status & S_ERRORS)
				return(scrapi_status_red);
			if (sp->status & S_CONFIRM)
				confirms = TRUE;
			if (sp->status & S_RESV)
				reservations = TRUE;
			if (sp->status & S_REQUESTS)
				requests = TRUE;
		}
		if (confirms)
			return(scrapi_status_green);
		if (reservations)
			return(scrapi_status_green);
		if (requests)
			return(scrapi_status_yellow);
		return(scrapi_status_red);
	}
	sid = find_session(dst,proto,SAP(&any));
	if (sid == NULL_SID)
		return(scrapi_status_red);
	sp = &sessions[sid];
	f = filter_from_sockaddr(src);
	if (scrapi_sockaddr_get_port(src) != htons(0)) {
		s = get_sender(sid,f);
		if (s->status & S_ERRORS)
			return(scrapi_status_red);
		if (s->status & S_CONFIRM)
			return(scrapi_status_green);
		if (s->status & S_REQUESTS)
			return(scrapi_status_yellow);
		return(scrapi_status_red);
	}
	/*
	 *	Apply the wild src port to all sources with the
	 *	same address.
	 */
	for (s = sp->flows;s != NULL;s = s->next) {
		if (!filter_equal_wild(f,&s->src))
			continue;
		if (s->status & S_ERRORS)
			return(scrapi_status_red);
		if (s->status & S_CONFIRM)
			confirms = TRUE;
		if (s->status & S_REQUESTS)
			requests = TRUE;
	}
	if (confirms)
		return(scrapi_status_green);
	if (requests)
		return(scrapi_status_yellow);
	return(scrapi_status_red);
}

int
scrapi_errno(const struct sockaddr *dst,int proto,
	const struct sockaddr *src)
{
	int i;
	session *sp;
	struct SOCKADDR any;

	if (!scrapi_sockaddr_any(SAP(&any),dst->sa_family))
		return(SCRAPI_ERRNO_PARAM);
	if (src == NULL)
		src = SAP(&any);
	for (i = 0;i < MAXSESSIONS; i++) {
		sp = &sessions[i];
		if (!sockaddr_equal(dst,SAP(&sp->dst)))
			continue;
		if (proto != sp->proto)
			continue;
		if (sockaddr_equal(src,SAP(&sp->src)))
			return(sp->errno);
	}
	return(SCRAPI_ERRNO_NONE);
}

const char *
scrapi_errlist(int errno)
{
	return(errlist[errno]);
}

void
scrapi_perror(const struct sockaddr *dst,int proto,
	const struct sockaddr *src,const char *str)
{
	static int once = TRUE;

	if (once) {
		eout = stderr;
		once = FALSE;
	}
	if (!eout)
		return;
	fprintf(eout,"%s: %s\n",str,
		errlist[scrapi_errno(dst,proto,src)]);
	fflush(eout);
}

void
scrapi_stderr(FILE *f)
{
	eout = f;
}

void
scrapi_debug(FILE *f)
{
	dout = f;
}

/******************************************************************************
 *
 *	Utility functions for socket structures and the like.
 *
 *****************************************************************************/

#ifdef	sun
static const struct in_addr inaddr_any = {{{INADDR_ANY}}};
#else	/* sun */
static const struct in_addr inaddr_any = {INADDR_ANY};
#endif	/* sun */

int
scrapi_sockaddr_parse(struct sockaddr *s,const char *addr,unsigned short port)
{
	struct hostent *hp;
	struct in_addr in;
#ifdef	USE_IPV6
	struct in6_addr in6;
#endif	/* USE_IPV6 */

	if (inet_pton(AF_INET,addr,&in) == 1) {
		NET_SOCKADDR_UDP_IPv4(SAP4(s),in,port);
		return(TRUE);
	}
	hp = gethostbyname2(addr,AF_INET);
	if (hp != NULL) {
		memcpy(&in,hp->h_addr,hp->h_length);
		NET_SOCKADDR_UDP_IPv4(SAP4(s),in,port);
		return(TRUE);
	}
#ifdef	USE_IPV6
	if (inet_pton(AF_INET6,addr,&in6) == 1) {
		NET_SOCKADDR_UDP_IPv6(SAP6(s),in6,port);
		return(TRUE);
	}
	hp = gethostbyname2(addr,AF_INET6);
	if (hp != NULL) {
		memcpy(&in6,hp->h_addr,hp->h_length);
		NET_SOCKADDR_UDP_IPv6(SAP6(s),in6,port);
		return(TRUE);
	}
#endif	/* USE_IPV6 */
	return(FALSE);
}

const char *
scrapi_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,
				&SAP4(s)->sin_addr,buffer2,sizeof(buffer2)),
				ntohs(SAP4(s)->sin_port));
			return(buffer);
#ifdef	USE_IPV6
		case AF_INET6:
			sprintf(buffer,"%s/%hu",inet_ntop(AF_INET6,
				&SAP6(s)->sin6_addr,buffer2,sizeof(buffer2)),
				ntohs(SAP6(s)->sin6_port));
			return(buffer);
#endif	/* USE_IPV6 */
		default:
			return(NULL);
	}
}

int
scrapi_sockaddr_multicast(const struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			return(IN_IS_ADDR_MULTICAST(&SAP4(s)->sin_addr));
#ifdef	USE_IPV6
		case AF_INET6:
			return(IN6_IS_ADDR_MULTICAST(&SAP6(s)->sin6_addr));
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

int
scrapi_sockaddr_set_port(struct sockaddr *s,unsigned short port)
{
	switch (s->sa_family) {
		case AF_INET:
			SAP4(s)->sin_port = port;
			break;
#ifdef	USE_IPV6
		case AF_INET6:
			SAP6(s)->sin6_port = port;
			break;
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
	return(TRUE);
}

unsigned short
scrapi_sockaddr_get_port(const struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			return(SAP4(s)->sin_port);
#ifdef	USE_IPV6
		case AF_INET6:
			return(SAP6(s)->sin6_port);
#endif	/* USE_IPV6 */
		default:
			return(0);
	}
}

int
scrapi_sockaddr_set_addr(struct sockaddr *s,char *addr)
{
	switch (s->sa_family) {
		case AF_INET:
			memcpy(&SAP4(s)->sin_addr,addr,
				sizeof(SAP4(s)->sin_addr));
			break;
#ifdef	USE_IPV6
		case AF_INET6:
			memcpy(&SAP6(s)->sin6_addr,addr,
				sizeof(SAP6(s)->sin6_addr));
			break;
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
	return(TRUE);
}

int
scrapi_sockaddr_get_addr(const struct sockaddr *s,char *addr)
{
	switch (s->sa_family) {
		case AF_INET:
			memcpy(addr,&SAP4(s)->sin_addr,
				sizeof(SAP4(s)->sin_addr));
			break;
#ifdef	USE_IPV6
		case AF_INET6:
			memcpy(addr,&SAP6(s)->sin6_addr,
				sizeof(SAP6(s)->sin6_addr));
			break;
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
	return(TRUE);
}

int
scrapi_sockaddr_any(struct sockaddr *s,int family)
{
	switch (family) {
		case AF_INET:
			NET_SOCKADDR_UDP_IPv4(SAP4(s),inaddr_any,htons(0));
			return(TRUE);
#ifdef	USE_IPV6
		case AF_INET6:
			NET_SOCKADDR_UDP_IPv6(SAP6(s),in6addr_any,htons(0));
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

int
scrapi_sockaddr_length(const struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			return(sizeof(struct sockaddr_in));
#ifdef	USE_IPV6
		case AF_INET6:
			return(sizeof(struct sockaddr_in6));
#endif	/* USE_IPV6 */
		default:
			return(0);
	}
}

static
int
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(&SAP4(x)->sin_addr,
					&SAP4(y)->sin_addr))
				return(FALSE);
			return(SAP4(x)->sin_port == SAP4(y)->sin_port);
#ifdef	USE_IPV6
		case AF_INET6:
			if (!IN6_ARE_ADDR_EQUAL(&SAP6(x)->sin6_addr,
					&SAP6(y)->sin6_addr))
				return(FALSE);
			return(SAP6(x)->sin6_port == SAP6(y)->sin6_port);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

static
int
sockaddr_equal_wild(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(&SAP4(x)->sin_addr,
					&SAP4(y)->sin_addr))
				return(FALSE);
			if (SAP4(x)->sin_port == htons(0))
				return(TRUE);
			if (SAP4(y)->sin_port == htons(0))
				return(TRUE);
			return(SAP4(x)->sin_port == SAP4(y)->sin_port);
#ifdef	USE_IPV6
		case AF_INET6:
			if (!IN6_ARE_ADDR_EQUAL(&SAP6(x)->sin6_addr,
					&SAP6(y)->sin6_addr))
				return(FALSE);
			if (SAP6(x)->sin6_port == htons(0))
				return(TRUE);
			if (SAP6(y)->sin6_port == htons(0))
				return(TRUE);
			return(SAP6(x)->sin6_port == SAP6(y)->sin6_port);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

static
int
sockaddr_assign(struct sockaddr *x,const struct sockaddr *y)
{
	switch (y->sa_family) {
		case AF_INET:
			NET_SOCKADDR_UDP_IPv4(SAP4(x),SAP4(y)->sin_addr,
				SAP4(y)->sin_port);
			return(TRUE);
#ifdef	USE_IPV6
		case AF_INET6:
			NET_SOCKADDR_UDP_IPv6(SAP6(x),SAP6(y)->sin6_addr,
				SAP6(y)->sin6_port);
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

#ifdef	sun

static
const char *
inet_ntop(int af,const void *src,char *dst,size_t size)
{
	switch (af) {
		case AF_INET:
			if (size < INET_ADDRSTRLEN)
				return(NULL);
			strncpy(dst,inet_ntoa(*(struct in_addr *) src),
				INET_ADDRSTRLEN);
			return(dst);
#ifdef	USE_IPV6
		case AF_INET6:
			if (size < INET6_ADDRSTRLEN)
				return(NULL);
			strncpy(dst,addr2ascii(AF_INET6,
				(struct in6_addr *) src,
				sizeof(struct in6_addr),NULL),
				INET6_ADDRSTRLEN);
			return(dst);
#endif	/* USE_IPV6 */
		default:
			return(NULL);
	}
}

static
int
inet_pton(int af,const char *src,void *dst)
{
	switch (af) {
		case AF_INET:
			((struct in_addr *) dst)->s_addr = inet_addr(src);
			return(FAILED(((struct in_addr *) dst)->s_addr)
				? FALSE : 1);
#ifdef	USE_IPV6
		case AF_INET6:
			return(FAILED(ascii2addr(AF_INET6,src,dst))
				? FALSE : 1);
#endif	/* USE_IPV6 */
		default:
			return(SYS_ERROR);
	}
}

static
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 */

/******************************************************************************
 *
 *	This is for debugging purposes.
 *
 *****************************************************************************/

#ifndef	RSVP_Err_API_ERROR
#define	RSVP_Err_API_ERROR		20
#endif	/* RSVP_Err_API_ERROR */

static
void
print_callback(
	rapi_sid_t		sid,
	rapi_eventinfo_t	event,
	int			styleid,
	int			errcode,
	int			errval,
	struct sockaddr		*errnode,
	u_char			errflags,
	int			filt_num,
	rapi_filter_t		*filt_list,
	int			 flow_num,
	rapi_flowspec_t		*flow_list,
	int			 adspec_num,
	rapi_adspec_t		*adspec_list,
	void			*myparm)
	{
	rapi_filter_t *filtp = filt_list;
	rapi_flowspec_t *flowp = flow_list;
	rapi_adspec_t *adsp = adspec_list;
	int	isPath = 1;
	char	buff[128], out1[80];
	const char *str;
	int	T, i;
	static char *rapi_rstyle_names[] = {"?", "WF", "FF", "SE"};

	T = sid;			/* Map sid into thread# T */

	sprintf(out1, "  Session= %.32s",
		scrapi_sockaddr_print(SAP(&sessions[T].dst)));


		fprintf(dout,
	"\n---------------------------------------------------------------\n");		
	switch (event) {

	case RAPI_PATH_EVENT:
		fprintf(dout,"T%d: Path Event -- %s\n", T, out1);
		if (flow_num == 0)
			fprintf(dout,"    (No Path state)\n");
		break;

	case RAPI_RESV_EVENT:
		fprintf(dout,"T%d: Resv Event -- %s\n", T, out1);
		if (flow_num == 0)
			fprintf(dout,"    (No Resv state)\n");
		isPath = 0;
		break;

	case RAPI_RESV_ERROR:
		isPath = 0;
	case RAPI_PATH_ERROR:
		fprintf(dout,"T%d: sid=%d %s -- RSVP error: %s\n",
			T, sid, out1,
			(errcode==RSVP_Err_API_ERROR)?
				rapi_errlist[errval]:
				rsvp_errlist[errcode]);
		if (event == RAPI_RESV_ERROR)
			fprintf(dout,"    Style=%s", rapi_rstyle_names[styleid]);
		str = scrapi_sockaddr_print(errnode);
		str = (str != NULL) ? str : "(null)";
		fprintf(dout,"    Code=%d  Val=%d  Node= %s",
			 errcode, errval, str);
		if (errflags&RAPI_ERRF_InPlace)
			fprintf(dout," *InPlace*");
		if (errflags&RAPI_ERRF_NotGuilty)
			fprintf(dout," *NotGuilt*");
		fprintf(dout,"\n");
		break;

	case RAPI_RESV_STATUS:
		isPath = 0;
		fprintf(dout,"T%d: Resv State -- %s:\n", T, out1);
		break;

	case RAPI_PATH_STATUS:
		fprintf(dout,"T%d: Path Stat -- %s:\n", T, out1);
		break;

	case RAPI_RESV_CONFIRM:
		isPath = 0;
		fprintf(dout,"T%d: Confirm Event -- %s:\n", T, out1);
		break;

	default:
		fprintf(dout,"!!?\n");
		break;
	}
	for (i = 0; i < C_MAX(filt_num, flow_num); i++) {
		if (i < filt_num) {
			rapi_fmt_filtspec(filtp, buff, sizeof(buff));
			fprintf(dout,"\t%s", buff);
			filtp = (rapi_filter_t *)After_RAPIObj(filtp);
		}
		else
			fprintf(dout,"\t\t");
		if (i < flow_num) {
			if (isPath)
				rapi_fmt_tspec((rapi_tspec_t *)flowp,
							 buff, sizeof(buff));
			else
				rapi_fmt_flowspec(flowp, buff, sizeof(buff));
			fprintf(dout,"\t%s\n", buff);
			flowp = (rapi_flowspec_t *)After_RAPIObj(flowp);
		}
		else
			fprintf(dout,"\n");
		if (i < adspec_num) {
			rapi_fmt_adspec(adsp, buff, sizeof(buff));
			fprintf(dout,"\t\t%s\n", buff);
			adsp = (rapi_adspec_t *)After_RAPIObj(adsp);
		}
			
	}
	fprintf(dout,
	"---------------------------------------------------------------\n");
	fflush(dout);
	return;
}