rsvpeep.c

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

				(j==0)?"PATH":"\"  ",
				Pp->pathS_in_if,
				ip_convert(Pp->pathS_phop));
			printf("%-22s \t%s\n", filtsptoa(fip), ftspectoa(fsp));
			Pp = (PathSender_t *) Next_Object(fsp);
		}
		sesp = (PathInfo_t *)Pp;
	}
}

#define WFp(rp) ((ResvWF_t *)(rp))
#define FFp(rp) ((ResvFF_t *)(rp))
#define SEp(rp) ((ResvSE_t *)(rp))
                                             
/*
 *  Display reservations state from vector of session data
 */
void
print_Resv(sesp, n)
	ResvInfo_t *sesp;	/* First session */
	int n;			/* Number of sessions */
	{
	char *rp;
	int i, j;
	FILTER_SPEC *filtp;

	if (n == 0) {
		printf("  Resv  (Session gone)\n");
		return;
	}
	for (i= 0; i<n; i++) {
		int		style = sesp->resv_style;
		Authentication	*ap = &sesp->resv_policy;

		if (ADDR_NEQ(&sesp->resv_session, &last_session))
			print_session(&sesp->resv_session, ap);
		last_session = sesp->resv_session;

		rp = (char *) Next_Object(ap);
		for (j=0; j < sesp->nStruct; j++) {
			switch (style) {

			case RAPI_RSTYLE_WILDCARD:
				filtp = (FILTER_SPEC *)
					Next_Object(&WFp(rp)->WF_flowspec);

				printf("   WF   %-9.9s %-16.16s %s %s\n",
					WFp(rp)->WF_if,
					ip_convert(WFp(rp)->WF_nexthop),
					filtsptoa(filtp),
					fspectoa(&WFp(rp)->WF_flowspec));
				rp = (char *) Next_Object(filtp);
				break;

			case RAPI_RSTYLE_FIXED:
				filtp = (FILTER_SPEC *)
					Next_Object(&FFp(rp)->FF_flowspec);

				printf("   FF   %-9.9s %-16.16s %-.22s \t%s\n",
					FFp(rp)->FF_if,
#ifdef BAD_FF_REPORTS
				       	inet_ntoa(FFp(rp)->FF_nexthop),
#else
					ip_convert(FFp(rp)->FF_nexthop),
#endif
					filtsptoa(filtp),
				        fspectoa(&FFp(rp)->FF_flowspec));
				rp = (char *) Next_Object(filtp);
				break;

			case RAPI_RSTYLE_SE:
				filtp = (FILTER_SPEC *)
					Next_Object(&SEp(rp)->SE_flowspec);
				printf("   SE   %-9.9s %-16.16s %-.22s \t%s\n",
					SEp(rp)->SE_if,
					ip_convert(SEp(rp)->SE_nexthop),
					filtsptoa(filtp),
				        fspectoa(&SEp(rp)->SE_flowspec));
				filtp = (FILTER_SPEC *) Next_Object(filtp);
				for (j = 1; j < SEp(rp)->nSE_filts; j++) {
					printf("   SE   %26s %-.22s\n",
							"", filtsptoa(filtp));
					filtp = (FILTER_SPEC *) 
							Next_Object(filtp);
				}
				rp = (char *) filtp;
				break;
				

			default:
				break;
			}
		}
		sesp= (ResvInfo_t *) rp;
	}
}

void
print_session(sadrp, authp)
	SESSION_ipv4 *sadrp;
	POLICY_DATA *authp;
	{
	struct timeval timenow;

	gettimeofday(&timenow,NULL ) ; 
	printf("SESSION (dest) = %s:%d  %.19s.%06ld  Auth= %s\n",
		ip_convert(sadrp->sess_destaddr),
		sadrp->sess_destport,
		ctime(&timenow.tv_sec), timenow.tv_usec,
		"(none)" /* XXXX */
		);
}

int
wrong_name( cp)
	char *cp;
	{
	int i;

	if (Num_names == 0) return(0);
	for (i=0; i<Num_names; i++)
		if (!strcmp(cp, Names[i])) return(0);
        return(1);
}

char *argscan(argcp, argvp)
    int *argcp;
    register char ***argvp;
    {
    register char *cp;
    
    if (*(cp = 2+**argvp)) 
        return(cp);
    else if  (--*argcp > 0)
        return(*++*argvp);
    Usage();
    exit(1);
}
   
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") ;
    }
}

/*
 * Convert RSVPInfo_t datastructure from network to local format
 * return 0 success, -1 fail
 */
int
ntoh_info(RSVPInfo_t *ip)
{
    int i, j;

    NTOH32(ip->type);
    NTOH32(ip->nSession);

    switch(ip->type) {
    case TYPE_RSVP_VPATH: {
	PathInfo_t *pp = &ip->Session_un.pathInfo;
	PathSender_t *sp;
	char *p;

	for (i = 0; i < ip->nSession; i++) {
	    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 = (char *)&sp->pathS_policy;
		if (ntoh_policydata((POLICY_DATA *) p))
		    return -1;
		p = (char *)Next_Object(p);
		if (ntoh_filterspec((FILTER_SPEC *) p))
		    return -1;
		p = (char *)Next_Object(p);
		NTOH16(Obj_Length(p));
		ntoh_tspec((SENDER_TSPEC *) p);
		p = (char *)Next_Object(p);
		sp = (PathSender_t *) p;
	    }
	    pp = (PathInfo_t *)sp;
	}
	return 0;
    }
	
    case TYPE_RSVP_VRESV: {
	ResvInfo_t *rp = &ip->Session_un.resvInfo;
	int i, j;
	char *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);
	    	/* NTOH32(sp->WF_nexthop); */
		NTOH16(Obj_Length(&sp->WF_flowspec));
	    	ntoh_flowspec(&sp->WF_flowspec);
		p = (char *)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 */
	    	/* NTOH32(sp->FF_nexthop); */
		NTOH16(Obj_Length(&sp->FF_flowspec));
	    	ntoh_flowspec(&sp->FF_flowspec);
		p = (char *)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);
	    	/* NTOH32(sp->SE_nexthop); */
		NTOH16(sp->nSE_filts);
		NTOH16(Obj_Length(&sp->SE_flowspec));
	    	ntoh_flowspec(&sp->SE_flowspec);
		p = (char *)Next_Object(&sp->SE_flowspec);
		for (j = 0; j < sp->nSE_filts; j++) {
		    if (ntoh_filterspec((FILTER_SPEC *) p))
			return -1;
		    p = (char *)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 */

    default:
	/* Unknown INFO packet type */
	return 0;
    }
    } /* pkt type */
    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(p->policy_d_header.obj_length);
    return 0;
}

int
ntoh_filterspec(FILTER_SPEC *p)
{
    NTOH16(p->filt_header.obj_length);
    /* XXX how do you know what kind of filter it is? */
    /* address, port stay in network format for fmt_filtspec */
    return 0;
}

/*  Remove any final suffix .<chars> (if any) from the end of a given
 *    string by storing a NUL on top of the dot.  Return a pointer to
 *    the beginning of <chars>, or NULL if there is no suffix.
 */
char *rmsuffix(cp)
    char *cp;
{
        char *tp, *ep;

        tp = ep = cp + strlen(cp) - 1;
        while (*tp != '.' && tp >= cp) tp--;
        if (*tp != '.') return(NULL);
        *tp = '\0';
    return((char *)tp+1);
}

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);
}