[hcoop/debian/openafs.git] / src / butc / test.c

/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 *
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */
#include <afsconfig.h>
#include <afs/param.h>

#include <roken.h>

#ifdef AFS_AIX_ENV
#include <sys/statfs.h>
#endif

#include <lock.h>
#include <rx/xdr.h>
#include <rx/rx.h>
#include <rx/rx_globals.h>
#include <afs/nfs.h>
#include <afs/vlserver.h>
#include <afs/cellconfig.h>
#include <afs/keys.h>
#include <ubik.h>
#include <afs/afsint.h>
#include <afs/cmd.h>
#include <rx/rxkad.h>
#include <afs/tcdata.h>

#define SERVERNAME "server1"

afs_int32 code = 0;
struct tc_tapeSet ttapeSet;
char tdumpSetName[TC_MAXNAMELEN];
tc_dumpArray tdumps;		/*defined by rxgen */
tc_restoreArray trestores;	/*defined by rxgen */
afs_int32 tdumpID;
struct tc_dumpStat tstatus;
int rxInitDone = 0;

struct rx_connection *
UV_Bind(aserver, port)
     afs_uint32 aserver;
     afs_int32 port;
{
    struct rx_connection *tc;
    struct rx_securityClass *uvclass;

    uvclass = rxnull_NewClientSecurityObject();
    tc = rx_NewConnection(aserver, htons(port), TCSERVICE_ID, uvclass, 0);
    return tc;
}


/* return host address in network byte order */
afs_uint32
GetServer(aname)
     char *aname;
{
    struct hostent *th;
    afs_uint32 addr;
    char b1, b2, b3, b4;
    afs_int32 code;

    code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
    if (code == 4) {
	addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
	return htonl(addr);	/* convert to network order (128 in byte 0) */
    }
    th = gethostbyname(aname);
    if (!th)
	return 0;
    memcpy(&addr, th->h_addr, sizeof(addr));
    return addr;
}


static int
PerformDump(struct cmd_syndesc *as, void *arock)
{
    struct rx_connection *aconn;
    afs_uint32 server;
    FILE *fopen(), *fp;
    struct tc_dumpDesc *ptr;
    int i;
    afs_int32 parentDumpID, dumpLevel;

    server = GetServer(SERVERNAME);
    if (!server) {
	printf("cant get server id \n");
	exit(1);
    }
    parentDumpID = 1;
    dumpLevel = 1;
    strcpy(tdumpSetName, "Test");
    ttapeSet.id = 1;
    ttapeSet.maxTapes = 10;
    fp = fopen("dumpScr", "r");
    fscanf(fp, "%u %u %u\n", &tdumps.tc_dumpArray_len, &ttapeSet.a,
	   &ttapeSet.b);
    strcpy(ttapeSet.format, "tapeName%u");
    strcpy(ttapeSet.tapeServer, "diskTapes");
    tdumps.tc_dumpArray_val =
	malloc(tdumps.tc_dumpArray_len * sizeof(struct tc_dumpDesc));
    ptr = tdumps.tc_dumpArray_val;
    for (i = 0; i < tdumps.tc_dumpArray_len; i++) {
	fscanf(fp, "%s\n", ptr->name);
	fscanf(fp, "%s\n", ptr->hostAddr);
	fscanf(fp, "%u %u %u\n", &ptr->vid, &ptr->partition, &ptr->date);
	ptr++;
    }

    aconn = UV_Bind(server, TCPORT);
    code =
	TC_PerformDump(aconn, tdumpSetName, &ttapeSet, &tdumps, parentDumpID,
		       dumpLevel, &tdumpID);
    free(tdumps.tc_dumpArray_val);
    if (code) {
	printf("call to TC_PerformDump failed %u\n", code);
	exit(1);
    }
    printf("dumpid returned %u\n", tdumpID);

    return 0;
}

static int
PerformRestore(struct cmd_syndesc *as, void *arock)
{
    struct rx_connection *aconn;
    afs_uint32 server;
    int i;
    FILE *fopen(), *fp;
    struct tc_restoreDesc *ptr;

    server = GetServer(SERVERNAME);
    if (!server) {
	printf("cant get server id \n");
	exit(1);
    }
    aconn = UV_Bind(server, TCPORT);
    strcpy(tdumpSetName, "");
    strcpy(tdumpSetName, "Test");
    fp = fopen("restoreScr", "r");
    fscanf(fp, "%u\n", &trestores.tc_restoreArray_len);
    trestores.tc_restoreArray_val
	= malloc(trestores.tc_restoreArray_len *
		 sizeof(struct tc_restoreDesc));
    ptr = trestores.tc_restoreArray_val;
    for (i = 0; i < trestores.tc_restoreArray_len; i++) {
	fscanf(fp, "%s\n", ptr->oldName);
	fscanf(fp, "%s\n", ptr->newName);
	fscanf(fp, "%s\n", ptr->tapeName);
	fscanf(fp, "%s\n", ptr->hostAddr);
	fscanf(fp, "%u %u %u %u %d %u\n", &ptr->origVid, &ptr->vid,
	       &ptr->partition, &ptr->flags, &ptr->frag, &ptr->position);
	ptr++;

    }
    code = TC_PerformRestore(aconn, tdumpSetName, &trestores, &tdumpID);
    if (code) {
	printf("call to TC_PerformRestore failed %u\n", code);
	exit(1);
    }
    printf("dumpid returned %u\n", tdumpID);
    return 0;
}

static int
CheckDump(struct cmd_syndesc *as, void *arock)
{
    struct rx_connection *aconn;
    afs_uint32 server;
    server = GetServer(SERVERNAME);
    if (!server) {
	printf("cant get server id \n");
	exit(1);
    }
    tdumpID = atol(as->parms[0].items->data);
    aconn = UV_Bind(server, TCPORT);
    code = TC_CheckDump(aconn, tdumpID, &tstatus);
    if (code) {
	printf("call to TC_CheckDump failed %u\n", code);
	exit(1);
    }
    return 0;
}

static int
AbortDump(struct cmd_syndesc *as, void *arock)
{
    struct rx_connection *aconn;
    afs_uint32 server;
    server = GetServer(SERVERNAME);
    if (!server) {
	printf("cant get server id \n");
	exit(1);
    }
    tdumpID = atol(as->parms[0].items->data);
    aconn = UV_Bind(server, TCPORT);
    code = TC_AbortDump(aconn, tdumpID);
    if (code) {
	printf("call to TC_AbortDump failed %u\n", code);
	exit(1);
    }
    return 0;
}

static int
WaitForDump(struct cmd_syndesc *as, void *arock)
{
    struct rx_connection *aconn;
    afs_uint32 server;
    server = GetServer(SERVERNAME);
    if (!server) {
	printf("cant get server id \n");
	exit(1);
    }
    tdumpID = atol(as->parms[0].items->data);
    aconn = UV_Bind(server, TCPORT);
    code = TC_WaitForDump(aconn, tdumpID);
    if (code) {
	printf("call to TC_WaitForDump failed %u\n", code);
	exit(1);
    }
    return 0;
}

static int
EndDump(struct cmd_syndesc *as, void *arock)
{
    struct rx_connection *aconn;
    afs_uint32 server;
    server = GetServer(SERVERNAME);
    if (!server) {
	printf("cant get server id \n");
	exit(1);
    }
    tdumpID = atol(as->parms[0].items->data);
    aconn = UV_Bind(server, TCPORT);
    code = TC_EndDump(aconn, tdumpID);
    if (code) {
	printf("call to TC_EndDump failed %u\n", code);
	exit(1);
    }
    return 0;
}

static int
MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
    afs_int32 code;

    code = rx_Init(0);
    if (code) {
	printf("Could not initialize rx.\n");
	return code;
    }
    rxInitDone = 1;
    rx_SetRxDeadTime(50);
    return 0;
}

#include "AFS_component_version_number.c"

main(argc, argv)
     int argc;
     char **argv;
{
    afs_int32 code;

    struct cmd_syndesc *ts;

#ifdef	AFS_AIX32_ENV
    /*
     * The following signal action for AIX is necessary so that in case of a
     * crash (i.e. core is generated) we can include the user's data section
     * in the core dump. Unfortunately, by default, only a partial core is
     * generated which, in many cases, isn't too useful.
     */
    struct sigaction nsa;

    sigemptyset(&nsa.sa_mask);
    nsa.sa_handler = SIG_DFL;
    nsa.sa_flags = SA_FULLDUMP;
    sigaction(SIGABRT, &nsa, NULL);
    sigaction(SIGSEGV, &nsa, NULL);
#endif
    cmd_SetBeforeProc(MyBeforeProc, NULL);

    ts = cmd_CreateSyntax("dump", PerformDump, NULL, 0, "perform a dump");

    ts = cmd_CreateSyntax("restore", PerformRestore, NULL, 0, "perform a restore");

    ts = cmd_CreateSyntax("check", CheckDump, NULL, 0, "check a dump");
    cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");

    ts = cmd_CreateSyntax("abort", AbortDump, NULL, 0, "abort a dump");
    cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");

    ts = cmd_CreateSyntax("wait", WaitForDump, NULL, 0, "wait for a dump");
    cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");

    ts = cmd_CreateSyntax("end", EndDump, NULL, 0, "end a dump");
    cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");

    code = cmd_Dispatch(argc, argv);
    if (rxInitDone)
	rx_Finalize();
    exit(code);
}
Commit	Line	Data
805e021f CE	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	malloc(tdumps.tc_dumpArray_len * sizeof(struct tc_dumpDesc));
107	ptr = tdumps.tc_dumpArray_val;
108	for (i = 0; i < tdumps.tc_dumpArray_len; i++) {
109	fscanf(fp, "%s\n", ptr->name);
110	fscanf(fp, "%s\n", ptr->hostAddr);
111	fscanf(fp, "%u %u %u\n", &ptr->vid, &ptr->partition, &ptr->date);
112	ptr++;
113	}
114
115	aconn = UV_Bind(server, TCPORT);
116	code =
117	TC_PerformDump(aconn, tdumpSetName, &ttapeSet, &tdumps, parentDumpID,
118	dumpLevel, &tdumpID);
119	free(tdumps.tc_dumpArray_val);
120	if (code) {
121	printf("call to TC_PerformDump failed %u\n", code);
122	exit(1);
123	}
124	printf("dumpid returned %u\n", tdumpID);
125
126	return 0;
127	}
128
129	static int
130	PerformRestore(struct cmd_syndesc as, void arock)
131	{
132	struct rx_connection *aconn;
133	afs_uint32 server;
134	int i;
135	FILE fopen(), fp;
136	struct tc_restoreDesc *ptr;
137
138	server = GetServer(SERVERNAME);
139	if (!server) {
140	printf("cant get server id \n");
141	exit(1);
142	}
143	aconn = UV_Bind(server, TCPORT);
144	strcpy(tdumpSetName, "");
145	strcpy(tdumpSetName, "Test");
146	fp = fopen("restoreScr", "r");
147	fscanf(fp, "%u\n", &trestores.tc_restoreArray_len);
148	trestores.tc_restoreArray_val
149	= malloc(trestores.tc_restoreArray_len *
150	sizeof(struct tc_restoreDesc));
151	ptr = trestores.tc_restoreArray_val;
152	for (i = 0; i < trestores.tc_restoreArray_len; i++) {
153	fscanf(fp, "%s\n", ptr->oldName);
154	fscanf(fp, "%s\n", ptr->newName);
155	fscanf(fp, "%s\n", ptr->tapeName);
156	fscanf(fp, "%s\n", ptr->hostAddr);
157	fscanf(fp, "%u %u %u %u %d %u\n", &ptr->origVid, &ptr->vid,
158	&ptr->partition, &ptr->flags, &ptr->frag, &ptr->position);
159	ptr++;
160
161	}
162	code = TC_PerformRestore(aconn, tdumpSetName, &trestores, &tdumpID);
163	if (code) {
164	printf("call to TC_PerformRestore failed %u\n", code);
165	exit(1);
166	}
167	printf("dumpid returned %u\n", tdumpID);
168	return 0;
169	}
170
171	static int
172	CheckDump(struct cmd_syndesc as, void arock)
173	{
174	struct rx_connection *aconn;
175	afs_uint32 server;
176	server = GetServer(SERVERNAME);
177	if (!server) {
178	printf("cant get server id \n");
179	exit(1);
180	}
181	tdumpID = atol(as->parms[0].items->data);
182	aconn = UV_Bind(server, TCPORT);
183	code = TC_CheckDump(aconn, tdumpID, &tstatus);
184	if (code) {
185	printf("call to TC_CheckDump failed %u\n", code);
186	exit(1);
187	}
188	return 0;
189	}
190
191	static int
192	AbortDump(struct cmd_syndesc as, void arock)
193	{
194	struct rx_connection *aconn;
195	afs_uint32 server;
196	server = GetServer(SERVERNAME);
197	if (!server) {
198	printf("cant get server id \n");
199	exit(1);
200	}
201	tdumpID = atol(as->parms[0].items->data);
202	aconn = UV_Bind(server, TCPORT);
203	code = TC_AbortDump(aconn, tdumpID);
204	if (code) {
205	printf("call to TC_AbortDump failed %u\n", code);
206	exit(1);
207	}
208	return 0;
209	}
210
211	static int
212	WaitForDump(struct cmd_syndesc as, void arock)
213	{
214	struct rx_connection *aconn;
215	afs_uint32 server;
216	server = GetServer(SERVERNAME);
217	if (!server) {
218	printf("cant get server id \n");
219	exit(1);
220	}
221	tdumpID = atol(as->parms[0].items->data);
222	aconn = UV_Bind(server, TCPORT);
223	code = TC_WaitForDump(aconn, tdumpID);
224	if (code) {
225	printf("call to TC_WaitForDump failed %u\n", code);
226	exit(1);
227	}
228	return 0;
229	}
230
231	static int
232	EndDump(struct cmd_syndesc as, void arock)
233	{
234	struct rx_connection *aconn;
235	afs_uint32 server;
236	server = GetServer(SERVERNAME);
237	if (!server) {
238	printf("cant get server id \n");
239	exit(1);
240	}
241	tdumpID = atol(as->parms[0].items->data);
242	aconn = UV_Bind(server, TCPORT);
243	code = TC_EndDump(aconn, tdumpID);
244	if (code) {
245	printf("call to TC_EndDump failed %u\n", code);
246	exit(1);
247	}
248	return 0;
249	}
250
251	static int
252	MyBeforeProc(struct cmd_syndesc as, void arock)
253	{
254	afs_int32 code;
255
256	code = rx_Init(0);
257	if (code) {
258	printf("Could not initialize rx.\n");
259	return code;
260	}
261	rxInitDone = 1;
262	rx_SetRxDeadTime(50);
263	return 0;
264	}
265
266	#include "AFS_component_version_number.c"
267
268	main(argc, argv)
269	int argc;
270	char **argv;
271	{
272	afs_int32 code;
273
274	struct cmd_syndesc *ts;
275
276	#ifdef AFS_AIX32_ENV
277	/*
278	* The following signal action for AIX is necessary so that in case of a
279	* crash (i.e. core is generated) we can include the user's data section
280	* in the core dump. Unfortunately, by default, only a partial core is
281	* generated which, in many cases, isn't too useful.
282	*/
283	struct sigaction nsa;
284
285	sigemptyset(&nsa.sa_mask);
286	nsa.sa_handler = SIG_DFL;
287	nsa.sa_flags = SA_FULLDUMP;
288	sigaction(SIGABRT, &nsa, NULL);
289	sigaction(SIGSEGV, &nsa, NULL);
290	#endif
291	cmd_SetBeforeProc(MyBeforeProc, NULL);
292
293	ts = cmd_CreateSyntax("dump", PerformDump, NULL, 0, "perform a dump");
294
295	ts = cmd_CreateSyntax("restore", PerformRestore, NULL, 0, "perform a restore");
296
297	ts = cmd_CreateSyntax("check", CheckDump, NULL, 0, "check a dump");
298	cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
299
300	ts = cmd_CreateSyntax("abort", AbortDump, NULL, 0, "abort a dump");
301	cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
302
303	ts = cmd_CreateSyntax("wait", WaitForDump, NULL, 0, "wait for a dump");
304	cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
305
306	ts = cmd_CreateSyntax("end", EndDump, NULL, 0, "end a dump");
307	cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
308
309	code = cmd_Dispatch(argc, argv);
310	if (rxInitDone)
311	rx_Finalize();
312	exit(code);
313	}