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