rsvp_debug.c

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

/*
 * @(#) $Id: rsvp_debug.c,v 1.1.1.1 2000/05/08 22:51:24 wenqing Exp $
 */

/***************************** rsvp_debug.c ******************************
 *                                                                       *
 *                                                                       *
 * Code to format a trace of events and internal state for debugging,    *
 * and code to log debugging, warning, and informational messages.       *
 *                                                                       *
 *                                                                       *
 *************************************************************************/
/****************************************************************************

            RSVPD -- ReSerVation Protocol Daemon

                USC Information Sciences Institute
                Marina del Rey, California

		Original Version: Shai Herzog, Nov. 1993.
		Current Version:  Steven Berson & Bob Braden, May 1996

  Copyright (c) 1996 by the University of Southern California
  All rights reserved.

  Permission to use, copy, modify, and distribute this software and its
  documentation in source and binary forms for any purpose and without
  fee is hereby granted, provided that both the above copyright notice
  and this permission notice appear in all copies, and that any
  documentation, advertising materials, and other materials related to
  such distribution and use acknowledge that the software was developed
  in part by the University of Southern California, Information
  Sciences Institute.  The name of the University may not be used to
  endorse or promote products derived from this software without
  specific prior written permission.

  THE UNIVERSITY OF SOUTHERN CALIFORNIA makes no representations about
  the suitability of this software for any purpose.  THIS SOFTWARE IS
  PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
  INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

  Other copyrights might apply to parts of this software and are so
  noted when applicable.

********************************************************************/

#include "rsvp_daemon.h"
#ifdef __STDC__
#include <stdarg.h>
#include <stdio.h>
#else
#include <varargs.h>
#endif

/*
 *	External declarations
 */
char	*fmt_tspec(SENDER_TSPEC *);
char	*fmt_filtspec(FILTER_SPEC *);
char	*fmt_flowspec(FLOWSPEC *);
char	*fmt_adspec(ADSPEC *);
void	fmt_object();
char	*strtcpy();
char	*fmt_style(style_t);
char	*cnv_flags(char *, u_char);
char 	*bm_expand();

int	debug_filter;
int	debug_filter_num;
extern net_addr debug_filters[];
extern char *	RSVPstat_msg[];

/*
 *	Forward declarations
 */
void	print_senders(), print_flwds();
void	dump_PSB(PSB *), dump_RSB(RSB *);
void	dump_session_state(Session *);
void	dump_filtstar(FiltSpecStar *, FLOWSPEC *);
void	dump_rsvp_stats();

int 	bmp_equ(bitmap *, bitmap *);
int 	bmp_zero(bitmap *);
void 	bmp_rst(bitmap *);
void 	bmp_set(bitmap *, int);
void 	bmp_clr(bitmap *, int);
int 	bmp_tst(bitmap *, int);
bitmap * bmp_shift(bitmap *, bitmap *, int);
bitmap * bmp_create(u_long, bitmap *);
bitmap * bmp_convert(rsrr_bmp *, bitmap *);

/*
 * Exported variables.
 */
char s1[19];		/* buffers to hold the string representations  */
char s2[19];		/* of IP addresses, to be passed to inet_fmt() */
char s3[19];		/* or inet_fmts().                             */
char s4[19];
char s[2*RSRR_MAX_VIFS_V2];  /* char buff for bm_expand() */

char   *r_type[] = {"RSVP_Unknown", "PATH", "RESV", "PATH_ERR",
				 "RESV_ERR", "PTEAR", "RTEAR","CONFIRM",
                                 "", "DREQ", "DREP"};

/*
 * dump_ds(): This function is called to log and possibly multicast the
 *	internal state.
 */
void
dump_ds(int force) {
	Session	*dst;
	static int last_print = 0;
	int	i;

	/*
	 * Don't print state too often, wait at least DUMP_DS_TIMO, unless a
	 * force option is specified.
	 */
	if (!force && (abs((int) (time_now - last_print)) < DUMP_DS_TIMO))
		return;

	/* If flag set, multicast the state to remote display programs
	 */
	if (m_debug & DEBUG_MCAST_STATE) {
		mcast_rsvp_state();
		last_print = time_now;
	}

	/* If state dump flag bit not set, exit now.
	 */
	if (!IsDebug(DEBUG_DS_DUMP))
		return;

	last_print = time_now;
	log(LOG_DEBUG, 0,
		"\n%12s >>>>>>>>>>  Internal STATE: <<<<<<< %u <<<<<<\n",
		rsvp_timestamp(),time_now);

	/* Dump each session */
	for (i = 0; i < SESS_HASH_SIZE; i++)
		for (dst = session_hash[i]; dst; dst = dst->d_next)
			dump_session_state(dst);
	return;
}

void
dump_session_state(Session *dst) {
	PSB 		*snd;
	RSB		*rp;
	int		 i;
	net_if inf;

	fmt_object(dst->d_session, 0);

	if (debug_filter) {
		for (i = 0; i < debug_filter_num; i++) {
			NET_SET_IF_PHY(&inf,debug_filters[i],0);
			if (session_if_eq(dst->d_session,&inf))
				break;
		}
		if (i == debug_filter_num)
			return;
	}
	log(LOG_DEBUG, 0, "   Refresh intervals: Path R= %d  Resv R=%d\n",
		dst->d_Rtimop, dst->d_Rtimor);
	for (snd = dst->d_PSB_list; snd != NULL; snd = snd->ps_next)
		dump_PSB(snd);
	for (rp = dst->d_RSB_list; rp != NULL; rp = rp->rs_next)
		dump_RSB(rp);
	for (i = 0; i < if_num; i++)
		LL_BugDump(i, dst);
	log(LOG_DEBUG, 0, 
		"   ------------- End of Dest state dump ---------------\n\n");
}

void
dump_PSB(PSB *sp) {
	Fobject		*fop;

	log(LOG_DEBUG, 0,
	"   Sender: %s   PHOP: <%s>   TTD: %d\n", 
		fmt_filtspec(sp->ps_templ),
 		(IsHopAPI(&sp->ps_phop)) ? "(API)" : hop_print(&sp->ps_phop),
		sp->ps_ttd);
	log(LOG_DEBUG, 0,
	"     In_if %d=>%s  Outlist %s   flags %s  ip_ttl %d\n",
		sp->ps_in_if, IF_NAME(sp->ps_in_if), 
		bm_expand(&(sp->ps_outif_list), s),
		cnv_flags("SRPULE?N", sp->ps_flags), sp->ps_ip_ttl);
	log(LOG_DEBUG, 0,
	"     %s", fmt_tspec(sp->ps_tspec));
	if (sp->ps_adspec)
		log(LOG_DEBUG, 0, "   %s\n", fmt_adspec(sp->ps_adspec));
	else 
		log(LOG_DEBUG, 0, "\n");
	for (fop = sp->ps_UnkObjList; fop; fop= fop->Fobj_next)
		fmt_object(&fop->Fobj_objhdr, 0);
	if (sp->ps_BSB_Qb)
		log(LOG_DEBUG, 0,
		"      Blockade: Tb= %d  Qb= %s\n", sp->ps_BSB_Tb,
			fmt_flowspec(sp->ps_BSB_Qb));
}

void
dump_RSB(RSB *rp)
	{
	char		temp[256];
	Fobject		*fop;

	sprintf(temp, "Iface %d=>%s Nhop <%s>",
			rp->rs_OIf, IF_NAME(rp->rs_OIf),
			 hop_print(&rp->rs_nhop));
	log(LOG_DEBUG, 0, "   %s Resv:   %s  TTD %d\n",
				fmt_style(rp->rs_style), temp, rp->rs_ttd);
	if (rp->rs_scope)
		fmt_object(rp->rs_scope, RSVP_RESV);
	if (rp->rs_confirm)
		fmt_object(rp->rs_confirm, RSVP_RESV);
	else if (rp->rs_scope)
		log(LOG_DEBUG, 0, "\n");
	for (fop = rp->rs_UnkObjList; fop; fop= fop->Fobj_next)
		fmt_object(&fop->Fobj_objhdr, 0);
	dump_filtstar(rp->rs_filtstar, rp->rs_spec);
}

void
dump_filtstar(FiltSpecStar *fstp, FLOWSPEC *specp)
	{
	int i;

	if (fstp->fst_count == 0) {
		log(LOG_DEBUG, 0, "      Flowspec %s\n",  fmt_flowspec(specp));
		return;
	}
	for (i=0; i < fstp->fst_count; i++) {
	    if (fstp->fst_Filtp(i) == NULL)
		continue;
	    if (i)
		log(LOG_DEBUG, 0, "             %s\n",
				fmt_filtspec(fstp->fst_Filtp(i)));
	    else
		log(LOG_DEBUG, 0, "      Filter %s    Flowspec %s\n",
				fmt_filtspec(fstp->fst_filtp0), 
				fmt_flowspec(specp));
	}
}


/*
 * print_rsvp(): Log a dump of an RSVP message.
 */
void
print_rsvp(struct packet *pkt)
	{
	packet_map	*mapp = pkt->pkt_map;
	enum byteorder	old_order = pkt->pkt_order;
	SCOPE		*scp;
        DIAG_RESPONSE   *d_resp ;
	Fobject		*fop;
	int             i;
	net_if inf;

	ntoh_packet(pkt);
	/* It would be nicer to make copy if necessary to convert byte order,
	 *	avoid converting back at end.
	 */
 
	if (!(mapp->rsvp_session)) {
		log (LOG_DEBUG, 0, "Missing session obj\n");
		return;
	}
	if (debug_filter) {
		for (i = 0; i < debug_filter_num; i++) {
			NET_SET_IF_PHY(&inf,debug_filters[i],0);
			if (session_if_eq(pkt->rsvp_sess,&inf))
				break;
		}
		if (i == debug_filter_num)
			return;
	}

	if (mapp->rsvp_integrity)
		fmt_object(mapp->rsvp_integrity, 0);
	log(LOG_DEBUG, 0, "  %-4s:", r_type[mapp->rsvp_msgtype]);
	fmt_object(mapp->rsvp_session, 0);

	switch (mapp->rsvp_msgtype) {

	    case (RSVP_PATH):
	    case (RSVP_PATH_TEAR):
		fmt_object(mapp->rsvp_timev, RSVP_PATH);
		fmt_object(mapp->rsvp_hop, RSVP_PATH);
		print_senders(pkt);
		break;

	    case (RSVP_RESV):
	    case (RSVP_RESV_TEAR):
		fmt_object(mapp->rsvp_timev, RSVP_RESV);
		fmt_object(mapp->rsvp_hop, RSVP_RESV);
		if ((scp = mapp->rsvp_scope_list))
			fmt_object(scp, RSVP_RESV);
		if (mapp->rsvp_confirm)
			fmt_object(mapp->rsvp_confirm, RSVP_RESV);

		print_flwds(pkt);
		log(LOG_DEBUG, 0, "\n");
		break;

	    case (RSVP_PATH_ERR):
		log(LOG_DEBUG, 0, "\n");	
		fmt_object(mapp->rsvp_errspec, RSVP_RESV_ERR);
		print_senders(pkt);
		break;

	    case (RSVP_RESV_ERR):
		log(LOG_DEBUG, 0, "\n");	
		fmt_object(mapp->rsvp_errspec, RSVP_RESV_ERR);
		print_flwds(pkt);
		break;

	    case (RSVP_CONFIRM):
		log(LOG_DEBUG, 0, "\n");
		fmt_object(mapp->rsvp_confirm, RSVP_CONFIRM);	
		fmt_object(mapp->rsvp_errspec, RSVP_RESV_ERR);
		print_flwds(pkt);
		break;

            case (RSVP_DREQ):
                fmt_object(mapp->rsvp_diag, RSVP_DREQ);
                if (mapp->rsvp_diag_response) {
                        d_resp = mapp->rsvp_diag_response ;
                        log(LOG_DEBUG, 0, "  Responses: %d\n",mapp->rsvp_resplist);     
                        for(i=0;i<mapp->rsvp_resplist;i++) {
                                fmt_object(d_resp, RSVP_DREQ);
                                (char *)d_resp += Obj_Length(d_resp);
                        }
                }
                if(mapp->rsvp_route) {
                        log(LOG_DEBUG, 0, "  Route: \n");
                        fmt_object(mapp->rsvp_route,RSVP_DREQ);
                }
                break;

            case (RSVP_DREP):
                fmt_object(mapp->rsvp_diag, RSVP_DREP);
                if (mapp->rsvp_diag_response) {
                        d_resp = mapp->rsvp_diag_response ;
                        log(LOG_DEBUG, 0, "  Responses: %d\n",mapp->rsvp_resplist);     
                        for(i=0;i<mapp->rsvp_resplist;i++) {
                                fmt_object(d_resp, RSVP_DREP);
                                (char *)d_resp += Obj_Length(d_resp);
                        }
                }
                if(mapp->rsvp_route) {
                        log(LOG_DEBUG, 0, "  Route: \n");
                        fmt_object(mapp->rsvp_route,RSVP_DREP);
                }
                break;
		
	default:
		log(LOG_DEBUG, 0, "unknown rsvp packet type: %d\n",
		    RSVP_TYPE_OF(pkt->pkt_data));
		break;
	}
	for (fop = mapp->rsvp_UnkObjList; fop; fop = fop->Fobj_next)
		fmt_object(&fop->Fobj_objhdr, 0);

/****
	log(LOG_DEBUG, 0,
	    "  --------------- end packet parse ---------------------------\n\n"
	    );
****/
	log(LOG_DEBUG, 0, "\n");

	if (old_order != BO_HOST) {
		hton_packet(pkt);
	}

}

void
print_senders(struct packet *pkt)
	{
	SenderDesc     *sdscp = SenderDesc_of(pkt);

	log(LOG_DEBUG, 0, "\t%s  %s\n", fmt_filtspec(sdscp->rsvp_stempl), 
					fmt_tspec(sdscp->rsvp_stspec));
	if (sdscp->rsvp_adspec)