rapi_lib.c

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

	{
	IS_serv_hdr_t	*isshp = (IS_serv_hdr_t *) &d_spec->specbody_IS.spec_u;
	int		 rapilen;

	rapilen = (Use_Intserv)? RAPIObj_Size(d_spec) :
			sizeof(qos_flowspecx_t) + sizeof(rapi_hdr_t);
	if ((char *)i_spec + rapilen > endp) {
		rapi_errno = RAPI_ERR_OVERFLOW;
		return -1;
	}
	i_spec->len = rapilen;


	if (Use_Intserv) {
		/*	RAPI format is int-serv body with RAPI framing,
		 *	that is, we can just copy RAPI object without change.
		 */
		memcpy((char *) i_spec, (char *) d_spec, rapilen);
		return 0;
	}
	i_spec->form = RAPI_FLOWSTYPE_Simplified;
	switch (isshp->issh_service) {

	    case CONTROLLED_LOAD_SERV:
		CLtoCSZX_spec(&d_spec->specbody_IS, &i_spec->specbody_qosx);
		return 0;

	    case GUARANTEED_SERV:
		GtoCSZX_spec(&d_spec->specbody_IS, &i_spec->specbody_qosx);
		return 0;

	    default:
		rapi_errno = RAPI_ERR_INTSERV;
		return -1;
	}
}

static int
copy_tspec_d2i(API_TSpec * d_spec, rapi_tspec_t * i_spec, char *endp,
							int Use_Intserv)
	{
	IS_serv_hdr_t	*isshp = (IS_serv_hdr_t *)&d_spec->tspecbody_IS.tspec_u;
	int	rapilen;

	rapilen = (Use_Intserv)? RAPIObj_Size(d_spec) :
			sizeof(qos_tspecx_t) + sizeof(rapi_hdr_t);
	if ((char *)i_spec + rapilen > endp) {
		rapi_errno = RAPI_ERR_OVERFLOW;
		return -1;
	}
	i_spec->len = rapilen;
	if (Use_Intserv) {
		memcpy((char *) i_spec, (char *) d_spec, rapilen);
		return 0;
	}
	i_spec->form = RAPI_TSPECTYPE_Simplified;
	switch (isshp->issh_service) {

	    case GENERAL_INFO:
		GentoCSZX_tspec(&d_spec->tspecbody_IS, &i_spec->tspecbody_qosx);
		return 0;

	    default:
		rapi_errno = RAPI_ERR_INTSERV;
		return -1;
	}
}

static int
copy_adspec_d2i(API_Adspec * d_adspp, rapi_adspec_t * i_adspp, char *endp,
							int Use_Intserv)
	{
	int	rapilen;

	rapilen = (Use_Intserv)? RAPIObj_Size(d_adspp) :
			sizeof(qos_adspecx_t) + sizeof(rapi_hdr_t);
	if ((char *)i_adspp + rapilen > endp) {
		rapi_errno = RAPI_ERR_OVERFLOW;
		return -1;
	}
	i_adspp->len = rapilen;
	if (Use_Intserv) {
		i_adspp->form = RAPI_ADSTYPE_Intserv;
		memcpy((char *) i_adspp, (char *) d_adspp, rapilen);
	} else {
		/* Convert Intserv format to Simplified format.
		 */
		i_adspp->form = RAPI_ADSTYPE_Simplified;
		IStoCSZX_adspec(&d_adspp->adspecbody_IS, 
						&i_adspp->adspecbody_qosx);
	}
	return 0;
}


static int
copy_filterspec_d2i(API_FilterSpec * d_filter, rapi_filter_t * i_filter,
							char *endp) {
#ifdef USE_NET_BO
	NTOH_RAPIhdr(d_filter);
#endif /* USE_NET_BO */
	if ((char *)i_filter + RAPIObj_Size(d_filter) > endp) {
		rapi_errno = RAPI_ERR_OVERFLOW;
		return -1;
	}
	memcpy((char *) i_filter, (char *) d_filter, RAPIObj_Size(d_filter));
	return 0;
}

static char *
copy_policy_i2d(
        rapi_policy_t   *i_pol,
        rapi_policy_t   *o_pol,
	char		*endp,
	int 		 policy)
	{
	char *next;

	i_pol = (rapi_policy_t *) &Empty_RObj;  /*** ALWAYS EMPTY ! ***/
	if ((char *)o_pol + RAPIObj_Size(i_pol) > endp) {
		rapi_errno = RAPI_ERR_OVERFLOW;
		return NULL;
	}
	memcpy((char *) o_pol, (char *)i_pol, RAPIObj_Size(i_pol));
	next = After_RAPIObj(o_pol);
#ifdef USE_NET_BO
	HTON_RAPIhdr(o_pol);
#endif /* USE_NET_BO */
	return (next);
}


/*	Build (Intserv) Guaranteed Flowspec from Simplified-format flowspec
 */
int
CSZXtoG_spec(qos_flowspecx_t *csxp, IS_specbody_t *ISp)
	{
	Guar_flowspec_t *gp = &ISp->spec_u.G_spec;

	Set_Main_Hdr(&ISp->spec_mh, sizeof(Guar_flowspec_t));
	Set_Serv_Hdr(&gp->Guar_serv_hdr, GUARANTEED_SERV, Gspec_len);
	Set_Parm_Hdr(&gp->Guar_Tspec_hdr, IS_WKP_TB_TSPEC,
							sizeof(TB_Tsp_parms_t));
	gp->Gspec_r = csxp->xspec_r;
	gp->Gspec_b = csxp->xspec_b;
	gp->Gspec_p = csxp->xspec_p;
	gp->Gspec_m = csxp->xspec_m;
	gp->Gspec_M = csxp->xspec_M;

	Set_Parm_Hdr(&gp->Guar_Rspec_hdr, IS_GUAR_RSPEC, sizeof(guar_Rspec_t));
	gp->Gspec_R = csxp->xspec_R;
	gp->Gspec_S = csxp->xspec_S;
	return(0);
}


/*	Build (Intserv) Generic Tspec from Simplified-format Tspec
 */
int
CSZXtoGen_tspec(qos_tspecx_t *csxtp, IS_tspbody_t *IStp)
	{
	gen_Tspec_t *gtp = &IStp->tspec_u.gen_stspec;

	Set_Main_Hdr(&IStp->st_mh, sizeof(gen_Tspec_t));
	Set_Serv_Hdr(&gtp->gen_Tspec_serv_hdr, GENERAL_INFO, gtspec_len);
	Set_Parm_Hdr(&gtp->gen_Tspec_parm_hdr, IS_WKP_TB_TSPEC,
						sizeof(TB_Tsp_parms_t));
	gtp->gtspec_r = csxtp->xtspec_r;
	gtp->gtspec_b = csxtp->xtspec_b;
	gtp->gtspec_p = csxtp->xtspec_p;
	gtp->gtspec_m = csxtp->xtspec_m;
	gtp->gtspec_M = csxtp->xtspec_M;
	return(0);
}

/*	Build (Intserv) Controlled-Load Flowspec from Simplified-format Flowspec
 */
int
CSZXtoCL_spec(qos_flowspecx_t *csxp, IS_specbody_t *ISp)
	{
	CL_flowspec_t *clsp = &ISp->spec_u.CL_spec;

	Set_Main_Hdr(&ISp->spec_mh, sizeof(CL_flowspec_t));
	Set_Serv_Hdr(&clsp->CL_spec_serv_hdr, CONTROLLED_LOAD_SERV, CLspec_len);
	Set_Parm_Hdr(&clsp->CL_spec_parm_hdr, IS_WKP_TB_TSPEC, 
							sizeof(TB_Tsp_parms_t));
	clsp->CLspec_r = csxp->xspec_r;
	clsp->CLspec_b = csxp->xspec_b;
	clsp->CLspec_p = csxp->xspec_p;
	clsp->CLspec_m = csxp->xspec_m;
	clsp->CLspec_M = csxp->xspec_M;
	return(0);
}


/*	Map Intserv Guaranteed Flowspec into Simplified format
 */
int
GtoCSZX_spec(IS_specbody_t *ISp, qos_flowspecx_t *csxp)
	{
	Guar_flowspec_t *gp = &ISp->spec_u.G_spec;

	csxp->xspec_r = gp->Gspec_r;
	csxp->xspec_b = gp->Gspec_b;
	csxp->xspec_m = gp->Gspec_m;
	csxp->xspec_M = gp->Gspec_M;
	csxp->xspec_p = gp->Gspec_p;
	csxp->xspec_R = gp->Gspec_R;
	csxp->xspec_S = gp->Gspec_S;
	csxp->spec_type = QOS_GUARANTEEDX;
	return(0);
}

/*	Map Intserv Controlled-Load Flowspec into Simplified format
 *	(We don't check format here... assume intserv format is OK)
 */
int
CLtoCSZX_spec(IS_specbody_t *ISp, qos_flowspecx_t *csxp)
	{
	CL_flowspec_t *clsp = &ISp->spec_u.CL_spec;

	csxp->xspec_r = clsp->CLspec_r; 
	csxp->xspec_b = clsp->CLspec_b; 
	csxp->xspec_p = clsp->CLspec_p;
	csxp->xspec_m = clsp->CLspec_m; 
	csxp->xspec_M = clsp->CLspec_M; 
	csxp->xspec_R = 0;
	csxp->xspec_S = 0;
	csxp->spec_type = QOS_CNTR_LOAD;
	return(0);
}

/*	Map Intserv Generic Tspec into Simplified format Tspec
 *	(We don't check format here... assume intserv format is OK)
 */
int
GentoCSZX_tspec(IS_tspbody_t *IStp, qos_tspecx_t *ctxp)
	{
	gen_Tspec_t *gtp = &IStp->tspec_u.gen_stspec;

	ctxp->xtspec_r = gtp->gtspec_r; 
	ctxp->xtspec_b = gtp->gtspec_b; 
	ctxp->xtspec_p = gtp->gtspec_p; 
	ctxp->xtspec_m = gtp->gtspec_m; 
	ctxp->xtspec_M = gtp->gtspec_M;
	ctxp->spec_type = QOS_TSPECX;
	return(0);
}

#define Move_parm2SF(t, y) siap->y = * (t *) (php+1)

/*	Map Intserv Adspec into Simplified format Adspec
 */
int
IStoCSZX_adspec(IS_adsbody_t *ISap, qos_adspecx_t *siap)
	{
	IS_main_hdr_t	*mhp = (IS_main_hdr_t *)ISap;
	IS_serv_hdr_t	*shp = (IS_serv_hdr_t *)(mhp+1); /* Ptr to 1st frag */
	IS_serv_hdr_t	*lastshp = (IS_serv_hdr_t *) Next_Main_Hdr(mhp);
	IS_parm_hdr_t	*php, *lastphp;

	memset((char *)siap, 0, sizeof(qos_adspecx_t));
	siap->xGaspec_flags = XASPEC_FLG_IGN;
	siap->xClaspec_flags = XASPEC_FLG_IGN;

	if (mhp->ismh_version != INTSERV_VERSION0) {
		return(-1);  /* All zero if ill-formed int-serv adspec */
	}
	while (shp < lastshp) {
	    lastphp = (IS_parm_hdr_t *)Next_Serv_Hdr(shp);

	    switch(shp->issh_service) {

		case GENERAL_INFO:
			{
			genparm_parms_t *gp = (genparm_parms_t *)shp;
			/*
			 *	Move default general parameters into default 
			 *	slots and into service-specific override slots.
			 */
			if (shp->issh_flags&ISSH_BREAK_BIT)
				siap->xaspec_flags = XASPEC_FLG_BRK;
			siap->xaspec_hopcnt =  gp->gen_parm_hopcnt;
			siap->xaspec_path_bw = gp->gen_parm_path_bw;
			siap->xaspec_min_latency =  gp->gen_parm_min_latency;
			siap->xaspec_composed_MTU = gp->gen_parm_composed_MTU;

			/*	Also copy general parameters into override
			 *	fields, in case they are needed.
			 */
			siap->xClaspec_hopcnt = gp-> gen_parm_hopcnt;
			siap->xClaspec_path_bw = gp-> gen_parm_path_bw;
			siap->xClaspec_min_latency = gp-> gen_parm_min_latency;
			siap->xClaspec_composed_MTU = 
						gp-> gen_parm_composed_MTU;

			siap->xGaspec_hopcnt = gp-> gen_parm_hopcnt;
			siap->xGaspec_path_bw = gp-> gen_parm_path_bw;
			siap->xGaspec_min_latency = gp-> gen_parm_min_latency;
			siap->xGaspec_composed_MTU = gp-> gen_parm_composed_MTU;
			break;

		case GUARANTEED_SERV:
			siap->xGaspec_flags &= ~XASPEC_FLG_IGN;
			if (shp->issh_flags&ISSH_BREAK_BIT)
				siap->xGaspec_flags = XASPEC_FLG_BRK;
	    		for (php = (IS_parm_hdr_t *)(shp+1); php < lastphp;
						php = Next_Parm_Hdr(php)) {
			    switch (php->isph_parm_num) {

			    case GUAR_ADSPARM_Ctot:
				siap->xGaspec_flags |= XASPEC_FLG_PARM;
				siap->xGaspec_Ctot = *(u_int32_t *)(php+1);
				break;

			    case GUAR_ADSPARM_Dtot:
				siap->xGaspec_Dtot = *(u_int32_t *)(php+1);
				break;

			    case GUAR_ADSPARM_Csum:
				siap->xGaspec_Csum = *(u_int32_t *)(php+1);
				break;

			    case GUAR_ADSPARM_Dsum:
				siap->xGaspec_Dsum = *(u_int32_t *)(php+1);
				break;

			    case IS_WKP_HOP_CNT:
			        siap->xGaspec_override = 1;
				Move_parm2SF(u_int16_t, xGaspec_hopcnt);
				break;

		    	    case IS_WKP_PATH_BW:
			        siap->xGaspec_override = 1;
				Move_parm2SF(float32_t, xGaspec_path_bw);
				break;

		    	    case IS_WKP_MIN_LATENCY:
			        siap->xGaspec_override = 1;
				Move_parm2SF(u_int32_t, xGaspec_min_latency);
				break;

		    	    case IS_WKP_COMPOSED_MTU:
			        siap->xGaspec_override = 1;
				Move_parm2SF(u_int32_t, xGaspec_composed_MTU);
				break;

		    	    default:
				break;
			    }
	  		}
			break;
			}

		case CONTROLLED_LOAD_SERV:
			siap->xClaspec_flags &= ~XASPEC_FLG_IGN;
			if (shp->issh_flags&ISSH_BREAK_BIT)
				siap->xClaspec_flags = XASPEC_FLG_BRK;
			
	    		for (php = (IS_parm_hdr_t *)(shp+1); php < lastphp;
						php = Next_Parm_Hdr(php)) {
			    siap->xClaspec_override = 1;
			    switch (php->isph_parm_num) {
			    case IS_WKP_HOP_CNT:
				siap->xClaspec_hopcnt = *(u_int32_t *)(php+1);
				break;
		    	    case IS_WKP_MIN_LATENCY:
				siap->xClaspec_min_latency =
							*(u_int32_t *)(php+1);
				break;
		    	    case IS_WKP_COMPOSED_MTU:
				siap->xClaspec_composed_MTU = 
							*(u_int32_t *)(php+1);
				break;
		    	    case IS_WKP_PATH_BW:
				siap->xClaspec_path_bw = *(u_int32_t *)(php+1);
				break;
		    	    default:
				break;
			    }
	  		}
			break;

		default:
			break;
		}
		shp = (IS_serv_hdr_t *)lastphp;
	    }
	return (0);
}

#define Set_Parm(id, t, val) {t *xxx = (t *)(php+1); \
			Set_Parm_Hdr(php, id, sizeof(t)); \
			*xxx = val; php++; \
			cumlen += (sizeof(IS_parm_hdr_t)+sizeof(t));\
			php = (IS_parm_hdr_t *)(xxx+1);}

/*	Map Simplified format Adspec into Intserv Adspec
 */
int
CSZXtoIS_adspec(qos_adspecx_t *siap, IS_adsbody_t *ISap)
	{
	IS_main_hdr_t	*mhp = (IS_main_hdr_t *)ISap;
	IS_serv_hdr_t	*shp = (IS_serv_hdr_t *)(mhp+1); /* Ptr to 1st frag */
	genparm_parms_t *genp;
	IS_parm_hdr_t	*php;	/* Parameter pointer */
	int		cumlen;

	genp = (genparm_parms_t *)shp;
	php = (IS_parm_hdr_t *)(shp+1);
	cumlen = 0;
	Set_Parm(IS_WKP_HOP_CNT, u_int32_t, siap->xaspec_hopcnt);
	Set_Parm(IS_WKP_PATH_BW, float32_t, siap->xaspec_path_bw);
	Set_Parm(IS_WKP_MIN_LATENCY, u_int32_t, siap->xaspec_min_latency);
	Set_Parm(IS_WKP_COMPOSED_MTU, u_int32_t, siap->xaspec_composed_MTU);
 	Set_Serv_Hdr(shp, GENERAL_INFO, cumlen);
#ifdef ISI_TEST
	if (siap->xaspec_flags & XASPEC_FLG_BRK)
		Set_Break_Bit(shp);
#endif
	shp = (IS_serv_hdr_t *)(php);

	if (!(siap->xGaspec_flags & XASPEC_FLG_IGN)) {
	    php = (IS_parm_hdr_t *)(shp+1);
	    cumlen = 0;
	    if (siap->xGaspec_flags & XASPEC_FLG_PARM) {
	    	Set_Parm(GUAR_ADSPARM_Ctot, u_int32_t, siap->xGaspec_Ctot);
	    	Set_Parm(GUAR_ADSPARM_Dtot, u_int32_t, siap->xGaspec_Dtot);
	    	Set_Parm(GUAR_ADSPARM_Csum, u_int32_t, siap->xGaspec_Csum);
	   	Set_Parm(GUAR_ADSPARM_Dsum, u_int32_t, siap->xGaspec_Dsum);
	    }
#ifdef ISI_TEST
	    if (siap->xGaspec_override) {
		if (siap->xGaspec_hopcnt != genp->gen_parm_hopcnt)
			Set_Parm(IS_WKP_HOP_CNT, u_int32_t, 
						siap->xGaspec_hopcnt);
		if (siap->xGaspec_path_bw != genp->gen_parm_path_bw)
			Set_Parm(IS_WKP_PATH_BW, float32_t, 
						siap->xGaspec_path_bw);
		if (siap->xGaspec_min_latency != genp->gen_parm_min_latency)
			Set_Parm(IS_WKP_MIN_LATENCY, u_int32_t, 
						siap->xGaspec_min_latency);
		if (siap->xGaspec_composed_MTU != genp->gen_parm_composed_MTU)
			Set_Parm(IS_WKP_COMPOSED_MTU, u_int32_t, 
						siap->xGaspec_composed_MTU);
	    }
#else
	Set_Break_Bit(shp);	/* We do not support GUARANTEED */
#endif
	}
	Set_Serv_Hdr(shp, GUARANTEED_SERV, cumlen);
	if (siap->xGaspec_flags & XASPEC_FLG_BRK)
		Set_Break_Bit(shp);
	shp = (IS_serv_hdr_t *)php;

	if (!(siap->xClaspec_flags & XASPEC_FLG_IGN)) {
	    php = (IS_parm_hdr_t *)(shp+1);
	    cumlen = 0;
#ifdef ISI_TEST
	    if (siap->xClaspec_override) {
		if (siap->xClaspec_hopcnt != genp->gen_parm_hopcnt)
			Set_Parm(IS_WKP_HOP_CNT, u_int32_t, 
						siap->xClaspec_hopcnt);
		if (siap->xClaspec_path_bw != genp->gen_parm_path_bw)
			Set_Parm(IS_WKP_PATH_BW, float32_t, 
						siap->xClaspec_path_bw);
		if (siap->xClaspec_min_latency != genp->gen_parm_min_latency)
			Set_Parm(IS_WKP_MIN_LATENCY, u_int32_t, 
						siap->xClaspec_min_latency);
		if (siap->xClaspec_composed_MTU != genp->gen_parm_composed_MTU)
			Set_Parm(IS_WKP_COMPOSED_MTU, u_int32_t, 
						siap->xClaspec_composed_MTU);
	    }
#else
	Set_Break_Bit(shp);	/* We do not support CONTROLLED LOAD */
#endif
	}
	Set_Serv_Hdr(shp, CONTROLLED_LOAD_SERV, cumlen);
	if (siap->xClaspec_flags & XASPEC_FLG_BRK)
		Set_Break_Bit(shp);
	shp = (IS_serv_hdr_t *)php;
	Set_Main_Hdr(mhp, (char *)shp - (char *)genp);
	return 0;
}

void
hton_rapi_cmd(rapi_cmd_t *cmd) {
}

int
api_addr_assign(api_addr *addr,const struct sockaddr *s)
{
	switch (s->sa_family) {
		case AF_INET:
			addr->type = htons(API_ADDR_TYPE_IPv4);
			addr->port = ((struct sockaddr_in *) s)->sin_port;
			memcpy(&addr->u.addr_ipv4,
				&(((struct sockaddr_in *) s)->sin_addr),
				sizeof(addr->u.addr_ipv4));
			return(TRUE);
#ifdef	USE_IPV6
		case AF_INET6:
			addr->type = htons(API_ADDR_TYPE_IPv6);
			addr->port = ((struct sockaddr_in6 *) s)->sin6_port;
			memcpy(&addr->u.addr_ipv6,
				&(((struct sockaddr_in6 *) s)->sin6_addr),
				sizeof(addr->u.addr_ipv6));
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}

int
sockaddr_assign(struct sockaddr *s,const api_addr *addr)
{
	switch (ntohs(addr->type)) {
		case API_ADDR_TYPE_IPv4:
			s->sa_family = AF_INET;
			((struct sockaddr_in *) s)->sin_port = addr->port;
			memcpy(&(((struct sockaddr_in *) s)->sin_addr),
				&addr->u.addr_ipv4,
				sizeof(addr->u.addr_ipv4));
			return(TRUE);
#ifdef	USE_IPV6
		case API_ADDR_TYPE_IPv6:
			s->sa_family = AF_INET6;
			((struct sockaddr_in6 *) s)->sin6_port = addr->port;
			memcpy(&(((struct sockaddr_in6 *) s)->sin6_addr),
				&addr->u.addr_ipv6,
				sizeof(addr->u.addr_ipv6));
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}