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