rtap_cmds.c

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

	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];
	int	T, i;
	extern  char *rapi_rstyle_names[];

	for (T=0 ; T < MAX_T; T++)	/* Map sid into thread# T */
		if (Sid[T] == sid)
			break;

	sprintf(out1, "  Session= %.32s%s",
		net_sockaddr_print((struct sockaddr *) &dest[T]),
		(Mode[T]&GPI_MODE)?":GPI":"");
	printf(
	"---------------------------------------------------------------\n");		
	switch (event) {

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

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

	case RAPI_RESV_ERROR:
		isPath = 0;
	case RAPI_PATH_ERROR:
		printf("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)
			printf("    Style=%s", rapi_rstyle_names[styleid]);
		printf("    Code=%d  Val=%d  Node= %s",
			 errcode, errval, net_sockaddr_print(errnode));
		if (errflags&RAPI_ERRF_InPlace)
			printf(" *InPlace*");
		if (errflags&RAPI_ERRF_NotGuilty)
			printf(" *NotGuilt*");
		printf("\n");
		break;

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

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

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

	default:
		printf("!!?\n");
		break;
	}
	for (i = 0; i < MAX(filt_num, flow_num); i++) {
		if (i < filt_num) {
			printf("\t%s", fmt_filterspec(filtp));
			filtp = (rapi_filter_t *)After_RAPIObj(filtp);
		}
		else
			printf("\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));
			printf("\t%s\n", buff);
			flowp = (rapi_flowspec_t *)After_RAPIObj(flowp);
		}
		else
			printf("\n");
		if (i < adspec_num) {
			rapi_fmt_adspec(adsp, buff, sizeof(buff));
			printf("\t\t%s\n", buff);
			adsp = (rapi_adspec_t *)After_RAPIObj(adsp);
		}
			
	}
	printf(
	"---------------------------------------------------------------\n");
	fflush(stdout);
	return 0;
}


/*
 * Skip leading blanks, then copy next word (delimited by blank or zero, but
 * no longer than 63 bytes) into buffer b, set scan pointer to following 
 * non-blank (or end of string), and return 1.  If there is no non-blank text,
 * set scan ptr to point to 0 byte and return 0.
 */
int 
next_word(char **cpp, char *b)
{
	char           *tp;
	int		L;

	*cpp += strspn(*cpp, " \t");
	if (**cpp == '\0' || **cpp == '\n' || **cpp == '#')
		return(0);

	tp = strpbrk(*cpp, " \t\n#");
	L = MIN((tp)?(tp-*cpp):strlen(*cpp), 63);
	strncpy(b, *cpp, L);
	*(b + L) = '\0';
	*cpp += L;
	*cpp += strspn(*cpp, " \t");
	return (1);
}

char           *
argscan(argcp, argvp)
	int            *argcp;
	register char ***argvp;
{
	register char  *cp;

	if (*(cp = 2 + **argvp))
		return (cp);
	else if (--*argcp > 0)
		return (*++*argvp);
	exit(1);
}


void
print_errno(char *cp, int rapi_errno)
	{
	printf("RAPI: %s err %d : %s\n", cp, rapi_errno,
					rapi_errlist[rapi_errno]);
}

void
print_status()
	{
	char	*state_str;
	char	buff[128];
	int	mode;
#ifdef ISI_TEST
	int	rc;
#endif
	if (Sid[T] == NULL_SID) {
		printf("T%d STATUS: No session\n", T);
#ifdef RTAP
		dump_rsvp_stats();
#endif
		return;
	}
	mode = Mode[T] & (RS_MODE);
	if (mode == RS_MODE) state_str = "Open SR";
	else if (mode == R_MODE) state_str = "Open R";
	else if (mode == S_MODE) state_str = "Open S";
	else state_str = "Closed";

	printf("T%d STATUS:\n", T);
	printf("  State: %s  sid= %d \n", state_str, Sid[T]);
	printf("  Session:\n     Dest= %s\n",
		net_sockaddr_print((struct sockaddr *) &dest[T]));
	if (mode == 0) {
#ifdef RTAP
		dump_rsvp_stats();
#endif
		return;
	}

	if (mode&S_MODE) {
            if (((struct sockaddr *) &src[T])->sa_family != AF_UNSPEC) {
		printf("  Sender:\n    %s",
			net_sockaddr_print((struct sockaddr *) &src[T]));
		if (snd_template[T])
			printf("  Snd_Templ= %s",
			       fmt_filterspec(Area_Data((rapi_filter_t *), 
					snd_template[T])));
		if (snd_tspec[T]) {
			rapi_fmt_tspec(Area_Data((rapi_tspec_t *),
					snd_tspec[T]), buff, 128);
			printf("  Tspec= %s", buff);
		}
		printf("\n");
	    }
	}
#ifdef DATA
	printf("  Data:\n    Size= %d  Timeout= %ld.%06ld  TTL= %d\n",
		data_size, timeout.tv_sec, timeout.tv_usec, ttl);
	printf("    Sent %ld bytes, %ld msgs; Rcvd %ld bytes, %ld msgs\n",
	    send_data_bytes, send_data_msgs, recv_data_bytes, recv_data_msgs);
#endif
#ifdef ISI_TEST
	rc = rapi_status(Sid[T], RAPI_STAT_PATH+RAPI_STAT_RESV);
	if (rc)
		print_errno("rapi_status()", rc);
#endif
	sleep(2);
#ifdef RTAP
	dump_rsvp_stats();
#endif
}

#define MinRAPILen	8	/* minimum RAPI filterspec length */

char *
fmt_filterspec(rapi_filter_t *rfiltp)
	{
	static char FIbuff[256];

	rapi_fmt_filtspec(rfiltp, FIbuff, 256);
	return(FIbuff);
}

area_t *
init_Area(area_t **app, int size)
	{
	area_t *ap = *app;

	if (ap == NULL) {
       		size += sizeof(area_t);
       		if (size <= 0 || (ap = (area_t *) malloc(size)) == NULL)
                	return(NULL);
		*app = ap;
        	ap->area_size = size;
	}
	ap->area_offset = sizeof(area_t);
	ap->area_cnt = 0;
        return(ap);
}

char *
Area_offset(area_t *ap) {
        return((char *) ap + ap->area_offset);
}

void
free_Area(area_t **app)
	{
	free(*app);
	*app = NULL;
}


void
Cat_Area(area_t *orig, rapi_hdr_t *objp) {
        if (orig->area_offset + objp->len > orig->area_size) {
                printf("!!Area overflow\n");
                return;
        }
        memcpy((rapi_hdr_t *)Area_offset(orig), objp, objp->len);
        orig->area_offset += objp->len;
        orig->area_cnt++;
}

int
Get_Socket_ipv4(int port)
	{
	struct sockaddr_in	sin;
	int			one = 1;
	int			sock;

	if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("rtap socket:");
		exit(1);
	}

	NET_SOCKADDR_UDP_IPv4(&sin,inaddr_any,port);
	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 
						(char *)&one, sizeof(one))){
		perror("rtap sockopt:");
		exit(1);
	}
	if (bind(sock, (struct sockaddr *) &sin, sizeof(sin))) {
		perror("rtap bind:");
		exit(1);
	}
	return (sock);
}

#ifdef	USE_IPV6

#ifndef IPV6_ADD_MEMBERSHIP
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
#endif

int
Get_Socket_ipv6(int port)
	{
	struct sockaddr_in6	sin;
	int			one = 1;
	int			sock;

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
		perror("rtap socket:");
		exit(1);
	}

	NET_SOCKADDR_UDP_IPv6(&sin,in6addr_any,port);
	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 
						(char *)&one, sizeof(one))){
		perror("rtap sockopt:");
		exit(1);
	}
	if (bind(sock, (struct sockaddr *) &sin, sizeof(sin))) {
		perror("rtap bind:");
		exit(1);
	}
	return (sock);
}
#endif	/* USE_IPV6 */

int
Get_Socket(struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			return(Get_Socket_ipv4(
				((struct sockaddr_in *) s)->sin_port));
#ifdef	USE_IPV6
		case AF_INET6:
			return(Get_Socket_ipv6(
				((struct sockaddr_in6 *) s)->sin6_port));
#endif	/* USE_IPV6 */
		default:
			return(-1);
	}
}

void
Set_Recv_ipv4(dstp, srcp)
	struct sockaddr_in	*dstp;
	struct sockaddr_in 	*srcp;
{
	struct ip_mreq  	mreq;

	if (!IN_IS_ADDR_MULTICAST(&dstp->sin_addr))
		return;
	mreq.imr_multiaddr = dstp->sin_addr;
	mreq.imr_interface = srcp->sin_addr;
	if (0 > setsockopt(udpsock[T], IPPROTO_IP, IP_ADD_MEMBERSHIP,
				(char *) &mreq, sizeof(mreq))) {
		perror("Can't join multicast group");
		return;
	}
	printf("Joined multicast group %s\n",
		net_inaddr_print((char *) &dstp->sin_addr,AF_INET));
}

#ifdef	USE_IPV6
void
Set_Recv_ipv6(dstp, srcp)
	struct sockaddr_in6	*dstp;
	struct sockaddr_in6 	*srcp;
{
	struct ipv6_mreq  	mreq;

	if (!IN6_IS_ADDR_MULTICAST(&dstp->sin6_addr))
		return;
	mreq.ipv6mr_multiaddr = dstp->sin6_addr;
#ifdef	WORKAROUNDS
	mreq.ipv6mr_interface = srcp->sin6_addr;
#else	/* WORKAROUNDS */
	mreq.ipv6mr_interface = if_addrtoindex((struct sockaddr *) srcp);
#endif	/* WORKAROUNDS */
	if (0 > setsockopt(udpsock[T], IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
				(char *) &mreq, sizeof(mreq))) {
		perror("Can't join multicast group");
		return;
	}
	printf("Joined multicast group %s\n",
		net_inaddr_print((char *) &dstp->sin6_addr,AF_INET6));
}
#endif	/* USE_IPV6 */

void
Set_Recv(dstp, srcp)
	struct sockaddr		*dstp;
	struct sockaddr 	*srcp;
{
	switch (dstp->sa_family) {
		case AF_INET:
			Set_Recv_ipv4((struct sockaddr_in *) dstp,
				(struct sockaddr_in *) srcp);
			return;
#ifdef	USE_IPV6
		case AF_INET6:
			Set_Recv_ipv6((struct sockaddr_in6 *) dstp,
				(struct sockaddr_in6 *) srcp);
			return;
#endif	/* USE_IPV6 */
		default:
			return;
	}
}

static
void
Set_INADDR_ANY(net_addr *addr,struct sockaddr *s)
{
	switch(s->sa_family) {
		case AF_INET:
			NET_SET_ADDR_IPv4(addr,inaddr_any);
			return;
#ifdef	USE_IPV6
		case AF_INET6:
			NET_SET_ADDR_IPv6(addr,in6addr_any);
			return;
#endif	/* USE_IPV6 */
		default:
			return;
	}
}

#ifdef DATA
/* Following code is carried over from earlier version of rtap,
 * which could send data.  This code is currently incomplete.
 */
void
Set_Send((struct sockaddr *, struct sockaddr *, int T)
	{
        int     sock = udpsock[T];
        u_char  zero = 0;
        u_char  ttlv = ttl[T];

	if (0 > setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL,
                      			&ttlv, sizeof(ttlv))) {
		perror("Can't set multicast TTL");
		exit(1);
	}
	if (0 > setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP,
					&zero, sizeof(zero))) {
		perror("Can't set no loopback");
		exit(1);
	}
	if (0 > setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
				&srcp->sin_addr, sizeof(struct in_addr))) {
		perror("Can't set mcast iface");
		exit(1);
	}
}

void
Send_data(T)
	{
	int rc;

	rc = sendto(udpsock[T], data_buff, data_size, 0,
			(struct sockaddr *) dstp, sizeof(struct SOCKADDR));
        if (rc < 0) {
                perror("sendto");
                return;
        }
        send_data_bytes[T] += rc;
        send_data_msgs[T] ++;
}
#endif /* DATA */

int
Do_rsvp_cmd(int flags, int type)
	{
	int		old_level, errnum;
	rapi_cmd_t	cmd;

	cmd.rapi_cmd_len = 1;
	cmd.rapi_cmd_type = type;
	cmd.rapi_filler = flags;
	old_level = rapi_rsvp_cmd(&cmd, &errnum);
	if (type == RAPI_CMD_DEBUG_LEVEL)
		printf("Rsvpd logging level:\n");
	else
		printf("Rsvpd debug mask:\n");
	if (flags != -1)
		printf("	Changing to: %d\n", flags);
	if (old_level < 0)
		printf("rapi_debug_level error: %d\n", errnum);
	return(0);
}