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 int
  84 PerformDump(register struct cmd_syndesc *as, void *arock)
  85 {
  86     struct rx_connection *aconn;
  87     afs_int32 server;
  88     FILE *fopen(), *fp;
  89     struct tc_dumpDesc *ptr;
  90     int i;
  91     afs_int32 parentDumpID, dumpLevel;
  92
  93     server = GetServer(SERVERNAME);
  94     if (!server) {
  95         printf("cant get server id \n");
  96         exit(1);
  97     }
  98     parentDumpID = 1;
  99     dumpLevel = 1;
 100     strcpy(tdumpSetName, "Test");
 101     ttapeSet.id = 1;
 102     ttapeSet.maxTapes = 10;
 103     fp = fopen("dumpScr", "r");
 104     fscanf(fp, "%u %u %u\n", &tdumps.tc_dumpArray_len, &ttapeSet.a,
 105            &ttapeSet.b);
 106     strcpy(ttapeSet.format, "tapeName%u");
 107     strcpy(ttapeSet.tapeServer, "diskTapes");
 108     tdumps.tc_dumpArray_val =
 109         (struct tc_dumpDesc
 110          *)(malloc(tdumps.tc_dumpArray_len * sizeof(struct tc_dumpDesc)));
 111     ptr = tdumps.tc_dumpArray_val;
 112     for (i = 0; i < tdumps.tc_dumpArray_len; i++) {
 113         fscanf(fp, "%s\n", ptr->name);
 114         fscanf(fp, "%s\n", ptr->hostAddr);
 115         fscanf(fp, "%u %u %u\n", &ptr->vid, &ptr->partition, &ptr->date);
 116         ptr++;
 117     }
 118
 119     aconn = UV_Bind(server, TCPORT);
 120     code =
 121         TC_PerformDump(aconn, tdumpSetName, &ttapeSet, &tdumps, parentDumpID,
 122                        dumpLevel, &tdumpID);
 123     free(tdumps.tc_dumpArray_val);
 124     if (code) {
 125         printf("call to TC_PerformDump failed %u\n", code);
 126         exit(1);
 127     }
 128     printf("dumpid returned %u\n", tdumpID);
 129
 130     return 0;
 131 }
 132
 133 static int
 134 PerformRestore(register struct cmd_syndesc *as, void *arock)
 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     return 0;
 173 }
 174
 175 static int
 176 CheckDump(register struct cmd_syndesc *as, void *arock)
 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     return 0;
 193 }
 194
 195 static int
 196 AbortDump(register struct cmd_syndesc *as, void *arock)
 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     return 0;
 213 }
 214
 215 static int
 216 WaitForDump(register struct cmd_syndesc *as, void *arock)
 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     return 0;
 233 }
 234
 235 static int
 236 EndDump(register struct cmd_syndesc *as, void *arock)
 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     return 0;
 253 }
 254
 255 static int
 256 MyBeforeProc(struct cmd_syndesc *as, void *arock)
 257 {
 258     afs_int32 code;
 259
 260     code = rx_Init(0);
 261     if (code) {
 262         printf("Could not initialize rx.\n");
 263         return code;
 264     }
 265     rxInitDone = 1;
 266     rx_SetRxDeadTime(50);
 267     return 0;
 268 }
 269
 270 #include "AFS_component_version_number.c"
 271
 272 main(argc, argv)
 273      int argc;
 274      char **argv;
 275 {
 276     register afs_int32 code;
 277
 278     register struct cmd_syndesc *ts;
 279
 280 #ifdef  AFS_AIX32_ENV
 281     /*
 282      * The following signal action for AIX is necessary so that in case of a
 283      * crash (i.e. core is generated) we can include the user's data section
 284      * in the core dump. Unfortunately, by default, only a partial core is
 285      * generated which, in many cases, isn't too useful.
 286      */
 287     struct sigaction nsa;
 288
 289     sigemptyset(&nsa.sa_mask);
 290     nsa.sa_handler = SIG_DFL;
 291     nsa.sa_flags = SA_FULLDUMP;
 292     sigaction(SIGABRT, &nsa, NULL);
 293     sigaction(SIGSEGV, &nsa, NULL);
 294 #endif
 295     cmd_SetBeforeProc(MyBeforeProc, NULL);
 296
 297     ts = cmd_CreateSyntax("dump", PerformDump, NULL, "perform a dump");
 298
 299     ts = cmd_CreateSyntax("restore", PerformRestore, NULL, "perform a restore");
 300
 301     ts = cmd_CreateSyntax("check", CheckDump, NULL, "check a dump");
 302     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 303
 304     ts = cmd_CreateSyntax("abort", AbortDump, NULL, "abort a dump");
 305     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 306
 307     ts = cmd_CreateSyntax("wait", WaitForDump, NULL, "wait for a dump");
 308     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 309
 310     ts = cmd_CreateSyntax("end", EndDump, NULL, "end a dump");
 311     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
 312
 313     code = cmd_Dispatch(argc, argv);
 314     if (rxInitDone)
 315         rx_Finalize();
 316     exit(code);
 317 }