rsvp_api.c

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

	API_FilterSpec	*api_filtp;
	API_TSpec	*api_tspecp;
	API_Flowspec	*api_specp;
	char		 buff1[80], buff2[80];
	int		 i;
	char		*flgstr;
	net_addr	dest;

	if (len==0 || req->rq_type == API_CLOSE) {
		log_api_event(LOGEV_API_close, "",
			&recp->api_dest, recp->api_protid,
			"<API pid=%d Asid=%d\n", 
			recp->api_pid, recp->api_a_sid);
		return;
	}
		

	net_addr_assign_api_addr(&dest,&req->rq_dest,1);
	switch (req->rq_type) {

	    case API2_REGISTER:
		flgstr = cnv_flags("SRCIG??L", req->rq_flags);
		/*  Flags:
		 *	S: Sender
		 *	R: Receiver
		 *	C: Confirmation request on rapi_reserve call
		 *	I: Intserv format for upcalls
		 *	G: GPI format
		 */
		log_api_event(LOGEV_API_regi, flgstr,
			&dest, req->rq_protid,
			"<API pid=%d Asid=%d\n", 
			req->rq_pid,  req->rq_a_sid);
		if (IsDebug(DEBUG_EVENTS)&& req->rq_nflwd) {
			api_filtp = (API_FilterSpec *) 
						After_APIObj(req->rq_policy);
			api_tspecp = (API_TSpec *) After_APIObj(api_filtp);
                       	rapi_fmt_filtspec(api_filtp, buff1, 80);
			rapi_fmt_tspec(api_tspecp, buff2, 80);
             		log(LOG_DEBUG, 0, "   Register sender: %s  %s\n",
					buff1, buff2);
		}
		break;

	case API2_RESV:
		log_api_event(LOGEV_API_resv, style_names[req->rq_style],
			 &dest, req->rq_protid,
			"<API pid=%d Asid=%d\n", 
			req->rq_pid, req->rq_a_sid);
		if (IsDebug(DEBUG_EVENTS)) {
			log(LOG_DEBUG, 0, "  Reserve  StyleID= %d\n",
				 req->rq_style);
			api_filtp = (API_FilterSpec *) 
						After_APIObj(req->rq_policy);
			for (i = 0; i < req->rq_nflwd; i++) {
				api_specp = (API_Flowspec *) 
						After_APIObj(api_filtp);
                      		rapi_fmt_filtspec(api_filtp, buff1, 80);
				buff2[0] = '\0';
				if (api_specp->form != RAPI_EMPTY_OTYPE)
				    rapi_fmt_flowspec(api_specp, buff2, 80);
				api_filtp = (API_FilterSpec *) 
						After_APIObj(api_specp);
             			log(LOG_DEBUG, 0, "    %s  %s\n", buff1, buff2);
			}
		}
		break;

	default:
		break;
	}
}

/*      Define a set of object reformatting routines:
 *
 *	    Move_XXXX_api2d: copy object of type XXXX, repackaging it
 *		from the [r]api framing of daemon's object framing.
 *
 *	    Move_XXXX_d2api: copy object of type XXXX, repackaging it
 *		from the daemon object framing to [r]api framing.
 */
int
Move_spec_api2d(rapi_flowspec_t * api_specp, FLOWSPEC * d_specp)
	{
	int size;

	/* XXX should validity-check type and length
	 */
	Obj_Length(d_specp) = size = size_api2d(api_specp->len);
	memcpy(Obj_data(d_specp), RAPIObj_data(api_specp),
						size - sizeof(Object_header));
	return(0);
}

/*	In rsvpd -> API direction, send flowspec, Tspec, or Adspec in
 *	int-serv format but with RAPI framing.  This common routine
 *	does the necessary reframing.
 */
void
Reframe_d2api(Object_header *d_specp, rapi_hdr_t * api_specp, int type)
	{
	int size;

	if (!d_specp) {
		api_specp->len = sizeof(rapi_hdr_t);
		api_specp->form = RAPI_EMPTY_OTYPE;  /* Empty entry */
	}
	else {
		api_specp->len = size = size_d2api(Obj_Length(d_specp));
		api_specp->form = type;
		memcpy(RAPIObj_data(api_specp), Obj_data(d_specp),
						size - sizeof(rapi_hdr_t));
	}
}

char *
Move_spec_d2api(FLOWSPEC * d_specp, rapi_flowspec_t * api_specp)
	{
	Reframe_d2api((Object_header *) d_specp,
		      (rapi_hdr_t *) api_specp, RAPI_FLOWSTYPE_Intserv);
	return(After_APIObj(api_specp));
}

int
Move_tspec_api2d(rapi_tspec_t * api_tspecp, SENDER_TSPEC * d_tspecp)
	{
		/* XXX should validity-check type and length */
	Move_spec_api2d((rapi_flowspec_t *)api_tspecp, (FLOWSPEC *)d_tspecp);
	return(0);
}

char *
Move_tspec_d2api(SENDER_TSPEC * d_tspecp, rapi_tspec_t * api_tspecp)
	{
	Reframe_d2api((Object_header *) d_tspecp,
		      (rapi_hdr_t *) api_tspecp, RAPI_TSPECTYPE_Intserv);
	return(After_APIObj(api_tspecp));
}

int
Move_adspec_api2d(rapi_adspec_t * api_adspecp, ADSPEC * d_adspecp)
	{
		/* XXX should validity-check type and length */
	Move_spec_api2d((rapi_flowspec_t *)api_adspecp, (FLOWSPEC *)d_adspecp);
	return(0);
}

char *
Move_adspec_d2api(ADSPEC * d_adspecp, rapi_adspec_t * api_adspecp)
	{
	Reframe_d2api((Object_header *) d_adspecp,
		      (rapi_hdr_t *) api_adspecp, RAPI_ADSTYPE_Intserv);
	return(After_APIObj(api_adspecp));
}

int
Move_filter_api2d(rapi_filter_t * api_filtp, FILTER_SPEC * d_filtp,int filt)
	{
	switch (api_filtp->form) {

	    case RAPI_FILTERFORM_BASE:
		if (filt) {
			Init_Object(d_filtp,FILTER_SPEC,
				FILTER_SPEC_ipv4);
		}
		else {
			Init_Object(d_filtp,SENDER_TEMPLATE,
				SENDER_TEMPLATE_ipv4);
		}
		d_filtp->filt4_srcaddr.s_addr = 
				api_filtp->rapi_filtbase4_addr.s_addr;
		d_filtp->filt4_srcport = api_filtp->rapi_filtbase4_port;
		break;

	    case RAPI_FILTERFORM_GPI:
		if (filt) {
			Init_Object(d_filtp,FILTER_SPEC,
				FILTER_SPEC_ipv4GPI);
		}
		else {
			Init_Object(d_filtp,SENDER_TEMPLATE,
				SENDER_TEMPLATE_ipv4GPI);
		}
		d_filtp->filtgpi4_srcaddr.s_addr = 
					api_filtp->rapi_filtgpi4_addr.s_addr;
		d_filtp->filtgpi4_srcgpi = api_filtp->rapi_filtgpi4_gpi;
		break;
		
#ifdef	USE_IPV6
	    case RAPI_FILTERFORM_BASE6:
		if (filt) {
			Init_Object(d_filtp,FILTER_SPEC,
				FILTER_SPEC_ipv6);
		}
		else {
			Init_Object(d_filtp,SENDER_TEMPLATE,
				SENDER_TEMPLATE_ipv6);
		}
		d_filtp->filt6_srcaddr = api_filtp->rapi_filtbase6_addr;
		d_filtp->filt6_srcport = api_filtp->rapi_filtbase6_port;
		break;

	    case RAPI_FILTERFORM_GPI6:
		if (filt) {
			Init_Object(d_filtp,FILTER_SPEC,
				FILTER_SPEC_ipv6GPI);
		}
		else {
			Init_Object(d_filtp,SENDER_TEMPLATE,
				SENDER_TEMPLATE_ipv6GPI);
		}
		d_filtp->filtgpi6_srcaddr = api_filtp->rapi_filtgpi6_addr;
		d_filtp->filtgpi6_srcgpi = api_filtp->rapi_filtgpi6_gpi;
		break;
#endif	/* USE_IPV6 */

	    default:
		log(LOG_ERR, 0, "API: Bad filterspec type %d\n", 
							api_filtp->form);
		break;
	}
	return(0);
}

int
path_set_laddr(rapi_filter_t * api_filtp)
	{
	net_addr addr;
	switch (api_filtp->form) {

	    case RAPI_FILTERFORM_BASE:
		if (IN_ARE_ADDR_EQUAL(&api_filtp->rapi_filtbase4_addr,
				&inaddr_any))
			api_filtp->rapi_filtbase4_addr =
				NET_GET_ADDR_IPv4(&Get_local_addr);
		NET_SET_ADDR_IPv4(&addr,api_filtp->rapi_filtbase4_addr);
		return map_if_addr(&addr);

	    case RAPI_FILTERFORM_GPI:
		if (IN_ARE_ADDR_EQUAL(&api_filtp->rapi_filtgpi4_addr,
				&inaddr_any))
			api_filtp->rapi_filtgpi4_addr =
				NET_GET_ADDR_IPv4(&Get_local_addr);
		NET_SET_ADDR_IPv4(&addr,api_filtp->rapi_filtgpi4_addr);
		return map_if_addr(&addr);
		
#ifdef	USE_IPV6
	    case RAPI_FILTERFORM_BASE6:
		if (IN6_ARE_ADDR_EQUAL(&api_filtp->rapi_filtbase6_addr,
				&in6addr_any))
			api_filtp->rapi_filtbase6_addr =
				NET_GET_ADDR_IPv6(&Get_local_addr6);
		NET_SET_ADDR_IPv6(&addr,api_filtp->rapi_filtbase6_addr);
		return map_if_addr(&addr);
#endif	/* USE_IPV6 */

	    default:  /* Error noted later */
		break;
	}
	return(-1);
}

char *
Move_filter_d2api(FILTER_SPEC * d_filtp, rapi_filter_t * api_filtp)
	{
	if (!d_filtp) {
		api_filtp->len = sizeof(rapi_hdr_t);
		api_filtp->form = RAPI_EMPTY_OTYPE;  /* Empty entry */
		return (After_APIObj(api_filtp));
	}
	switch (Obj_CType(d_filtp)) {

	    case ctype_FILTER_SPEC_ipv4:
		api_filtp->form = RAPI_FILTERFORM_BASE;
		NET_SOCKADDR_UDP_IPv4( &api_filtp->rapi_filt4,
			d_filtp->filt4_srcaddr,
			d_filtp->filt4_srcport);
		api_filtp->len = sizeof(rapi_hdr_t)+sizeof(rapi_filter_base_t);
		break;

	    case ctype_FILTER_SPEC_ipv4GPI:
		api_filtp->form = RAPI_FILTERFORM_GPI;
		api_filtp->rapi_filtgpi4_addr.s_addr =
			d_filtp->filtgpi4_srcaddr.s_addr;
		api_filtp->rapi_filtgpi4_gpi = d_filtp->filtgpi4_srcgpi;
		api_filtp->len = sizeof(rapi_hdr_t) + sizeof(rapi_filter_gpi_t);
		break;

#ifdef	USE_IPV6
	    case ctype_FILTER_SPEC_ipv6:
		api_filtp->form = RAPI_FILTERFORM_BASE6;
		NET_SOCKADDR_UDP_IPv6( &api_filtp->rapi_filt6,
			d_filtp->filt6_srcaddr,
			d_filtp->filt6_srcport);
		api_filtp->len = sizeof(rapi_hdr_t)+sizeof(rapi_filter_base6_t);
		break;

	    case ctype_FILTER_SPEC_ipv6GPI:
		api_filtp->form = RAPI_FILTERFORM_GPI6;
		api_filtp->rapi_filtgpi6_addr = d_filtp->filtgpi6_srcaddr;
		api_filtp->rapi_filtgpi6_gpi = d_filtp->filtgpi6_srcgpi;
		api_filtp->len = sizeof(rapi_hdr_t)+sizeof(rapi_filter_gpi6_t);
		break;

#endif	/* USE_IPV6 */

	    default:
		/*	Something is wrong with filter spec.  Pass null (but
		 *	not empty) one.  Maybe someone will notice...
		 *	But really: should validity check filter spec before
		 *	reach here!
		 */
		api_filtp->form = RAPI_FILTERFORM_BASE;
		NET_SOCKADDR_UDP_IPv4(&api_filtp->rapi_filt4,
			inaddr_any,hton16(0));
		api_filtp->len = sizeof(rapi_hdr_t)+sizeof(rapi_filter_base_t);
		break;
	}
	return (After_APIObj(api_filtp));
}


/*
 *  ntoh_api_request(): API request from net to host byte order
 *
 */
void
ntoh_api_request(rsvp_req *req, int len) {
#if BYTE_ORDER == LITTLE_ENDIAN
	int i;
	rapi_flowspec_t	*api_specp;
	rapi_filter_t	*api_filtp;

	NTOH32(req->rq_a_sid);
	NTOH32(req->rq_pid);
	NTOH16(req->rq_nflwd);
	NTOH_RAPIhdr(req->rq_policy);
	api_filtp = (API_FilterSpec *) After_APIObj(req->rq_policy);
	for (i = 0; i < req->rq_nflwd; i++) {
		NTOH_RAPIhdr(api_filtp);
		api_specp = (API_Flowspec *) After_APIObj(api_filtp);
		NTOH_RAPIhdr(api_specp);
		ntoh_rapi_flowspec(&api_specp->specbody_IS);
		api_filtp = (API_FilterSpec *) After_APIObj(api_specp);
	}
	if (i == 1 && (char *)api_filtp < (char *)req + len) {
		NTOH_RAPIhdr(api_filtp);
		ntoh_rapi_adspec(&((API_Adspec *)api_filtp)->adspecbody_IS);
	}
#endif /* LITTLE_ENDIAN */
}

/*
 *  hton_api_resp(): API response from host to net byte order
 *
 */
void
hton_api_resp(rsvp_resp *resp, int len) {
#if BYTE_ORDER == LITTLE_ENDIAN
	int i;
	rapi_flowspec_t	*api_specp;
	rapi_filter_t	*api_filtp;
	rapi_adspec_t	*api_adspec, *next_adspec;

	HTON32(resp->resp_a_sid);
	HTON32(resp->resp_style);
	HTON16(resp->resp_errval);
	api_filtp = (API_FilterSpec *) resp->resp_flows;
	for (i = 0; i < resp->resp_nflwd; i++) {
		api_specp = (API_Flowspec *) After_APIObj(api_filtp);
		HTON_RAPIhdr(api_filtp);
		api_filtp = (API_FilterSpec *) After_APIObj(api_specp);
		hton_rapi_flowspec(&api_specp->specbody_IS);
		HTON_RAPIhdr(api_specp);
	}
	if ((char *)api_filtp - (char *) resp < len) {
		/*	There is a list of adspecs too
		 */
		api_adspec = (API_Adspec *) api_filtp;
		for (i = 0; i < resp->resp_nflwd; i++) {
			hton_rapi_adspec(&api_adspec->adspecbody_IS);
			next_adspec = (API_Adspec *) After_APIObj(api_adspec);
			HTON_RAPIhdr(api_adspec);
			api_adspec = next_adspec;
		}
	}			
	HTON16(resp->resp_nflwd);
	resp->resp_flags |= API_NET_BO;
#endif /* LITTLE_ENDIAN */
}

int
net_addr_assign_api_addr(net_addr *addr,const api_addr *x,int udp)
{
	struct in_addr a4;
#ifdef	USE_IPV6
	struct in6_addr a6;
#endif	/* USE_IPV6 */

	switch (ntohs(x->type)) {
		case API_ADDR_TYPE_IPv4:
			memcpy(&a4,x->u.addr_ipv4,sizeof(x->u.addr_ipv4));
			if (udp) {
				NET_SET_ADDR3_UDP_IPv4(addr,a4,x->port);
			}
			else {
				NET_SET_ADDR_IPv4(addr,a4);
			}
			return(TRUE);
#ifdef	USE_IPV6
		case API_ADDR_TYPE_IPv6:
			memcpy(&a6,x->u.addr_ipv6,sizeof(x->u.addr_ipv6));
			if (udp) {
				NET_SET_ADDR3_UDP_IPv6(addr,a6,x->port);
			}
			else {
				NET_SET_ADDR_IPv6(addr,a6);
			}
			return(TRUE);
#endif	/* USE_IPV6 */
		default:
			return(FALSE);
	}
}