src/butc/test.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <sys/types.h>
  11 #include <sys/file.h>
  12 #include <sys/stat.h>
  13 #ifdef AFS_AIX_ENV
  14 #include <sys/statfs.h>
  15 #endif
  16 #include <netdb.h>
  17 #include <sys/errno.h>
  18 #include <lock.h>
  19 #include <netinet/in.h>
  20 #include <rx/xdr.h>
  21 #include <rx/rx.h>
  22 #include <rx/rx_globals.h>
  23 #include <afs/nfs.h>
  24 #include <afs/vlserver.h>
  25 #include <afs/cellconfig.h>
  26 #include <afs/keys.h>
  27 #include <ubik.h>
  28 #include <afs/afsint.h>
  29 #include <afs/cmd.h>
  30 #include <rx/rxkad.h>
  31 #include <afs/tcdata.h>
  32 #ifdef  AFS_AIX32_ENV
  33 #include <signal.h>
  34 #endif
  35
  36 #define SERVERNAME "server1"
  37
  38 afs_int32 code = 0;
  39 struct tc_tapeSet ttapeSet;
  40 char tdumpSetName[TC_MAXNAMELEN];
  41 tc_dumpArray tdumps;            /*defined by rxgen */
  42 tc_restoreArray trestores;      /*defined by rxgen */
  43 afs_int32 tdumpID;
  44 struct tc_dumpStat tstatus;
  45 int rxInitDone = 0;
  46
  47 struct rx_connection *
  48 UV_Bind(aserver, port)
  49      afs_int32 aserver, port;
  50 {
  51     register struct rx_connection *tc;
  52     struct rx_securityClass *uvclass;
  53
  54     uvclass = rxnull_NewClientSecurityObject();
  55     tc = rx_NewConnection(aserver, htons(port), TCSERVICE_ID, uvclass, 0);
  56     return tc;
  57 }
  58
  59
  60 /* return host address in network byte order */
  61 afs_int32
  62 GetServer(aname)
  63      char *aname;
  64 {
  65     register struct hostent *th;
  66     afs_int32 addr;
  67     char b1, b2, b3, b4;
  68     register afs_int32 code;
  69
  70     code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
  71     if (code == 4) {
  72         addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
  73         return htonl(addr);     /* convert to network order (128 in byte 0) */
  74     }
  75     th = gethostbyname(aname);
  76     if (!th)
  77         return 0;
  78     memcpy(&addr, th->h_addr, sizeof(addr));
  79     return addr;
  80 }
  81
  82
  83 static
  84 PerformDump(as)
  85      register struct cmd_syndesc *as;
  86 {
  87     struct rx_connection *aconn;
  88     afs_int32 server;
  89     FILE *fopen(), *fp;
  90     struct tc_dumpDesc *ptr;
  91     int i;
  92     afs_int32 parentDumpID, dumpLevel;
  93
  94     server = GetServer(SERVERNAME);
  95     if (!server) {
  96         printf("cant get server id \n");
  97         exit(1);
  98     }
  99     parentDumpID = 1;
 100     dumpLevel = 1;
 101     strcpy(tdumpSetName, "Test");
 102     ttapeSet.id = 1;
 103     ttapeSet.maxTapes = 10;
 104     fp = fopen("dumpScr", "r");
 105     fscanf(fp, "%u %u %u\n", &tdumps.tc_dumpArray_len, &ttapeSet.a,
 106            &ttapeSet.b);
 107     strcpy(ttapeSet.format, "tapeName%u");
 108     strcpy(ttapeSet.tapeServer, "diskTapes");
 109     tdumps.tc_dumpArray_val =
 110         (struct tc_dumpDesc
 111          *)(malloc(tdumps.tc_dumpArray_len * sizeof(struct tc_dumpDesc)));
 112     ptr = tdumps.tc_dumpArray_val;
 113     for (i = 0; i < tdumps.tc_dumpArray_len; i++) {
 114         fscanf(fp, "%s\n", ptr->name);
 115         fscanf(fp, "%s\n", ptr->hostAddr);
 116         fscanf(fp, "%u %u %u\n", &ptr->vid, &ptr->partition, &ptr->date);
 117         ptr++;
 118     }
 119
 120     aconn = UV_Bind(server, TCPORT);
 121     code =
 122         TC_PerformDump(aconn, tdumpSetName, &ttapeSet, &tdumps, parentDumpID,
 123                        dumpLevel, &tdumpID);
 124     free(tdumps.tc_dumpArray_val);
 125     if (code) {
 126         printf("call to TC_PerformDump failed %u\n", code);
 127         exit(1);
 128     }
 129     printf("dumpid returned %u\n", tdumpID);
 130 }
 131
 132 static
 133 PerformRestore(as)
 134      register struct cmd_syndesc *as;
 135 {
 136     struct rx_connection *aconn;
 137     afs_int32 server;
 138     int i;
 139     FILE *fopen(), *fp;
 140     struct tc_restoreDesc *ptr;
 141
 142     server = GetServer(SERVERNAME);
 143     if (!server) {
 144         printf("cant get server id \n");
 145         exit(1);
 146     }
 147     aconn = UV_Bind(server, TCPORT);
 148     strcpy(tdumpSetName, "");
 149     strcpy(tdumpSetName, "Test");
 150     fp = fopen("restoreScr", "r");
 151     fscanf(fp, "%u\n", &trestores.tc_restoreArray_len);
 152     trestores.tc_restoreArray_val =
 153         (struct tc_restoreDesc *)malloc(trestores.tc_restoreArray_len *
 154                                         sizeof(struct tc_restoreDesc));
 155     ptr = trestores.tc_restoreArray_val;
 156     for (i = 0; i < trestores.tc_restoreArray_len; i++) {
 157         fscanf(fp, "%s\n", ptr->oldName);
 158         fscanf(fp, "%s\n", ptr->newName);
 159         fscanf(fp, "%s\n", ptr->tapeName);
 160         fscanf(fp, "%s\n", ptr->hostAddr);
 161         fscanf(fp, "%u %u %u %u %d %u\n", &ptr->origVid, &ptr->vid,
 162                &ptr->partition, &ptr->flags, &ptr->frag, &ptr->position);
 163         ptr++;
 164
 165     }
 166     code = TC_PerformRestore(aconn, tdumpSetName, &trestores, &tdumpID);
 167     if (code) {
 168         printf("call to TC_PerformRestore failed %u\n", code);
 169         exit(1);
 170     }
 171     printf("dumpid returned %u\n", tdumpID);
 172 }
 173
 174 static
 175 CheckDump(as)
 176      register struct cmd_syndesc *as;
 177 {
 178     struct rx_connection *aconn;
 179     afs_int32 server;
 180     server = GetServer(SERVERNAME);
 181     if (!server) {
 182         printf("cant get server id \n");
 183         exit(1);
 184     }
 185     tdumpID = atol(as->parms[0].items->data);
 186     aconn = UV_Bind(server, TCPORT);
 187     code = TC_CheckDump(aconn, tdumpID, &tstatus);
 188     if (code) {
 189         printf("call to TC_CheckDump failed %u\n", code);
 190         exit(1);
 191     }
 192 }
 193
 194 static
 195 AbortDump(as)
 196      register struct cmd_syndesc *as;
 197 {
 198     struct rx_connection *aconn;
 199     afs_int32 server;
 200     server = GetServer(SERVERNAME);
 201     if (!server) {
 202         printf("cant get server id \n");
 203         exit(1);
 204     }
 205     tdumpID = atol(as->parms[0].items->data);
 206     aconn = UV_Bind(server, TCPORT);
 207     code = TC_AbortDump(aconn, tdumpID);
 208     if (code) {
 209         printf("call to TC_AbortDump failed %u\n", code);
 210         exit(1);
 211     }
 212 }
 213
 214 static
 215 WaitForDump(as)
 216      register struct cmd_syndesc *as;
 217 {
 218     struct rx_connection *aconn;
 219     afs_int32 server;
 220     server = GetServer(SERVERNAME);
 221     if (!server) {
 222         printf("cant get server id \n");
 223         exit(1);
 224     }
 225     tdumpID = atol(as->parms[0].items->data);
 226     aconn = UV_Bind(server, TCPORT);
 227     code = TC_WaitForDump(aconn, tdumpID);
 228     if (code) {
 229         printf("call to TC_WaitForDump failed %u\n", code);
 230         exit(1);
 231     }
 232 }
 233
 234 static
 235 EndDump(as)
 236      register struct cmd_syndesc *as;
 237 {
 238     struct rx_connection *aconn;
 239     afs_int32 server;
 240     server = GetServer(SERVERNAME);
 241     if (!server) {
 242         printf("cant get server id \n");
 243         exit(1);
 244     }
 245     tdumpID = atol(as->parms[0].items->data);
 246     aconn = UV_Bind(server, TCPORT);
 247     code = TC_EndDump(aconn, tdumpID);
 248     if (code) {
 249         printf("call to TC_EndDump failed %u\n", code);
 250         exit(1);
 251     }
 252 }
 253
 254 static
 255 MyBeforeProc(as, arock)
 256      struct cmd_syndesc *as;
 257      char *arock;
 258 {
 259     afs_int32 code;
 260
 261     code = rx_Init(0);
 262     if (code) {
 263         printf("Could not initialize rx.\n");
 264         return code;
 265     }
 266     rxInitDone = 1;
 267     rx_SetRxDeadTime(50);
 268     return 0;
 269 }
 270
 271 #include "AFS_component_version_number.c"
 272
 273 main(argc, argv)
 274      int argc;
 275      char **argv;
 276 {
 277     register afs_int32 code;
 278
 279     register struct cmd_syndesc *ts;
 280
 281 #ifdef  AFS_AIX32_ENV
 282     /*
 283      * The following signal action for AIX is necessary so that in case of a
 284      * crash (i.e. core is generated) we can include the user's data section
 285      * in the core dump. Unfortunately, by default, only a partial core is
 286      * generated which, in many cases, isn't too useful.
 287      */
 288     struct sigaction nsa;
 289
 290     sigemptyset(&nsa.sa_mask);
 291     nsa.sa_handler = SIG_DFL;
 292     nsa.sa_flags = SA_FULLDUMP;
 293     sigaction(SIGABRT, &nsa, NULL);
 294     sigaction(SIGSEGV, &nsa, NULL);
 295 #endif
 296     cmd_SetBeforeProc(MyBeforeProc, NULL);
 297
 298     ts = cmd_CreateSyntax("dump", PerformDump, 0, "perform a dump");
 299
 300     ts = cmd_CreateSyntax("restore", PerformRestore, 0, "perform a restore");
 301
 302     ts = cmd_CreateSyntax("check", CheckDump, 0, "check a dump");
 303     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 304
 305     ts = cmd_CreateSyntax("abort", AbortDump, 0, "abort a dump");
 306     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 307
 308     ts = cmd_CreateSyntax("wait", WaitForDump, 0, "wait for a dump");
 309     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 310
 311     ts = cmd_CreateSyntax("end", EndDump, 0, "end a dump");
 312     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 313
 314     code = cmd_Dispatch(argc, argv);
 315     if (rxInitDone)
 316         rx_Finalize();
 317     exit(code);
 318 }