rtap_cmds.c

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

		else
			get_filter(1+vi, &Filter_specs[T], 
						sizeof(rapi_filter_t));
		Pm_vi = vi+1;
		break;

	case Aflowspec:
		/* Value stack: <style> <service> <parm> ... 
		 */
		get_flowspec(1+vi, &Flowspecs[T], sizeof(rapi_flowspec_t));
		Pm_vi = vi+1;
		break;
	
	case Aresv_fin:
		Mode[T] |= R_MODE;
		Style[T] = (rapi_styleid_t) Pm_val[vi];
		rc = rapi_reserve(Sid[T], resv_flags[T],
			    (struct sockaddr *) &rcvr[T],
			    Style[T], NULL, NULL,
			    Filter_specs[T]->area_cnt,
			    Area_Data((rapi_filter_t *), Filter_specs[T]),
			    Flowspecs[T]->area_cnt,
			    Area_Data((rapi_flowspec_t *), Flowspecs[T]));
		if (rc)
			print_errno("rapi_reserve()", rc);
		resv_flags[T] = 0;
		break;

	case Arcvr:	/* Explicit receiver address in reserve command */
		Append_Val(0);	/* No port */
		get_sockaddr(vi, (struct sockaddr *) &rcvr[T]);
		break;
		
	case Aresv_init:
               	memset(&rcvr[T], 0, sizeof(struct SOCKADDR));
		init_Area((area_t **)&Filter_specs[T], 
					MAX_NFLWDS*sizeof(rapi_filter_t));
		init_Area((area_t **)&Flowspecs[T], 
					MAX_NFLWDS*sizeof(rapi_flowspec_t));
		break;

	case Adlevel:
		Do_rsvp_cmd((Pm_vi)?Pm_val[0]: -1, RAPI_CMD_DEBUG_LEVEL);
		break;

	case Admask:
		Do_rsvp_cmd((Pm_vi)?Pm_val[0]: -1, RAPI_CMD_DEBUG_MASK);
		break;
	}

	return(OK);
}


/* get_sockaddr: Create sockaddr from host, port values in value list
 *	at offset voff, voff+1.
 */
int
get_sockaddr(voff, sinp)
	int	voff;
	struct sockaddr *sinp;
	{
	u_short port;
	net_addr *addr;

	addr = &Pm_addrs[voff];
	if (Pm_vi > voff+1)
		port = hton16((u_short)Pm_val[voff+1]);
	else
		port = 0;
	switch(NET_GET_TYPE(addr)) {
		case NET_ADDR_IPv4:
			NET_SOCKADDR_UDP_IPv4((struct sockaddr_in *) sinp,
				NET_GET_ADDR_IPv4(addr),port);
			break;
#ifdef	USE_IPV6
		case NET_ADDR_IPv6:
			NET_SOCKADDR_UDP_IPv6((struct sockaddr_in6 *) sinp,
				NET_GET_ADDR_IPv6(addr),port);
			break;
#endif	/* USE_IPV6 */
		default:
			sinp->sa_family = AF_UNSPEC;
			break;
	}
	return(0);
}

/*
 *	Construct RAPI flowspec object from value list:
 *	voff+: 0=type
 *		type = cl:  1=r, 2=b, 3=p, 4=m, [5=M]
 *		type = gx:  1=R, 2=S, 3=r, 4=b, 5=p, 6=m, [7=M]
 */
int
get_flowspec(int voff, area_t **areapp, int size)
	{
	rapi_flowspec_t		Tflow, *flowsp = &Tflow;
	qos_flowspecx_t		*csxp = &flowsp->specbody_qosx;
	int			type = Pm_val[voff];
	
	switch (type) {

	case QOS_GUARANTEEDX:
		csxp->xspec_R = Pm_val[voff+1];
		csxp->xspec_S = Pm_val[voff+2];
		voff += 2;

	case QOS_CNTR_LOAD:
		csxp->spec_type = type;
		csxp->xspec_r = Pm_val[voff+1];
		csxp->xspec_b = Pm_val[voff+2];
		csxp->xspec_p = Pm_val[voff+3];
		csxp->xspec_m = Pm_val[voff+4];
		csxp->xspec_M = 65535;
		if (Pm_vi > voff+5)
			csxp->xspec_M = Pm_val[voff+5];
		flowsp->form = RAPI_FLOWSTYPE_Simplified;
		break;

	default:
		printf("Unknown flowspec type: %d\n", Pm_val[voff]);
		return(-1);
	}
		
	flowsp->len = sizeof(rapi_flowspec_t);
        Cat_Area(*areapp, (rapi_hdr_t *) flowsp);
 	return (0);
}


/*
 *	Construct RAPI sender-tspec object from value list:
 *	voff: +0=type(ignore), +1=r, +2=b, +3=p, +4=m, [+5=M]
 */
int
get_tspec(int voff, area_t **areapp, int size)
	{
	rapi_tspec_t		Tspec, *tspecp = &Tspec;
	qos_tspecx_t		*ctxp = &tspecp->tspecbody_qosx;
	
	ctxp->spec_type = QOS_TSPEC;
	ctxp->xtspec_r = Pm_val[voff+1];
	ctxp->xtspec_b = Pm_val[voff+2];
	ctxp->xtspec_p = Pm_val[voff+3];
	ctxp->xtspec_m = Pm_val[voff+4];
	ctxp->xtspec_M = 65535;
	if (Pm_vi > voff+5)
		ctxp->xtspec_M = Pm_val[voff+5];
	tspecp->len = sizeof(rapi_hdr_t) + sizeof(qos_tspecx_t);
	tspecp->form = RAPI_TSPECTYPE_Simplified;
		
        Cat_Area(*areapp, (rapi_hdr_t *) tspecp);
 	return (0);
}

/*
 *	Construct RAPI adspec object from value list:
 */

#define Valr Pm_val[voff+2]
	

void
set_adspec_p(int voff, int service, int parmno, int override)
	{
	qos_adspecx_t	*siap = &Adspec.adspecbody_qosx;

	/***
	printf("Set Serv= %d Parmno= %d Val = %d\n", service, parmno, Valr);
	***/

	switch (service) {
	    case GENERAL_INFO:
		switch(parmno) {

		case 0:  /* Global break bit */
			/* Since this is first call for Adspec, take the
			 * opportunity to clear the area, and assume IGN
			 * flags.
			 */
			memset((char *)siap, 0, sizeof(qos_adspecx_t));
			siap->xGaspec_flags = XASPEC_FLG_IGN;
			siap->xClaspec_flags = XASPEC_FLG_IGN;
			if (Valr)
				siap->xaspec_flags = XASPEC_FLG_BRK;
			break;

		case IS_WKP_HOP_CNT:
			siap->xaspec_hopcnt = Valr;
			break;
		case IS_WKP_PATH_BW:
			siap->xaspec_path_bw = Valr;
			break;
		case IS_WKP_MIN_LATENCY:
			siap->xaspec_min_latency =  Valr;
			break;
		case IS_WKP_COMPOSED_MTU:
			siap->xaspec_composed_MTU = Valr;
			break;
		}
		if (parmno != 0) {
			/* 	Make copy of general info parameter in
			 *	each specific service, as default.
			 */
			set_adspec_p(voff, GUARANTEED_SERV, parmno, 0);
			set_adspec_p(voff, CONTROLLED_LOAD_SERV, parmno, 0);
		}
		break;

	case GUARANTEED_SERV:
		if (override)
			siap->xGaspec_override = 1;
		switch(parmno) {

		case 0:  /* Guaranteed break bit: 0/1 */
			siap->xGaspec_flags &= ~XASPEC_FLG_IGN;
			if (Valr)
				siap->xGaspec_flags = XASPEC_FLG_BRK;
			break;

		case GUAR_ADSPARM_C:
			siap->xGaspec_flags |= XASPEC_FLG_PARM;
			siap->xGaspec_Ctot = Pm_val[voff+2];
			siap->xGaspec_Dtot = Pm_val[voff+3];
			siap->xGaspec_Csum = Pm_val[voff+4];
			siap->xGaspec_Dsum = Pm_val[voff+5];
			Pm_vi -= 3;
			return;

		case IS_WKP_HOP_CNT:
			siap->xGaspec_hopcnt = Valr;
			break;
		case IS_WKP_PATH_BW:
			siap->xGaspec_path_bw = Valr;
			break;
		case IS_WKP_MIN_LATENCY:
			siap->xGaspec_min_latency =  Valr;
			break;
		case IS_WKP_COMPOSED_MTU:
			siap->xGaspec_composed_MTU = Valr;
			break;
		}
		break;

	case CONTROLLED_LOAD_SERV:
		if (override)
			siap->xClaspec_override = 1;
		switch(parmno) {

		case 0:  /* Controlled Load break bit */
			siap->xClaspec_flags &= ~XASPEC_FLG_IGN;
			if (Valr)
				siap->xClaspec_flags = XASPEC_FLG_BRK;
			break;
		case IS_WKP_HOP_CNT:
			siap->xClaspec_hopcnt = Valr;
			break;
		case IS_WKP_PATH_BW:
			siap->xClaspec_path_bw = Valr;
			break;
		case IS_WKP_MIN_LATENCY:
			siap->xClaspec_min_latency = Valr;
			break;
		case IS_WKP_COMPOSED_MTU:
			siap->xClaspec_composed_MTU = Valr;
			break;
	  	}
		break;
	}
}


int
get_filter(int voff, area_t **areap, int size)
	{
	struct SOCKADDR sin;
	rapi_filter_t	Tfilt;

	get_sockaddr(voff, (struct sockaddr *) &sin);
	saddr_to_rapi_filt((struct sockaddr *) &sin, &Tfilt);
        Cat_Area(*areap, (rapi_hdr_t *) &Tfilt);
	return (0);
}

int
get_GPIfilter(int voff, area_t **areap, int size)
	{
	rapi_filter_t	Tfilt, *filtp = &Tfilt;
	net_addr	*addr = &Pm_addrs[voff];

	switch(NET_GET_TYPE(addr)) {
	    case NET_ADDR_IPv4:
		filtp->len = sizeof(rapi_hdr_t)+sizeof(rapi_filter_gpi_t);
		filtp->form =  RAPI_FILTERFORM_GPI;
		filtp->rapi_filtgpi4_addr = (struct in_addr)
						NET_GET_ADDR_IPv4(addr);
		filtp->rapi_filtgpi4_gpi = Pm_val[voff+1];
		break;

#ifdef	USE_IPV6
	    case NET_ADDR_IPv6:
		filtp->len = sizeof(rapi_hdr_t)+sizeof(rapi_filter_gpi6_t);
		filtp->form =  RAPI_FILTERFORM_GPI6;
		filtp->rapi_filtgpi6_addr = (struct in6_addr)
						NET_GET_ADDR_IPv6(addr);
		filtp->rapi_filtgpi6_gpi = Pm_val[voff+1];
		break;
#endif	/* USE_IPV6 */
	    default:
		/* Bad address format: should return error code. */
		break;
	}
	Cat_Area(*areap, (rapi_hdr_t *) filtp);
	return (0);
}
	

/*
 *	rtap_cmds_init(): Initialization routine, called to start things off.
 */
void
rtap_cmds_init()
	{
	int i;

	Pm_Init(rtap_mem);

	for (i = 0; i < MAX_T; i++) {
		Filter_specs[i] = NULL;
               	Flowspecs[i] = NULL;
                snd_template[i] = NULL;
                snd_tspec[i] = NULL;
                Sid[i] = ttl[i] = 0;
               	Mode[i] = NO_MODE;
		resv_flags[i] = 0;
		udpsock[i] = -1;
               	memset(&dest[i], 0, sizeof(struct SOCKADDR));
               	memset(&src[i], 0, sizeof(struct SOCKADDR));
               	memset(&rcvr[i], 0, sizeof(struct SOCKADDR));

#ifdef DATA
		timeout = Default_interval;
		data_size = 0;
#endif
	}
	packet_size = 0;
}

/*
 *  Do_Command(): Top-level routine to read the next line from a given
 *	file and execute the command it contains.  Returns 0 if EOF, else 1.
 */
int
Do_Command(char *infile, FILE *infp)
	{
	char	cmd_line[256], cmd_op[80];
	struct cmds    *cmdp;
	char	*cp;
	int	rc;

	if (fgets(cmd_line, sizeof(cmd_line), infp) == NULL) {
		printf("No input\n");
		return(0);
	}
	/* remove trailing NL */
	cp = cmd_line + strlen(cmd_line) - 1;
	if (*cp == '\n')
		*cp = '\0';
	else {
		printf("LINE > 255 CHARS: %s.\n", cmd_line);
		exit(1);
	}
	/*** printf("Do_Command: %s\n", cmd_line); ***/
	if (infile)
		printf("%12s > %s\n", rsvp_timestamp(), cmd_line);

	if (cmd_line[0] == '#') {	/* Comment, skip this line */
		return(1);
	}
	cp = cmd_line;
	if (!next_word(&cp, cmd_op))
		return(1);
	if (cmd_op[0] == 'T') {
		int n;

		if (isdigit(cmd_op[1])) {
			n = atoi(&cmd_op[1]);
			if (n <= 0 || n >= MAX_T) {
				printf("T out of range\n");
				return(1);
			}
			T = n;
		} else {
			switch (cmd_op[1]) {
			    case '\0':
				return(1);

			    case '+':
				T++;
				break;
	
			    case '-':
				T--;
				break;

		/***	    case '*';
				break;
		***/

			    default:
				printf(" ??\n");
				return(1);
			}
		}
		if (!next_word(&cp, cmd_op))
			return(1);
	}
	cmdp = cmd_table;
	while ((cmdp->cmd_op != OP_NULL) && pfxcmp(cmd_op, cmdp->cmd_verb))
		cmdp++;
	if (cmdp->cmd_op == OP_NULL) {
		if (cmd_op[0])
			printf(" ?? %s\n", cmd_op);
		return(1);
	}
	/*	Initialize parse machine: semantic stack and scan pointer.
	 */
	Pm_vi = 0;
	Pm_cp = cp;
	if (packet_size > 0 && cmdp->cmd_op != OP_HEXMSG) {
		printf("Hexmsg cmd not terminated \n");
		packet_size = 0;
	}
	rc = Parse_machine(rtap_mem, cmdp->cmd_op);
	if (rc != OK)
		printf("Error.\n");
	if (rc == NO)
		return(0);
	return(1);
}


void
saddr_to_rapi_filt(
	struct sockaddr		*host,
	rapi_filter_t		*p)
	{
	switch (host->sa_family) {
		case AF_INET:
			p->form = RAPI_FILTERFORM_BASE;
			p->len = sizeof(rapi_hdr_t)
				+ sizeof(rapi_filter_base_t);
			p->rapi_filt4 = *(struct sockaddr_in *) host;
			break;
#ifdef	USE_IPV6
		case AF_INET6:
			p->form = RAPI_FILTERFORM_BASE6;
			p->len = sizeof(rapi_hdr_t)
				+ sizeof(rapi_filter_base6_t);
			p->rapi_filt6 = *(struct sockaddr_in6 *) host;
			break;
#endif	/* USE_IPV6 */
		default:
			p->form = RAPI_EMPTY_OTYPE;
			break;
	}
}


/*
 * Prefix string comparison: Return 0 if s1 string is prefix of s2 string, 1
 * otherwise.
 */
int 
pfxcmp(s1, s2)
	register char  *s1, *s2;
{
	while (*s1)
		if (*s1++ != *s2++)
			return (1);
	return (0);
}

int
asynch_handler(
	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,