reindent-20030715
[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
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 }