rsvp_err.c

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

	bmp = (bitmap *) malloc(n);
	if (bmp == NULL)
		return(NULL);
	memset((char *) bmp, 0, n); 
	
	for (sp = destp->d_PSB_list; sp != NULL; sp = sp->ps_next) {
		/* There may be more than one sender per sender IP address;
		 *	use only the last.
		 */
		if ((sp->ps_next) &&
				filterspec_eq(sp->ps_next->ps_templ,
					sp->ps_templ))
			continue;
		/*
		 * If path sender matches s[i] in SCOPE list, record bitmap
		 *	in vector[i].
		 */
		i = filterspec_in_scope(sp->ps_templ, scope_inp);
		if (i < 0)
			continue;
		bmp[i] = sp->ps_outif_list;
	}
	return(bmp);
}


/*
 *   Initiate a Path_Err message, resulting from packet *pp_in.  Send
 *   it point-to-point to previous hop.
 *
 */

void 
rsvp_path_err(
	int		in_if,
	int		e_code,
	int		e_value,
	struct packet	*pp_in)
	{
	packet_area	data;
	struct packet	*pkt;

	pkt = new_packet_area(&data);

	/* If Path message was UDP-encapsulated, send PathErr with UDP
	 * encapsulation.
	 */
	pkt->pkt_flags = PKTFLG_USE_UDP & pp_in->pkt_flags;

	/* Copy appropriate entries from fixed part of map, plus index-th
	 * sender descriptor. Also construct ERROR_SPEC object in new map.
	 */
	pkt->pkt_map->rsvp_session = pp_in->pkt_map->rsvp_session;
	pkt->pkt_map->rsvp_integrity = pp_in->pkt_map->rsvp_integrity;
	pkt->pkt_map->rsvp_flags = pp_in->pkt_map->rsvp_flags;
	pkt->pkt_map->rsvp_msgtype = RSVP_PATH_ERR;
	memcpy((char *) SenderDesc_of(pkt), 
			(char *) SenderDesc_of(pp_in), 
			sizeof(SenderDesc));
	pkt->rsvp_nflwd = 1;

	pkt->pkt_map->rsvp_errspec = errorspec_create(&Get_local_interface,
		e_code,e_value,0);

	log_event(LOGEV_iserr, "PATH", pkt->pkt_map->rsvp_session,
					"!c=%d val=%d\n", e_code, e_value);

	if (IsHopAPI(pp_in->rsvp_phop)) {
		/*
		 *  Local reservation; return the error to the API
		 */
		api_PATH_ERR_upcall(pkt);
	} else {
		send_pkt_out_if(in_if, pp_in->pkt_map->rsvp_hop, pkt);
	}
}

/*
 *  rsvp_resv_err():
 *	Initiate Resv_Err message for Resv message *err_pkt, filter spec
 *	*filtssp.  Send Resv_Err point-to-point to next hop, or
 *	if local reservation, deliver to API.
 */
void 
rsvp_resv_err(
	int		 e_code,
	int		 e_value,
	int		 e_flags,
	FiltSpecStar	*e_filtssp,  /* -1 => all flow descriptors; 0 => none*/
	Resv_pkt	*err_pkt)
	{
	int		 k;
	style_t		 style = Style(err_pkt);
	FiltSpecStar	 filtss, *filtssp;

	if ((int)e_filtssp != -1) {
		rsvp_resv_err1(e_code, e_value, e_flags, e_filtssp, err_pkt);
		return;
	}
	/*
	 *	-1 => For all flow descriptors in packet
	 */
	filtss.fst_count = 1;
	switch (style) {
	    case STYLE_WF:
	    case STYLE_FF:
		/*	Style FF: execute independently for each flow
		 *	descriptor in the message.
		 */
		for (k=0; k < err_pkt->rsvp_nflwd; k++) {
		    filtss.fst_Filtp(0) = filter_of(FlowDesc_of(err_pkt, k));
		    rsvp_resv_err1(e_code, e_value, e_flags, &filtss, err_pkt);
		}
		break;

	    case STYLE_SE:
		/* 	SE => one flow descriptor but multiple filter specs.
		 *	Obtain storage and construct FILTER_SPEC*, i.e., 
		 *	list of FILTER_SPECs, dynamically.
		 */
		filtssp = Get_FiltSpecStar(err_pkt->rsvp_nflwd);
		if (!filtssp)
	 		{
			Log_Mem_Full("ResvErr1");
			return;
		}
		map2FiltStar(err_pkt, filtssp);
		rsvp_resv_err1(e_code, e_value, e_flags, filtssp, err_pkt);
		free(filtssp);			
		break;

	    default:
		break;
	}
}
	

/*
 *  rsvp_resv_err1():
 *	Inner routine of rsvp_resv_err()
 */
void 
rsvp_resv_err1(
	int		 e_code,
	int		 e_value,
	int		 e_flags,
	FiltSpecStar	*filtssp,
	Resv_pkt	*err_pkt)
	{
	packet_area	 data;		/* Packet buffer, map, etc */
	struct packet 	*pkt;
	packet_map	*mapp;
	int		OIf = hop_lih(err_pkt->rsvp_phop);
	static RSVP_HOP hop;

	pkt = new_packet_area(&data);
	mapp = pkt->pkt_map;
	mapp->rsvp_msgtype = RSVP_RESV_ERR;

	mapp->rsvp_session = err_pkt->pkt_map->rsvp_session;
	/*** mapp->rsvp_spolicy = ?? */
	mapp->rsvp_hop = &hop;
	switch(Obj_CType(err_pkt->pkt_map->rsvp_session)) {
		case ctype_SESSION_ipv4:
		case ctype_SESSION_ipv4GPI:
			Init_Object(&hop,RSVP_HOP,RSVP_HOP_ipv4);
			break;
#ifdef	USE_IPV6
		case ctype_SESSION_ipv6:
		case ctype_SESSION_ipv6GPI:
			Init_Object(&hop,RSVP_HOP,RSVP_HOP_ipv6);
			break;
#endif	/* USE_IPV6 */
		default:
			Init_Object(&hop,NULL,NULL);
			break;
	}

	mapp->rsvp_style = err_pkt->pkt_map->rsvp_style;
	if (Style_is_Wildcard(Style(err_pkt)))
		pkt->rsvp_scope = err_pkt->rsvp_scope;

	Filtstar2map(filtssp, pkt);
	spec_of(FlowDesc_of(pkt, 0)) = spec_of(FlowDesc_of(err_pkt, 0));

	mapp->rsvp_errspec = errorspec_create(&Get_local_interface,
		e_code,e_value,e_flags);

	log_event(LOGEV_iserr, "RESV", mapp->rsvp_session,
					"!c=%d val=%d\n", e_code, e_value);

	if (IsHopAPI(err_pkt->rsvp_nhop))
		api_RESV_ERR_upcall(pkt);
	else {
		hop_if_assign(pkt->rsvp_phop,&GET_IF(OIf),OIf);
		send_pkt_out_if(OIf, err_pkt->pkt_map->rsvp_hop, pkt);
	}
}

/*
 *  rsvp_RSB_err():
 *	Initiate Resv_Err message for given RSB.
 */
void 
rsvp_RSB_err(
	Session		*destp,
	RSB		*rp,
	int		 e_code,
	int		 e_value)
	{
	packet_area	 data;		/* Packet buffer, map, etc */
	struct packet 	*pkt;
	packet_map	*mapp;
	static RSVP_HOP hop;
	extern STYLE	 Style_Obj;

	if (!rp)
		return;
	pkt = new_packet_area(&data);
	mapp = pkt->pkt_map;
	mapp->rsvp_msgtype = RSVP_RESV_ERR;

	mapp->rsvp_session = destp->d_session;
	/*** mapp->rsvp_spolicy = ?? */
	mapp->rsvp_hop = &hop;
	switch(Obj_CType(destp->d_session)) {
		case ctype_SESSION_ipv4:
		case ctype_SESSION_ipv4GPI:
			Init_Object(&hop,RSVP_HOP,RSVP_HOP_ipv4);
			break;
#ifdef	USE_IPV6
		case ctype_SESSION_ipv6:
		case ctype_SESSION_ipv6GPI:
			Init_Object(&hop,RSVP_HOP,RSVP_HOP_ipv6);
			break;
#endif	/* USE_IPV6 */
		default:
			Init_Object(&hop,NULL,NULL);
			break;
	}

	mapp->rsvp_style = &Style_Obj;
	Init_Object(&Style_Obj,STYLE,STYLE_CTYPE);
	Style_of(pkt)->style_word = rp->rs_style;
	pkt->rsvp_scope = rp->rs_scope;

	Filtstar2map(rp->rs_filtstar, pkt);
	spec_of(FlowDesc_of(pkt, 0)) = rp->rs_spec;

	mapp->rsvp_errspec = errorspec_create(&Get_local_interface,
		e_code,e_value,0);

	log_event(LOGEV_iserr, "RESV", mapp->rsvp_session,
					"!c=%d val=%d\n", e_code, e_value);

	if (IsHopAPI(&rp->rs_nhop))
		api_RESV_ERR_upcall(pkt);
	else {
		hop_if_assign(pkt->rsvp_phop,&GET_IF(rp->rs_OIf),rp->rs_OIf);
		send_pkt_out_if(rp->rs_OIf, &rp->rs_rsvp_nhop, pkt);
	}
}


void
Filtstar2map(FiltSpecStar *filtssp, struct packet *pkt)
	{
	int i;

	if (!filtssp) {
		FlowDesc *flwdp = FlowDesc_of(pkt, 0);
		flwdp->rsvp_specp = NULL;
		flwdp->rsvp_filtp = NULL;
		return;
	}
	pkt->rsvp_nflwd = filtssp->fst_count;
	for (i = 0; i < pkt->rsvp_nflwd; i++) {
		FlowDesc *flwdp = FlowDesc_of(pkt, i);

		flwdp->rsvp_filtp = filtssp->fst_p[i].fst_filtp;
		flwdp->rsvp_specp = NULL;
	}
}


/*	Special blockade processing when receive ResvErr message.
 *	1. Find/Create one (or more?) Blockade State Blocks (BSBs),
 *	   in style-dependent manner.
 *	2. For each BSB, set (or replace) its FLOWSPEC Qb with
 *	   FLOWSPEC from the message, and set/reset its timer Tb.
 */
PSB *
resv_err_blockade(Session *destp, struct packet *pkt)
	{
	PSB		*sp, *BSBp = NULL;
	FILTER_SPEC	*filtp;
	int		i;

	switch (Style(pkt)) {

	    case STYLE_WF:
		/*	For WF (wildcard) style, there will be one BSB
		 *	per (session, PHOP) pair.
		 */
		for (sp = destp->d_PSB_list; sp != NULL; sp = sp->ps_next) {
			if (hop_addr_eq(&sp->ps_phop,pkt->rsvp_phop)) {
				break;
			}
		}
		if (sp)
			update_BSB(destp, BSBp = sp, 
						spec_of(FlowDesc_of(pkt,0)));
		break;

	    case STYLE_FF:
	    case STYLE_SE:
		/*	For FF style, there will be one BSB per (session,
		 *	filter_spec) pair.  Note that an FF style ResvErr
		 *	message carries only one flow descriptor.
		 *
		 *	For SE style, there will be one BSB per (session,
		 *	filter_spec), for each filter_spec in the flow
		 *	descriptor.
		 */
		for (i = 0; i < pkt->rsvp_nflwd; i++) {
			filtp = filter_of(FlowDesc_of(pkt,i));
			for (sp = destp->d_PSB_list; sp; sp = sp->ps_next) {
				if (match_filter(filtp, sp->ps_templ)) {
					break;
				}
			}
			if (sp) {
			    BSBp = sp;
			    update_BSB(destp, BSBp, spec_of(FlowDesc_of(pkt,0)));
			}
		}
		break;

	}
	return (BSBp);
}

void
update_BSB(Session *destp, PSB *BSBp, FLOWSPEC *specp)
	{
	if (BSBp) {
		BSBp->ps_BSB_Qb = copy_spec(specp);
		BSBp->ps_BSB_Tb = time_now + Kb_FACTOR * destp->d_Rtimor; 
	}
}

/*
 *	Send an RSVP ResvConf message, containing specified CONFIRM
 *	object (which is freed).
 */
void
send_confirm(
	Session 	*destp,
	RSB		*rp)
	{
	packet_area	 data;		/* Packet buffer, map, etc */
	struct packet 	*pkt;
	packet_map	*mapp;
	extern STYLE	 Style_Obj;

	if (!rp)
		return;
	pkt = new_packet_area(&data);
	mapp = pkt->pkt_map;
	mapp->rsvp_msgtype = RSVP_CONFIRM;

	mapp->rsvp_session = destp->d_session;
	mapp->rsvp_style = &Style_Obj;
	Init_Object(&Style_Obj,STYLE,STYLE_CTYPE);
	Style_of(pkt)->style_word = rp->rs_style;

	mapp->rsvp_confirm = rp->rs_confirm;
	rp->rs_confirm = NULL;

	Filtstar2map(rp->rs_filtstar, pkt);
	spec_of(FlowDesc_of(pkt, 0)) = rp->rs_spec;

	
	mapp->rsvp_errspec = errorspec_create(&Get_local_interface,
		RSVP_Err_NONE,RSVP_Erv_Nonev,0);

	log_event(LOGEV_iserr, "CONF", mapp->rsvp_session,
					"!c=%d val=%d\n", 0, 0);

	if (IsHopAPI(&rp->rs_nhop))
		api_RESV_ERR_upcall(pkt);
	else
		send_pkt_out_if(rp->rs_OIf, &rp->rs_rsvp_nhop, pkt);
	free(mapp->rsvp_confirm);
}