rstat.c

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

void
print_status()
	{
	sess_element_t *sp, *tp;

	for (sp = selm_head.selm_next; sp; sp = sp->selm_next) {
		if (sp->selm_type == TYPE_RSVP_VRESV) {
			print_sess_Resv((ResvInfo_t *)sess_data(sp));
			tp = sp->selm_next;
			if (tp == NULL || tp->selm_type != TYPE_RSVP_VPATH ||
				!Sess_EQ(&sp->selm_session, &tp->selm_session)
				) {
				printf("!? missing path state\n");
				return;
			}
			sp = tp;
			if (Show_Path)
				print_sess_Path((PathInfo_t *)sess_data(sp));
		}
		else if (((PathInfo_t *)sess_data(sp))->nSender) {
			/* No Resv data for this session,
			 * but there is path data.
			 */
			printf(" (no resv) %-22s\n",
				fmt_session(&((PathInfo_t *)
					sess_data(sp))->path_session));
			if (Show_Path)
				print_sess_Path((PathInfo_t *)sess_data(sp));
		}
		printf("\n");
	}		

}


/*
 *  Display Path State from vector of n per-session data items
 */
void
print_sess_Path(sesp)
	PathInfo_t *sesp;
	{
	PathSender_t *Pp;
	int	j;

	Pp = &sesp->path_sender;
	for (j=0; j < sesp->nSender; j++) {
		FILTER_SPEC *fip =
				(FILTER_SPEC *)Next_Object(&Pp->pathS_policy);
		FLOWSPEC *fsp =  (FLOWSPEC *)  Next_Object(fip);

		printf("-- Path -- %-22s  %-22s  %-13s\n",
			fmt_session(&sesp->path_session),
			filtsptoa(fip),
			From_addr(Pp->pathS_phop, 13));

		if ((Show_Flowspecs) && NotNULL(fsp))
			printf(SpecFormat, "", ftspectoa(fsp));
		Pp = (PathSender_t *) Next_Object(fsp);
	}
}

                                             
/*
 *  Display reservation state from vector of (session, style) pair.
 */
void
print_sess_Resv(sesp)
	ResvInfo_t *sesp;
	{
	char		*rp, *bp;
	int		i, j, k;
	FILTER_SPEC	*fip;
	FLOWSPEC	*fsp;
	int		style = sesp->resv_style;
	POLICY_DATA	*ap = &sesp->resv_policy;
	int		N = sesp->nStruct;
	char		**vec = (char **) malloc(sizeof(char *) * N);

	if (N == 0)
		return; 
	bp = rp = (char *) Next_Object(ap);

	for (i = 0; i < N; i++) {
	    vec[i] = rp;
	    switch (style) {
		case RAPI_RSTYLE_WILDCARD:
			rp = (char *) Next_Object(Next_Object(
							&WFp(rp)->WF_flowspec));
			break;
	
		case RAPI_RSTYLE_FIXED:
			rp = (char *) Next_Object(Next_Object(
							&FFp(rp)->FF_flowspec));
			break;

		case RAPI_RSTYLE_SE:
			rp = (char *) Next_Object(&SEp(rp)->SE_flowspec);
			for (k = 0; k < ((ResvSE_t *)rp)->nSE_filts; k++)
				rp = (char *) Next_Object(rp);
			break;
				
		default:
			break;
		}
	}
	switch (style) {
		case RAPI_RSTYLE_WILDCARD:
			sort_ifaces(vec, N,
				0 /* offsetof(ResvWF_t, WF_if) */ );
			break;

		case RAPI_RSTYLE_FIXED:
			sort_ifaces(vec, N,
				0 /* offsetof(ResvFF_t, FF_if) */ );
			break;
	
		case RAPI_RSTYLE_SE:
			sort_ifaces(vec, N,
				0 /* offsetof(ResvSE_t, SE_if) */ );
 			break;
	}

	for (j = 0; j < N; j++) {
		rp = vec[j];
		switch (style) {

		case RAPI_RSTYLE_WILDCARD:
			fsp = &WFp(rp)->WF_flowspec;
			fip = (FILTER_SPEC *) Next_Object(fsp);
				
			printf("%-5s  WF  %-22s  %-22s  %-13s\n",
				Iface_name(WFp(rp)->WF_if),
				fmt_session(&sesp->resv_session),
				filtsptoa(fip),
				From_addr(WFp(rp)->WF_nexthop, 13));
			if ((Show_Flowspecs) && NotNULL(fsp))
				printf(SpecFormat, "", fspectoa(fsp));
			break;

		case RAPI_RSTYLE_FIXED:
			fsp = &FFp(rp)->FF_flowspec;
			fip = (FILTER_SPEC *) Next_Object(fsp);
			if (j == 0 ||  strcmp(FFp(rp)->FF_if,
					FFp(vec[j-1])->FF_if))
				printf("%-5s  FF  %-22s  %-22s  %-13s\n",
					Iface_name(FFp(rp)->FF_if),
					fmt_session(&sesp->resv_session),
					filtsptoa(fip),
					From_addr(FFp(rp)->FF_nexthop, 13));

			else
				printf("%33s  %-22s\n",
						"", filtsptoa(fip));
			if ((Show_Flowspecs) && NotNULL(fsp))
				printf(SpecFormat, "", fspectoa(fsp));
			break;

		case RAPI_RSTYLE_SE:
				

		default:
			break;
		}
	}
}

void
print_header()
	{
	if (Printed_header)
		return;
	Printed_header = 1;

	if (Node_name[0] != '\0')
		printf("RSVP status on node: %s\n", From_name);
	printf(Heading);
/*** seems to look better without this...
	if (Show_Flowspecs)
		printf(SpecFormat, "", "[Flowspec/Tspec]");
	else
****/
		printf("\n");
}

char *
fmt_session(sadrp)
	SESSION_ipv4 *sadrp;
	{
	static char sess_buff[32];
 
	sprintf(sess_buff, "%.15s/%d",
		ip_convert(sadrp->sess_destaddr),
		sadrp->sess_destport);
	return(sess_buff);
}

/*
 * Convert RSVPInfo_t datastructure from network to local format
 * 	Return 0 success, -1 fail
 */
int
ntoh_Path(PathInfo_t *pp)
	{
#if BYTE_ORDER == LITTLE_ENDIAN
	int j;
	PathSender_t *sp;
	Object_header *p;

	if (ntoh_session_ipv4(&pp->path_session))
		return -1;
	NTOH32(pp->path_R);
	NTOH32(pp->nSender);

	sp = &pp->path_sender;
	for (j = 0; j < pp->nSender; j++) {
		/* pathS_phop stays in network format.. */
		/* NTOH32(sp->pathS_routes); */
		NTOH32(sp->pathS_ttd);
		p = (Object_header *)&sp->pathS_policy;
		if (ntoh_policydata((POLICY_DATA *) p))
		    return -1;
		p = Next_Object(p);
		if (ntoh_filterspec((FILTER_SPEC *) p))
		    return -1;
		p = Next_Object(p);
		NTOH16(Obj_Length(p));
		ntoh_tspec((SENDER_TSPEC *) p);
		p = Next_Object(p);
		sp = (PathSender_t *) p;
	}
#endif /* LITTLE_ENDIAN */
	return 0;
}

	
int
ntoh_Resv(ResvInfo_t *rp)
	{
#if BYTE_ORDER == LITTLE_ENDIAN
	int i, j;
	Object_header *p;

	NTOH32(rp->resv_style);
	NTOH32(rp->resv_R);
	NTOH32(rp->nStruct);
	if (ntoh_session_ipv4(&rp->resv_session))
	    return -1;
	if (ntoh_policydata(&rp->resv_policy))
	    return -1;

	switch (rp->resv_style) {
	case RAPI_RSTYLE_WILDCARD: {
	    ResvWF_t *sp = (ResvWF_t *) Next_Object(&rp->resv_policy);

	    for (i = 0; i < rp->nStruct; i++) {
		NTOH32(sp->WF_ttd);
		NTOH16(Obj_Length(&sp->WF_flowspec));
		ntoh_flowspec(&sp->WF_flowspec);
		p = Next_Object(&sp->WF_flowspec);
		if (ntoh_filterspec((FILTER_SPEC *) p))
		    return -1;
		sp = (ResvWF_t *) Next_Object(p);
	    }
	    return 0;
	}

	case RAPI_RSTYLE_FIXED: {
	    ResvFF_t *sp = (ResvFF_t *) Next_Object(&rp->resv_policy);

	    for (i = 0; i < rp->nStruct; i++) {
		NTOH32(sp->FF_ttd);
		/* nexthop stays in network format for printer */
		NTOH16(Obj_Length(&sp->FF_flowspec));
	    	ntoh_flowspec(&sp->FF_flowspec);
		p = Next_Object(&sp->FF_flowspec);
		if (ntoh_filterspec((FILTER_SPEC *) p))
		    return -1;
		sp = (ResvFF_t *) Next_Object(p);
	    }
	    return 0;
	}

	case RAPI_RSTYLE_SE: {
	    ResvSE_t *sp = (ResvSE_t *) Next_Object(&rp->resv_policy);

	    for (i = 0; i < rp->nStruct; i++) {
		NTOH32(sp->SE_ttd);
		NTOH16(sp->nSE_filts);
		NTOH16(Obj_Length(&sp->SE_flowspec));
	    	ntoh_flowspec(&sp->SE_flowspec);
		p = Next_Object(&sp->SE_flowspec);
		for (j = 0; j < sp->nSE_filts; j++) {
		    if (ntoh_filterspec((FILTER_SPEC *) p))
			return -1;
		    p = Next_Object(p);
		}
		sp = (ResvSE_t *) p;
	    }
	    return 0;
	}

	default:
	    /* Unknown STYLE */
	    fprintf(stderr, "Unknown RSVPInfo reservation style... (%d)\n",
		    rp->resv_style);
	    return -1;
	} /* resv_style */
#endif /* LITTLE_ENDIAN */
	return 0;
}

int
ntoh_session_ipv4(SESSION_ipv4 *p)
{
    /* session address stays in network format */
    NTOH16(p->sess_destport);
    return 0;
}

int
ntoh_policydata(POLICY_DATA *p)
{
    NTOH16(Obj_Length(&p->policy_d_header));
    return 0;
}

int
ntoh_filterspec(FILTER_SPEC *p)
{
    NTOH16(Obj_Length(&p->filt_header));
    /* address, port stay in network format */
    return 0;
}


char *
filtsptoa(FILTER_SPEC *filtp)
	{
	static char tmp[256];
	char	*cp, *P, *Q;
	int	n;

	if (Obj_Class(filtp) == class_NULL)
		return  "*/*[*]";
	cp = fmt_filtspec(filtp);
	if ((n = strlen(cp)) <= 22)
		return cp;
	else if (n > 255)
		return "!!too long";

	strcpy(tmp, cp);
	while (strlen(tmp) > 22) {
		P = strrchr(tmp, '/');
		Q = strrchr(tmp, '.');
		strcpy(Q, P);
	}
	return tmp;
}

/*   Prune trailing segments from host name, in order to fit into
 *	specified width.  Modifies input string in place, returns
 *	its address.
 */
char *
prune_hostname(char *cp, int wid)
	{
	char	*p;

	if (isdigit(*cp))
		return(cp);	/* Can't prune dotted-decimal */
	while (strlen(cp) > wid) {
		if ((p = strrchr(cp, '.')))
			*p = '\0';
		else
			cp[wid] = '\0';
	}		
	return(cp);
}

/*	Sort list of Resv entries into lexicographic order by interface names
 */
void
sort_ifaces(char **vec, int N, int offset) {
	int i, j;
	char *temp;

	for (i = 0; i < N; i++)
		for (j = i+1; j < N; j++) {
			if (strcmp(vec[j]+offset, vec[i]+offset) > 0) {
				temp = vec[i];
				vec[i] = vec[j];
				vec[j] = temp;
			}
		}
}


void
hexf(fp,  p, len)                
    FILE *fp;
    char *p ;
    register int len ;
    {
    char *cp = p;
    int   wd ;
    u_long  temp ;
    
    while (len > 0) {
        fprintf(fp, "x%2.2x: ", cp-p);
        for (wd = 0; wd<4; wd++)  {
            memcpy((char *) &temp, cp, sizeof(u_long) );
            if (len > 4) {
                fprintf(fp, " x%8.8lx", temp) ;
                cp += sizeof(long);
                len -= sizeof(long);
                }
            else {
                fprintf(fp, " x%*.*lx", 2*len, 2*len, temp);
		len = 0;
                break ;
            }
        }
        fprintf(fp, "\n") ;
    }
}

u_long resolve_name(name)
char *name;
{
	net_addr addr;

	if (!net_addr_ascii(&addr,name))
		return(INADDR_ANY);
	if (NET_GET_TYPE(&addr) != NET_ADDR_IPv4)
		return(INADDR_ANY);
	return(NET_GET_ADDR_IPv4(&addr).s_addr);
}