dce_admin_host.c

Ho Chi Minh City University of Technology Computer Science Department Distributed Computing E

/***************************************
Ho Chi Minh City University of Technology
    Computer Science Department 
Distributed Computing Environment (DCE)
Written by Nguyen Van Noi -59406114
File dce_admin_host.c on Thu Dec 17 10:36:57 1998
****************************************/
#include <rpc/rpc.h>
#include <rpcsvc/rusers.h>
#include <rpcsvc/rstat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include "dce_admin.h"

#define TIME_OUT_RUSER 2

int cmphost (void *p1, void *p2);
void *newhost (u_long u);
void printhost (void *p);
bool_t next_one (char *, struct sockaddr_in *);
extern bool_t xdr_utmp_array (XDR *, utmp_array *);
static utmp_array ua;
static int b;

void *
newhost (u_long u)
{
  u_long *p = (u_long *) malloc (sizeof (u));
  if (!p)
    return NULL;
  *p = u;
  return p;
}

int
cmphost (void *p1, void *p2)
{
  u_long *pu1 = (u_long *) p1, *pu2 = (u_long *) p2;
  return *pu1 == *pu2;
}

void
printhost (void *p)
{
  u_long *pu = (u_long *) p;
  fprintf (stderr, "%s\n", ascaddr (*pu));
}

int
dce_admin_findhost (u_long u)
{
  void **p = ItemLookup (Admin.pListHost, (void *) &u, cmphost);
  if (!p)
    return 0;
  free (p);
  return 1;
}

void
travelprinthost ()
{
  fprintf (stderr, "\nList of hosts:\n");
  TravelList (Admin.pListHost, printhost);
}

void
dce_admin_listhost (int bShow)
{
  enum clnt_stat r;
  b = bShow;
  FreeList (Admin.pListHost, NULL);
  Admin.pListHost = NewList ();
  r = clnt_broadcast (RUSERSPROG, RUSERSVERS_3, RUSERSPROC_ALLNAMES,
		      xdr_void, 0, xdr_utmp_array, (caddr_t) & ua,
		      next_one);
  if (!bShow)
    return;
  travelprinthost ();
}


bool_t
next_one (char *pt, struct sockaddr_in * addr)
{
  utmp_array *p = (utmp_array *) pt;
  rusers_utmp *pp = p->utmp_array_val;
  int i = p->utmp_array_len;
  void *pu = newhost (addr->sin_addr.s_addr);
  if (b)
    printhost (pu);
  if (!AddItem (Admin.pListHost, pu, cmphost))
    {
      free (pu);
      return TRUE;
    }
  else if (b)
    while (i--)
      {
	fprintf (stderr, "%8s %8s %8s\n", pp->ut_user, pp->ut_line, pp->ut_host);
	pp++;
      }
  return FALSE;
}

/*****************************Netstat***********************/

#define TIMEOUT_NETSTAT  2


time_t t1, t2;
struct statstime s;
int timeout;

void
dump_statstime (struct statstime *s, struct sockaddr_in *addr, time_t * t)
{
  if (addr != NULL)
    {
      fprintf (stderr, "%s: ", inet_ntoa (addr->sin_addr));
    }

  fprintf (stderr, "rxv_ts=%ld ", *t);
  fprintf (stderr, "user=%d nice=%d sys=%d unknown=%d ",
	   s->cp_time[0],
	   s->cp_time[1],
	   s->cp_time[2],
	   s->cp_time[3]);

  fprintf (stderr, "v_pgpgin=%u v_pgpgout=%u v_pswpin=%u v_pswpout=%u ",
	   s->v_pgpgin,
	   s->v_pgpgout,
	   s->v_pswpin,
	   s->v_pswpout);

  fprintf (stderr, "dk_xfer=%d ",
	   s->dk_xfer[0]);

  fprintf (stderr, "v_intr=%u v_swtch=%u ",
	   s->v_intr,
	   s->v_swtch);

  fprintf (stderr, "if_ipackets=%d if_ierrors=%d if_opackets=%d if_oerrors=%d if_collisions=%d ",
	   s->if_ipackets,
	   s->if_ierrors,
	   s->if_opackets,
	   s->if_oerrors,
	   s->if_collisions);
  fprintf (stderr, "load1=%.2f load5=%.2f load15=%.2f ",
	   (float) s->avenrun[0] / FSCALE,
	   (float) s->avenrun[1] / FSCALE,
	   (float) s->avenrun[2] / FSCALE);
  fprintf (stderr, "uptime=%ld\n", s->curtime.tv_sec - s->boottime.tv_sec);

  fprintf (stderr, "\n");
}
bool_t
next_one_netstat (char *out, struct sockaddr_in *addr)
{

  if (time (&t2) == (time_t) - 1)
    return TRUE;
  dump_statstime ((struct statstime *) out, addr, &t2);
  return ((t2 - t1) > timeout);
}

void
dce_netstat (int i)
{

  enum clnt_stat r;
  timeout = (i > TIMEOUT_NETSTAT) ? i : TIMEOUT_NETSTAT;
  if (time (&t1) == (time_t) - 1)
    fprintf (stderr, "Error int timer \n");
  r = clnt_broadcast (RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS,
		      xdr_void, 0, xdr_statstime, (caddr_t) & s,
		      next_one_netstat);
  if (r != RPC_SUCCESS && r != RPC_TIMEDOUT)
    clnt_perrno (r);
  alarm (0);
}