dce_admin_cmd.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_cmd.c on Wed Dec 16 17:41:08 1998
****************************************/
#include <kstat.h>
#include <sys/param.h>
#include <signal.h>
#include "dce_admin.h"
#include "dce_admin_host.h"

#define MAXARGC 10
#define MAXBUF  512


MSG msg;
int timeout;
int _nMaxOrder;
int wait_timeout ();
void set_timeout ();
void time_out ();
int dce_admin_mcastsend (char *buf, int len);
int dce_admin_accept ();
int dce_admin_quit (int argc, char **argv);
int dce_admin_help (int argc, char **argv);
int dce_admin_listhostuser (int argc, char **argv);
int dce_admin_killall (int argc, char **argv);
int dce_admin_startagent (int argc, char **argv);
int dce_admin_findagent (int argc, char **argv);
int dce_admin_connectagent (int argc, char **argv);
int dce_admin_disconnect (int argc, char **argv);
int dce_admin_maxorder (int argc, char **argv);
int dce_admin_server_is_running_on_host (int argc, char **argv);
int dce_admin_startserver (int argc, char **argv);
int dce_admin_listserver (int argc, char **argv);
int dce_admin_killserver (int argc, char **argv);
int dce_admin_killagent (int argc, char **argv);
int dce_admin_restart (int argc, char **argv);
int dce_admin_howmanyserver (int argc, char **argv);
int dce_admin_adduser (int argc, char **argv);
int dce_admin_listperuser (int argc, char **argv);
int dce_admin_deluser (int argc, char **argv);
int dce_admin_countnumaliveserver (int argc, char **argv);
int dce_admin_add_service (int argc, char **argv);
int dce_admin_listservice (int argc, char **argv);
int dce_admin_listcurusage (int argc, char **argv);
int dce_admin_load (int argc, char **argv);
int dce_admin_listonusage (int argc, char **argv);
int dce_admin_brstart (int argc, char **argv);
int dce_admin_listhoste (int argc, char **argv);
int dce_admin_listloadserver(int argc, char **argv);
int dce_admin_confirm(int argc, char **argv);
int dce_admin_serverload(int argc,char **argv);
funct_t f[] =
{
  {dce_admin_listhostuser, "listhost", "List all hosts and users of subnet"},
  {dce_admin_startagent, "startagent", "startgent [hostname]"},
  {dce_admin_startserver, "startserver", "startserver [hostname]"},
  {dce_admin_add_service, "addservice", "addservice servicename argc :New service to DCE system "},
  {dce_admin_listcurusage, "listusage", "List  Users who used services of DCE system"},
  {dce_admin_listservice, "listservice", "list all service of DCE system"},
  {dce_admin_countnumaliveserver, "caser", "How many server is alive"},
  {dce_admin_deluser, "deluser", "Remove user out of DCE system"},
  {dce_admin_listperuser, "listuser", "List all users allowed to use DCE system"},
  {dce_admin_adduser, "adduser", "adduser  username :Allow adduser to DCE system"},
  {dce_admin_howmanyserver, "countserver", "How many server running"},
  {dce_admin_restart, "restart", "Restart hostname to move agent to another host"},
/*  {dce_admin_killagent, "killagent", "Kill agent for restart agent another
host"},*/
  {dce_admin_serverload,"serverinfo","Show information load of server"},	
  {dce_admin_killserver, "killserver", "killserver servername"},
  {dce_admin_listserver, "listserver", "list all server of DCE system"},
  {dce_admin_listloadserver,"listloadserver","List server with update load"},
  {dce_admin_server_is_running_on_host, "serhost", "serhost hostname :Check	server is running on host"},
  {dce_admin_maxorder, "maxorder", "Max order of server list"},
  {dce_admin_disconnect, "disconnect", "Disconnect agent"},
  {dce_admin_connectagent, "connect", "Connect agent "},
  {dce_admin_findagent, "findagent", "Find agent of DCE system"},
  {dce_admin_listhoste, "listhoste", "listhost without refresh"},
  {dce_admin_brstart, "netstat", "netstat [timeout] Netstat for DCE system"},
  {dce_admin_listonusage, "listcurusage", "List current User who is using service of DCE system"},
  {dce_admin_load, "loadavg", "Show average load of this computer"},
  {dce_admin_confirm,"confirm","Confirm agent connect admin"},
  {dce_admin_killall, "killall", "Kill all programs of DCE system"},
  {dce_admin_help, "help", "Help all command"},
  {dce_admin_quit, "exit", "Quit ADMIN program"},
  {NULL, NULL, NULL}
};

int argc;
char *argv[MAXARGC];
char buf[MAXBUF], _buf[MAXBUF];

/****************************************/
void
set_timeout ()
{
  int ns = 0;
  timeout = TIMEOUT;
  while (signal (SIGALRM, time_out) == SIG_ERR)
    {
      fprintf (stderr, "SIGALRM be lost \n");
      if (ns++ > 3)
	exit (0);
    }
  alarm (timeout);
}

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

void
time_out ()
{
  timeout = 0;
}

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

int
wait_timeout ()
{
  return timeout;
}

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

int
dce_admin_getcommand ()
{
  char *p = buf;
  int i;
  fprintf (stdout, "DCE >");
  fgets (buf, MAXBUF, stdin);
  strstandard (buf);
  if (!buf[0])
    return 0;
  strcpy (_buf, buf);
  argc = 0;
  argv[argc] = buf;
  while (*p)
    {
      if (*p == ' ')
	{
	  argc++;
	  argv[argc] = p + 1;
	  (*p) = '\0';
	}
      p++;
    }
  argc++;
  argv[argc] = NULL;
  return argc;
}

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

int
dce_admin_treat ()
{
  pfunct_t p = f;
  while (p->function)
    {
      if (strcmp (p->functname, argv[0]) == 0)
	{
	  return p->function (argc, argv);
	}
      p++;
    }
  fprintf (stderr, "Bad command : %s\n", _buf);
  return 0;
}

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

int
dce_admin_quit (int argc, char **argv)
{
  Admin.bExit = 1;
  Admin.Msg.type = DCE_MSG_ADMIN_EXIT;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  return 1;
}

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

int
dce_admin_help (int argc, char **argv)
{
  pfunct_t p = f;
  while (p->function)
    {
      fprintf (stderr, "%13s   %s\n", p->functname, p->functhelp);
      p++;
    }
  return 1;
}

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

int
dce_admin_accept ()
{
  int n = -1;
  set_timeout ();
  while (wait_timeout ())
    if ((n = dce_socketaccept (Admin.nSocket)) > 0)
      {
	alarm (0);
	return n;
      }
  return -1;
}

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

int
dce_admin_mcastsend (char *buf, int len)
{
  return dce_mcastsendsend (Admin.nMSockSend, Admin.maddr, Admin.mport, buf, len);
}

/****************************************/
int
dce_admin_listhostuser (int argc, char **argv)
{
  dce_admin_listhost (1);
  return 1;
}

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

int
dce_admin_killall (int argc, char **argv)
{
  Admin.Msg.type = DCE_MSG_KILLALL;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  return dce_admin_quit (argc, argv);
}
/****************************************/
int
dce_admin_findagent (int argc, char **argv)
{
  int n;
  fprintf (stderr, "Searching Agent ..... ");
  Admin.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_EXIST;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  if ((n = dce_admin_accept ()) <= 0)
    {
      fprintf (stderr, "Time out ! Agent not found !\n");
      return 0;
    }
  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_EXIST)
      {
	fprintf (stderr, "Agent found at %s\n", ascaddr (msg.saddr));
	close (n);
	return 1;
      }
  close (n);
  fprintf (stderr, "Error in read message \n");
  return 0;

}
/****************************************/
int
dce_admin_startagent (int argc, char **argv)
{
  char cmd[256];
  char host[20];
  char ssport[20];
  char smport[20];
  char stime[20];
  char *p = argv[1];
  int n, code;
  u_long u = gethostaddr (argv[1]);
  if (dce_admin_findagent (argc, argv))
    return 0;
  if (u == -1)
    {
      fprintf (stderr, "Illegal hostname %s\n", argv[1]);
      return 0;
    }

  if (u != getmyaddr ())
    {
      dce_admin_listhost (0);
      if (!dce_admin_findhost (u))
	{
	  fprintf (stderr, "%s is not on subnet\n", ascaddr (u));
	  return 0;
	}
    }
  else
    p = host;

  sprintf (cmd, "%s/bin/%s/dceagent", Admin.szDCE_ROOT, gethostarch (argv[1]));
  strcpy (host, (char *) ascaddrip (getmyaddr ()));
  sprintf (smport, "%d", Admin.mport);
  sprintf (ssport, "%d", Admin.Msg.sport);
  sprintf (stime,"%d",TIMEOUT_IAMALIVE);
  if (!IsFileExist (cmd))
    {
      fprintf (stderr, "%s not found\n", cmd);
      return 0;
    }
  if ((code = fork ()) < 0)
    {
      fprintf (stderr, "Can not fork process for agent\n");
      return 0;
    }
  if (!code)
    {
      code = execlp ("/usr/bin/rsh", "rsh", p, cmd, Admin.szDCE_ROOT, ascaddrip      (Admin.maddr), smport, host, ssport, "0",stime, NULL);
      if (code < 0)
	fprintf (stderr, "Can not execlp %s\n", cmd);
      exit (-1);
    }
  if ((n = dce_admin_accept ()) <= 0)
    return 0;

  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_FORK_SUCCESS)
      fprintf (stderr, "Agent start successfully at %s\n", ascaddr (msg.saddr));
  close (n);
  return dce_admin_connectagent (argc, argv);
}
/****************************************/
int
dce_admin_connectagent (int argc, char **argv)
{
  int n;
  char buf[30];

  if (Admin.bConnect)
    return;
  Admin.Msg.nextra = getpid ();
  Admin.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_CONNECT;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  if ((n = dce_admin_accept ()) <= 0)
    {
      fprintf (stderr, "Time out ! Agent not found !\n");
      return 0;
    }
  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_ACCEPT_CONNECT)
      {
	strcpy (buf, ascaddr (msg.saddr));
	fprintf (stderr, "Agent at %s accept connect with %s\n", buf, ascaddrip (getmyaddr ()));
	close (n);
	Admin.bConnect = 1;
	return 1;
      }
  if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_REFUSE_CONNECT)
    {
      strcpy (buf, ascaddr (msg.saddr));
      fprintf (stderr, "Agent at %s has  connected with %s time %d s\n", buf, ascaddr (msg.aaddr), msg.nextra);
      close (n);
      Admin.bExit = 1;
      return 0;
    }

  close (n);
  fprintf (stderr, "Error in read message \n");
  return 0;

}
int
dce_admin_disconnect (int argc, char **argv)
{
  Admin.bConnect = 0;
  Admin.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_DISCONNECT;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
}

int
dce_admin_maxorder (int argc, char **argv)
{
  int n;
  if (!dce_admin_confirm(argc,argv))
    return;
  Admin.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_MAXORDER;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  if ((n = dce_admin_accept ()) <= 0)
    {
      fprintf (stderr, "Time out ! Agent not found !\n");
      return 0;
    }
  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_MAXORDER)
      {
	fprintf (stderr, "Max order of Server List is %d\n", msg.nextra);
	close (n);
	return 1;
      }
  close (n);
  fprintf (stderr, "Error in read message \n");
  return 0;

}

int
dce_admin_server_is_running_on_host (int argc, char **argv)
{
  int n;
  u_long u = gethostaddr (argv[1]);
  if (!dce_admin_confirm(argc, argv))
    return 0;
  if (u == -1)
    {
      fprintf (stderr, "Illegal hostname %s\n", argv[1]);
      return 0;
    }
  Admin.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_SERONHOST;
  Admin.Msg.aaddr = u;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  if ((n = dce_admin_accept ()) <= 0)
    {
      fprintf (stderr, "Time out ! Agent not found !\n");
      return 0;
    }
  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_SERVERREADYRUN)
      {
	fprintf (stderr, "Server is running at %s\n", ascaddr (u));
	close (n);
	return 1;

      }
    else if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_NOSERVERONHOST)
      {
	fprintf (stderr, "No Server run at %s\n", ascaddr (u));
	close (n);
	return 0;
      }
  close (n);
  fprintf (stderr, "Error in read message \n");
  return 0;

}

int
dce_admin_startserver (int argc, char **argv)
{
  char cmd[256];
  char host[20];
  char ssport[20];
  char smport[20];
  char smax[10];
  char stime[20];
  char *p = argv[1];
  int n, code;
  u_long u = gethostaddr (argv[1]);
  if (!dce_admin_confirm(argc, argv))
    return 0;
  if (u == -1)
    {
      fprintf (stderr, "Illegal hostname %s\n", argv[1]);
      return 0;
    }
  if (dce_admin_server_is_running_on_host (argc, argv))
    return 0;
  if (!dce_admin_maxorder (argc, argv))
    return 0;
  sprintf (smax, "%d", msg.nextra + 1);
  if (u != getmyaddr ())
    {
      dce_admin_listhost (0);
      if (!dce_admin_findhost (u))
	{
	  fprintf (stderr, "%s is not on subnet\n", ascaddr (u));
	  return 0;
	}
    }
  else
    p = host;

  sprintf (cmd, "%s/bin/%s/dceserver", Admin.szDCE_ROOT, gethostarch (argv[1]));
  strcpy (host, (char *) ascaddrip (getmyaddr ()));
  sprintf (smport, "%d", Admin.mport);
  sprintf (ssport, "%d", Admin.Msg.sport);
  sprintf (stime,"%d",TIMEOUT_IAMALIVE);
  if (!IsFileExist (cmd))
    {
      fprintf (stderr, "%s not found\n", cmd);
      return 0;
    }
  if ((code = fork ()) < 0)
    {
      fprintf (stderr, "Can not fork process for agent\n");
      return 0;
    }
  if (!code)
    {
      code = execlp ("/usr/bin/rsh", "rsh", p, cmd, Admin.szDCE_ROOT, ascaddrip(Admin.maddr), smport, host, ssport, smax,stime,NULL);
      if (code < 0)
	fprintf (stderr, "Can not execlp %s\n", cmd);
      exit (-1);
    }
  if ((n = dce_admin_accept ()) <= 0)
    return 0;

  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_SERVER_REPLY_ADMIN_FORK_SUCCESS)
      fprintf (stderr, "Server start successfully at %s\n", ascaddr (msg.saddr));
  close (n);
  return 1;
}

int
dce_admin_listserver (int argc, char **argv)
{
  int n;
  SINFO s;
  if (!dce_admin_confirm(argc,argv))
    return;
  dce_admin_howmanyserver (argc, argv);
  Admin.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_LISTSERVER;
  dce_admin_mcastsend ((char *) &Admin.Msg, sizeof (MSG));
  if ((n = dce_admin_accept ()) <= 0)
    {
      fprintf (stderr, "Time out ! Agent not found !\n");
      return 0;
    }
  while (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    {
      if (msg.type == DCE_MSG_END_OF_TRANSACTION)
	{
	  fprintf (stderr, "End of transaction\n");
	  close (n);
	  return 1;
	}
      if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_SERVERINFO)
	{
	  if (read (n, (void *) &s, sizeof (s)) == sizeof (s))
	    fprintf (stderr, "Server %s order %d status %d load %6.5f\n", ascaddr (s.addr), s.order, s.status, s.load);