utils/statd/simulate.c

   1 /*
   2  * Copyright (C) 1995-1997, 1999 Jeffrey A. Uphoff
   3  *
   4  * NSM for Linux.
   5  */
   6
   7 #include "config.h"
   8 #ifndef SIMULATIONS
   9 # error How the hell did we get here?
  10 #endif
  11
  12 /* If we're running the simulator, we're debugging.  Pretty simple. */
  13 #ifndef DEBUG
  14 # define DEBUG
  15 #endif
  16
  17 #include <signal.h>
  18 #include <string.h>
  19 #include <rpc/rpc.h>
  20 #include <rpc/pmap_clnt.h>
  21 #include <rpcmisc.h>
  22 #include "statd.h"
  23 #include "sim_sm_inter.h"
  24
  25 static void daemon_simulator (void);
  26 static void sim_killer (int sig);
  27 static void simulate_crash (char *);
  28 static void simulate_mon (char *, char *, char *, char *, char *);
  29 static void simulate_stat (char *, char *);
  30 static void simulate_unmon (char *, char *, char *, char *);
  31 static void simulate_unmon_all (char *, char *, char *);
  32
  33 static int sim_port = 0;
  34
  35 extern void sim_sm_prog_1 (struct svc_req *, register SVCXPRT);
  36 extern void svc_exit (void);
  37
  38 void
  39 simulator (int argc, char **argv)
  40 {
  41   xlog_stderr (1);
  42   xlog_syslog (0);
  43   xlog_open ("statd simulator");
  44
  45   if (argc == 2)
  46     if (!strcasecmp (*argv, "crash"))
  47       simulate_crash (*(&argv[1]));
  48
  49   if (argc == 3) {
  50     if (!strcasecmp (*argv, "stat"))
  51       simulate_stat (*(&argv[1]), *(&argv[2]));
  52   }
  53   if (argc == 4) {
  54     if (!strcasecmp (*argv, "unmon_all"))
  55       simulate_unmon_all (*(&argv[1]), *(&argv[2]), *(&argv[3]));
  56   }
  57   if (argc == 5) {
  58     if (!strcasecmp (*argv, "unmon"))
  59       simulate_unmon (*(&argv[1]), *(&argv[2]), *(&argv[3]), *(&argv[4]));
  60   }
  61   if (argc == 6) {
  62     if (!strcasecmp (*argv, "mon"))
  63       simulate_mon (*(&argv[1]), *(&argv[2]), *(&argv[3]), *(&argv[4]),
  64                     *(&argv[5]));
  65   }
  66   xlog_err ("WTF?  Give me something I can use!");
  67 }
  68
  69 static void
  70 simulate_mon (char *calling, char *monitoring, char *as, char *proggy,
  71               char *fool)
  72 {
  73   CLIENT *client;
  74   sm_stat_res *result;
  75   mon mon;
  76
  77   xlog (D_GENERAL, "Calling %s (as %s) to monitor %s", calling, as,
  78            monitoring);
  79
  80   if ((client = clnt_create (calling, SM_PROG, SM_VERS, "udp")) == NULL)
  81     xlog_err ("%s", clnt_spcreateerror ("clnt_create"));
  82
  83   memcpy (mon.priv, fool, SM_PRIV_SIZE);
  84   mon.mon_id.my_id.my_name = xstrdup (as);
  85   sim_port = atoi (proggy) * SIM_SM_PROG;
  86   mon.mon_id.my_id.my_prog = sim_port; /* Pseudo-dummy */
  87   mon.mon_id.my_id.my_vers = SIM_SM_VERS;
  88   mon.mon_id.my_id.my_proc = SIM_SM_MON;
  89   mon.mon_id.mon_name = monitoring;
  90
  91   if (!(result = sm_mon_1 (&mon, client)))
  92     xlog_err ("%s", clnt_sperror (client, "sm_mon_1"));
  93
  94   free (mon.mon_id.my_id.my_name);
  95
  96   if (result->res_stat != STAT_SUCC) {
  97     xlog_err ("SM_MON request failed, state: %d", result->state);
  98   } else {
  99     xlog (D_GENERAL, "SM_MON result successful, state: %d\n", result->state);
 100     xlog (D_GENERAL, "Waiting for callback");
 101     daemon_simulator ();
 102     exit (0);
 103   }
 104 }
 105
 106 static void
 107 simulate_unmon (char *calling, char *unmonitoring, char *as, char *proggy)
 108 {
 109   CLIENT *client;
 110   sm_stat *result;
 111   mon_id mon_id;
 112
 113   xlog (D_GENERAL, "Calling %s (as %s) to unmonitor %s", calling, as,
 114            unmonitoring);
 115
 116   if ((client = clnt_create (calling, SM_PROG, SM_VERS, "udp")) == NULL)
 117     xlog_err ("%s", clnt_spcreateerror ("clnt_create"));
 118
 119   mon_id.my_id.my_name = xstrdup (as);
 120   mon_id.my_id.my_prog = atoi (proggy) * SIM_SM_PROG;
 121   mon_id.my_id.my_vers = SIM_SM_VERS;
 122   mon_id.my_id.my_proc = SIM_SM_MON;
 123   mon_id.mon_name = unmonitoring;
 124
 125   if (!(result = sm_unmon_1 (&mon_id, client)))
 126     xlog_err ("%s", clnt_sperror (client, "sm_unmon_1"));
 127
 128   free (mon_id.my_id.my_name);
 129   xlog (D_GENERAL, "SM_UNMON request returned state: %d\n", result->state);
 130   exit (0);
 131 }
 132
 133 static void
 134 simulate_unmon_all (char *calling, char *as, char *proggy)
 135 {
 136   CLIENT *client;
 137   sm_stat *result;
 138   my_id my_id;
 139
 140   xlog (D_GENERAL, "Calling %s (as %s) to unmonitor all hosts", calling, as);
 141
 142   if ((client = clnt_create (calling, SM_PROG, SM_VERS, "udp")) == NULL)
 143     xlog_err ("%s", clnt_spcreateerror ("clnt_create"));
 144
 145   my_id.my_name = xstrdup (as);
 146   my_id.my_prog = atoi (proggy) * SIM_SM_PROG;
 147   my_id.my_vers = SIM_SM_VERS;
 148   my_id.my_proc = SIM_SM_MON;
 149
 150   if (!(result = sm_unmon_all_1 (&my_id, client)))
 151     xlog_err ("%s", clnt_sperror (client, "sm_unmon_all_1"));
 152
 153   free (my_id.my_name);
 154   xlog (D_GENERAL, "SM_UNMON_ALL request returned state: %d\n", result->state);
 155   exit (0);
 156 }
 157
 158 static void
 159 simulate_crash (char *host)
 160 {
 161   CLIENT *client;
 162
 163   if ((client = clnt_create (host, SM_PROG, SM_VERS, "udp")) == NULL)
 164     xlog_err ("%s", clnt_spcreateerror ("clnt_create"));
 165
 166   if (!sm_simu_crash_1 (NULL, client))
 167     xlog_err ("%s", clnt_sperror (client, "sm_simu_crash_1"));
 168
 169   exit (0);
 170 }
 171
 172 static void
 173 simulate_stat (char *calling, char *monitoring)
 174 {
 175   CLIENT *client;
 176   sm_name checking;
 177   sm_stat_res *result;
 178
 179   if ((client = clnt_create (calling, SM_PROG, SM_VERS, "udp")) == NULL)
 180     xlog_err ("%s", clnt_spcreateerror ("clnt_create"));
 181
 182   checking.mon_name = monitoring;
 183
 184   if (!(result = sm_stat_1 (&checking, client)))
 185     xlog_err ("%s", clnt_sperror (client, "sm_stat_1"));
 186
 187   if (result->res_stat == STAT_SUCC)
 188     xlog (D_GENERAL, "STAT_SUCC from %s for %s, state: %d", calling,
 189              monitoring, result->state);
 190   else
 191     xlog (D_GENERAL, "STAT_FAIL from %s for %s, state: %d", calling,
 192              monitoring, result->state);
 193
 194   exit (0);
 195 }
 196
 197 static void
 198 sim_killer (int sig)
 199 {
 200   pmap_unset (sim_port, SIM_SM_VERS);
 201   xlog_err ("Simulator caught signal %d, un-registering and exiting", sig);
 202 }
 203
 204 static void
 205 daemon_simulator (void)
 206 {
 207   signal (SIGHUP, sim_killer);
 208   signal (SIGINT, sim_killer);
 209   signal (SIGTERM, sim_killer);
 210   pmap_unset (sim_port, SIM_SM_VERS);
 211   /* this registers both UDP and TCP services */
 212   rpc_init("statd", sim_port, SIM_SM_VERS, sim_sm_prog_1, 0);
 213   svc_run ();
 214   pmap_unset (sim_port, SIM_SM_VERS);
 215 }
 216
 217 void *
 218 sim_sm_mon_1_svc (struct status *argp, struct svc_req *rqstp)
 219 {
 220   static char *result;
 221
 222   xlog (D_GENERAL, "Recieved state %d for mon_name %s (opaque \"%s\")",
 223            argp->state, argp->mon_name, argp->priv);
 224   svc_exit ();
 225   return ((void *)&result);
 226 }