rsvp_specs.c

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

		clpx->CLspec_r = MIN(clp1->CLspec_r, clp2->CLspec_r);
		clpx->CLspec_b = MIN(clp1->CLspec_b, clp2->CLspec_b);
		clpx->CLspec_p = INFINITY32f;
		clpx->CLspec_m = MAX(clp1->CLspec_m, clp2->CLspec_m);
		clpx->CLspec_M = MIN(clp1->CLspec_M, clp2->CLspec_M);
		}
		break;

	default:
		return NULL;
	}
	return (FLOWSPEC *) &sx;
}

/*
 *  De-Merge two flowspecs.  Used while processing a ResvErr message, to
 *	determine where to forward the error.  Call is:
 *		demerge_flowspecs(Err_Q, RSB_Q),
 *	where Err_Q = flowspec from ResvErr message, and RSB_Q = flowspec in
 *	a reservation.   May return:
 *		SPECS_NEQ if RSB_Q did not contribute to Err_Q
 *		SPECS_EQL if RSB_Q did contribute to Err_Q
 *		SPECS_USELUB if RSB_Q did contribute to Err_Q but only via LUB.
 */
int
demerge_flowspecs(FLOWSPEC *spe, FLOWSPEC *spr)
	{
	IS_serv_hdr_t	*sp1, *sp2;

	if (Obj_CType(spe) != ctype_FLOWSPEC_Intserv0)
		return SPECS_NEQ;

	if (Intserv_Obj_size(&spe->flow_body.spec_mh) != Obj_Length(spe) ||
	    !Intserv_Version_OK(&spe->flow_body.spec_mh))
		return SPECS_NEQ;

	sp1 = (IS_serv_hdr_t *) &spe->flow_body.spec_u;
	sp2 = (IS_serv_hdr_t *) &spr->flow_body.spec_u;

	if (sp1->issh_service != sp2->issh_service)
		return(0);

	switch (sp1->issh_service) {

	    case GUARANTEED_SERV:
		{ Guar_flowspec_t *o1 = (Guar_flowspec_t *) sp1;
		  Guar_flowspec_t *o2 = (Guar_flowspec_t *) sp2;
		
		if (o1->Gspec_r == o2->Gspec_r
		 || o1->Gspec_b == o2->Gspec_b
		 || o1->Gspec_p == o2->Gspec_p
		 || o1->Gspec_m == o2->Gspec_m
		 || o1->Gspec_M == o2->Gspec_M
		 || o1->Gspec_R == o2->Gspec_R
		 || o1->Gspec_S == o2->Gspec_S)
			return SPECS_EQL;
		else
			return SPECS_USELUB;
		}

	    case CONTROLLED_LOAD_SERV:
		{ CL_flowspec_t *o1 = (CL_flowspec_t *) sp1;
		  CL_flowspec_t *o2 = (CL_flowspec_t *) sp2;

		if (o1->CLspec_r == o2->CLspec_r
		 || o1->CLspec_b == o2->CLspec_b
		 || o1->CLspec_p == o2->CLspec_p
		 || o1->CLspec_m == o2->CLspec_m
		 || o1->CLspec_M == o2->CLspec_M)
			return SPECS_EQL;
		else
			return SPECS_USELUB;
		}

	default:
		break;
	}
	return SPECS_NEQ;
}


/*
 *	Compare two Sender Tspecs for equality, and return one of:
 *		SPECS_EQL:	Two are equal (identical)
 *		SPECS_NEQ:	Two are unequal
 *		SPECS_INCOMPAT: They are incompatible.
 *		SPEC1_BAD:	First contains error
 *		SPEC2_BAD:	Second contains error
 */
int
Compare_Tspecs(SENDER_TSPEC *st1, SENDER_TSPEC *st2)
	{
	IS_serv_hdr_t	*sp1, *sp2;

	if (!st1)
		return (!st2)? SPECS_EQL: SPECS_NEQ;
	else if (!st2)
		return SPECS_NEQ;

	if (Obj_CType(st1) != ctype_SENDER_TSPEC_CTYPE)
		return SPEC1_BAD;
	if (Obj_CType(st2) != ctype_SENDER_TSPEC_CTYPE)
		return SPEC2_BAD;

	if (Intserv_Obj_size(&st1->stspec_body.st_mh) > Obj_Length(st1) ||
	    !Intserv_Version_OK(&st1->stspec_body.st_mh))
		return SPEC1_BAD;
	if (Intserv_Obj_size(&st2->stspec_body.st_mh) > Obj_Length(st2) ||
	    !Intserv_Version_OK(&st2->stspec_body.st_mh))
		return SPEC2_BAD;

	sp1 = (IS_serv_hdr_t *) &st1->stspec_body.tspec_u;
	sp2 = (IS_serv_hdr_t *) &st2->stspec_body.tspec_u;

	/* For now, regard two different services as incompatible.
	 */
	if (sp1->issh_service != sp2->issh_service)
		return SPECS_INCOMPAT;

	switch (sp1->issh_service) {

	    case CONTROLLED_LOAD_SERV:	/* XXX OBSOLETE */
	    case GUARANTEED_SERV:	/* XXX OBSOLETE */
	    case GENERAL_INFO:
		{ gen_Tspec_t *o1 = (gen_Tspec_t *) sp1;
		  gen_Tspec_t *o2 = (gen_Tspec_t *) sp2;

		if (st1->stspec_body.st_mh.ismh_len32b !=
					wordsof(sizeof(gen_Tspec_t)))
			return SPEC1_BAD;
		if (st2->stspec_body.st_mh.ismh_len32b !=
					wordsof( sizeof(gen_Tspec_t)))
			return SPEC2_BAD;
		if (o1->gtspec_r == o2->gtspec_r
		 && o1->gtspec_b == o2->gtspec_b
		 && o1->gtspec_p == o2->gtspec_p
		 && o1->gtspec_m == o2->gtspec_m
		 && o1->gtspec_M == o2->gtspec_M)
			return SPECS_EQL;

		else
			return SPECS_NEQ;
		}

	default:
		break;
	}
	return SPECS_INCOMPAT;
}


/*	Compute sum of two Tspecs, in second argument.
 */
int
addTspec2sum(SENDER_TSPEC *tsp1, SENDER_TSPEC *tsp2)
	{
	IS_serv_hdr_t	*sp1, *sp2;

	assert((tsp1) && (tsp2));
	sp1 = (IS_serv_hdr_t *) &tsp1->stspec_body.tspec_u;
	sp2 = (IS_serv_hdr_t *) &tsp2->stspec_body.tspec_u;

	if (sp2->issh_service == 0) {
		/*
		 *	First call: *tsp2 is zero.  Initialize it
		 *	appropriately from *tsp1.
		 */
		return(newTspec_sum(tsp1, tsp2));
	}
		
	switch (sp1->issh_service) {

	    case GENERAL_INFO:
		/* Guaranteed service uses generic Tspec format
		 */
		{ gen_Tspec_t *gp1 = (gen_Tspec_t *) sp1;
		  gen_Tspec_t *gp2 = (gen_Tspec_t *) sp2;

		if (tsp1->stspec_body.st_mh.ismh_len32b != 
						wordsof(sizeof(gen_Tspec_t)))
			return(-1);
		if (gp1->gtspec_parmno != IS_WKP_TB_TSPEC) {
			return(-1);
		}
		if (gp1->gtspec_flags & ISPH_FLG_INV)
			return(0);
		gp2->gtspec_r += gp1->gtspec_r;
		gp2->gtspec_b += gp1->gtspec_b;
		gp2->gtspec_p += gp1->gtspec_p;
		gp2->gtspec_m = MIN(gp2->gtspec_m, gp1->gtspec_m);
		gp2->gtspec_M = MAX(gp2->gtspec_M, gp1->gtspec_M);
		}
		break;
		
	    default:
		return(-1);
	}
	return(0);
}

/*	Initialize sum of Tspecs *tsp from Tspec *tsp_in
 *
 */
int
newTspec_sum(SENDER_TSPEC *tsp_in, SENDER_TSPEC *tsp)
	{
	IS_tspbody_t	*ISp = &tsp->stspec_body;
	IS_serv_hdr_t	*sp_in, *sp;

	assert(tsp);
	assert(Obj_Length(tsp) >= sizeof(IS_tspbody_t)+sizeof(Object_header));

	ISp->st_mh.ismh_version = INTSERV_VERSION0;
	sp = (IS_serv_hdr_t *) &tsp->stspec_body.tspec_u;
	sp_in = (IS_serv_hdr_t *) &tsp_in->stspec_body.tspec_u;

	switch (sp_in->issh_service) {

	    case GENERAL_INFO:
	    case GUARANTEED_SERV:		/* XXX OBSOLETE */
	    case CONTROLLED_LOAD_SERV:		/* XXX OBSOLETE */
		/* Guaranteed service uses generic Tspec format
		 */
		{
		gen_Tspec_t *gp = &tsp->stspec_body.tspec_u.gen_stspec;
		gen_Tspec_t *gp_in = &tsp_in->stspec_body.tspec_u.gen_stspec;

		Set_Main_Hdr(&ISp->st_mh, sizeof(gen_Tspec_t));
		Set_Serv_Hdr(&gp->gen_Tspec_serv_hdr, GENERAL_INFO, gtspec_len);
		Set_Parm_Hdr(&gp->gen_Tspec_parm_hdr, IS_WKP_TB_TSPEC,
							sizeof(TB_Tsp_parms_t));
		gp->gtspec_flags = gp_in->gtspec_flags;
		gp->gtspec_r = gp_in->gtspec_r;
		gp->gtspec_b = gp_in->gtspec_b;
		gp->gtspec_p = gp_in->gtspec_p;
		gp->gtspec_m = gp_in->gtspec_m;
		gp->gtspec_M = gp_in->gtspec_M;
		}
		break;
		
	    default:
		return(-1);
	}
	return(0);
}

/*	Compare two ADSPECs
 *		Return 1 if different, 0 if identical.   XXX NOT USED
 */
int
Compare_Adspecs(ADSPEC *ap1, ADSPEC *ap2)
	{
	int		ctype;
	IS_serv_hdr_t	*asp1, *asp2;

	if (!ap1 && !ap2)
		return(0);
	else if (!ap1||!ap2)
		return(1);

	ctype = Obj_CType(ap1);

	/*
	if (ctype != ctype_ADSPEC_INTSERV || ctype != Obj_CType(ap2))
		return(1);
	*/

	asp1 = (IS_serv_hdr_t *) &ap1->adspec_body.adspec_genparms;
	asp2 = (IS_serv_hdr_t *) &ap2->adspec_body.adspec_genparms;

	switch (asp1->issh_service) {

	    case GENERAL_INFO:
		{
		/* XXX TBD */
		return 0;
		}

	    case GUARANTEED_SERV:
		{
		/* XXX TBD */
		return 0;
		}

	    default:
		break;
	}
	return(0);
}

/*
 *	Construct new (minimal) Adspec.  Called at sender node when sender
 *	app does not provide its own initial adspec.
 */
int
New_Adspec(ADSPEC *ap)
	{
	IS_adsbody_t		*ISap = &ap->adspec_body;
	genparm_parms_t 	*genp = &ISap->adspec_genparms;
	IS_serv_hdr_t		*shp;	/* Fragment pointer */
	float32_t INFINITY32f = HUGE_VAL;

	memset(ISap, 0, DFLT_ADSPEC_LEN-sizeof(Object_header));
	Set_Main_Hdr(&ISap->adspec_mh, 0);
	
 	Set_Serv_Hdr(&genp->gen_parm_hdr, GENERAL_INFO,
				sizeof(genparm_parms_t)-sizeof(IS_serv_hdr_t));
	Set_Parm_Hdr(&genp->gen_parm_hopcnt_hdr, IS_WKP_HOP_CNT,
						sizeof(u_int32_t));
	genp->gen_parm_hopcnt = 0;
	Set_Parm_Hdr(&genp->gen_parm_pathbw_hdr, IS_WKP_PATH_BW,
						sizeof(float32_t));
	genp->gen_parm_path_bw = INFINITY32f;
	Set_Parm_Hdr(&genp->gen_parm_minlat_hdr, IS_WKP_MIN_LATENCY,
						sizeof(float32_t));
	genp->gen_parm_min_latency = 0;
	Set_Parm_Hdr(&genp->gen_parm_compmtu_hdr, IS_WKP_COMPOSED_MTU,
						sizeof(float32_t));
	genp->gen_parm_composed_MTU = 65535;
	shp = (IS_serv_hdr_t *)(genp+1);

	Set_Serv_Hdr(shp, GUARANTEED_SERV, 0);
	Set_Break_Bit(shp);	/* We do not support GUARANTEED */
	shp++;
	Set_Serv_Hdr(shp, CONTROLLED_LOAD_SERV, 0);
	Set_Break_Bit(shp);	/* We do not support CONTROLLED LOAD */
	shp++;
	ISap->adspec_mh.ismh_len32b = wordsof((char *)shp - (char *)genp);
	return(1);
}


static char 	spbuff[80];

char *
fmt_flowspec(FLOWSPEC *specp)
	{
	int		 ctype;

	if (!specp)
		return("[ ]");
	if ((ctype = Obj_CType(specp)) != ctype_FLOWSPEC_Intserv0) {
		sprintf(spbuff, "FLOWSPEC C-TYPE ??: %d\n", ctype);
		return(spbuff);
	}
	if (Intserv_Obj_size(&specp->flow_body) != Obj_Length(specp))
		return("Spec length?\n");
	return(rapi_fmt_specbody3(&specp->flow_body));
}



char *
fmt_tspec(SENDER_TSPEC *stsp)
	{
	int		 ctype;

	if (!stsp)
		return("[ ]");
	if ((ctype = Obj_CType(stsp)) != ctype_SENDER_TSPEC_CTYPE) {
		sprintf(spbuff, "Tspec C-Type ??: %d\n", ctype);
		return(spbuff);
	}
	if (Intserv_Obj_size(&stsp->stspec_body) != Obj_Length(stsp))
		return("Tspec length?\n");
	return(rapi_fmt_tspecbody3(&stsp->stspec_body));
}

/*
 *	Format ADSPEC [Shares internal buffer with fmt_tspec, fmt_flowspec]
 */
char *
fmt_adspec(ADSPEC *adsp)
	{
	int ctype;

	if (!adsp)
		return("Adspec()");
	if ((ctype = Obj_CType(adsp)) != ctype_ADSPEC_INTSERV) {
		sprintf(spbuff, "Tspec C-Type ??: %d\n", ctype);
		return(spbuff);
	}
	if (Intserv_Obj_size(&adsp->adspec_body) != Obj_Length(adsp))
		return("Adspec len??\n");
	return(rapi_fmt_adspecbody3(&adsp->adspec_body));
}


/*
 *  ntoh_flowspec(): Converts a flowspec in place, from network byte
 *	order into host byte order.
 */
void
ntoh_flowspec(FLOWSPEC *specp)
	{
	IS_serv_hdr_t	*sp;