[hcoop/debian/openafs.git] / src / bucoord / dsstub.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
 */

/*
 * ALL RIGHTS RESERVED
 */

#include <afsconfig.h>
#include <afs/param.h>

#include <roken.h>

#include <afs/cmd.h>
#include <afs/afsutil.h>
#include <afs/budb.h>
#include <afs/bubasics.h>
#include <afs/afsint.h>
#include <afs/volser.h>

#include "bc.h"

/* protos */

static char * TapeName(char *);
static char * DumpName(afs_int32 adumpID);
static FILE * OpenDump(afs_int32 , char * );
FILE * OpenTape(char * , char * );
static afs_int32 ScanForChildren(afs_int32 );
static afs_int32 DeleteDump(afs_int32 );
char * tailCompPtr(char *);
afs_int32 ScanDumpHdr(FILE *, char *, char *, afs_int32 *, afs_int32 *,
  afs_int32 *, afs_int32 *);
afs_int32 ScanTapeVolume(FILE *, char *, afs_int32 *, char *, afs_int32 *, afs_int32 *,
   afs_int32 *, afs_int32 *);
afs_int32 ScanVolClone(FILE *, char *, afs_int32 *);


/* basic format of a tape file is a file, whose name is "T<tapename>.db", and
 * which contains the fields
 * (afs_int32) dumpID, (afs_int32) tape-sequence-within-dump, (afs_int32) damage_flag
 * all as space-separated integers.
 */

/* The format of a dump file is:
 * a file whose name is "D<dump#>.db"
 * and whose contents are a header line:
 * (string) dumpName, (long) parent-id, (long) incTime, (long) dumpEndTime, (long) level
 * and a bunch of bcdb_volumeEntries with this format:
 * (string) volume name, (long) volume ID, (string) tape name, (long) position-on-tape,
 *     (long) sequence-in-volume-dump, (long) is-this-the-last-vol-frag, (long) incTime
 * again, all space-separated.
 * Note that dumpEndTime is stored and returned in the dump creation time field.
 */

/* return the tape file name corresponding to a particular tape */

static char * TapeName(char *atapeName)
{
    char *tbuffer;

    if (asprintf(&tbuffer, "%s/T%s.db", AFSDIR_SERVER_BACKUP_DIRPATH,
		 atapeName) < 0)
	return NULL;
    return tbuffer;
}

/* return the dump file name corresponding to a particular dump ID */

static char * DumpName(afs_int32 adumpID)
{
    char *tbuffer;

    if (asprintf(&tbuffer, "%s/D%d.db", AFSDIR_SERVER_BACKUP_DIRPATH,
		 adumpID) < 0)
	return NULL;
    return tbuffer;
}

static FILE * OpenDump(afs_int32 adumpID, char * awrite)
{
    char *tp;
    FILE *tfile;

    tp = DumpName(adumpID);
    if (tp == NULL)
	return NULL;
    tfile = fopen(tp, awrite);
    free(tp);
    return tfile;
}

/* OpenTape
 * notes:
 * 	non-static for recoverDB
 */

FILE * OpenTape(char * atapeName, char * awrite)
{
    char *tp;
    FILE *tfile;

    tp = TapeName(atapeName);
    if (tp == NULL)
	return NULL;
    tfile = fopen(tp, awrite);
    free(tp);
    return tfile;
}

/* scan for, and delete, all dumps whose parent dump ID is aparentID */

static afs_int32 ScanForChildren(afs_int32 aparentID)
{
    DIR *tdir;
    struct dirent *tde;
    afs_int32 dumpID, parent;
    FILE *tfile;
    afs_int32 code;
    afs_int32 j2, j3, j4;
    char dname[256];
    char dumpName[1024];

    tdir = opendir(AFSDIR_SERVER_BACKUP_DIRPATH);
    if (!tdir)
	return -1;

    for (tde = readdir(tdir); tde; tde = readdir(tdir)) {
	code = sscanf(tde->d_name, "D%ld.db", (long int *) &dumpID);
	if (code != 1)
	    continue;

	tfile = OpenDump(dumpID, "r");
	if (!tfile)
	    continue;		/* shouldn't happen, but should continue anyway */

	code = ScanDumpHdr(tfile, dname, dumpName, &parent, &j2, &j3, &j4);
	fclose(tfile);
	if (code) {
	    printf("backup:dsstub: bad dump header for dump %d\n", dumpID);
	    continue;
	}

	/* if this guy's parent is the ID we're scanning for, delete it */
	if (aparentID == parent) {
	    code = DeleteDump(dumpID);
	    if (code)
		printf("backup:dsstub: failed to delete child dump %d\n",
		       dumpID);
	}
    }
    closedir(tdir);
    return 0;
}

static afs_int32 DeleteDump(afs_int32 adumpID)
{
    char *tp;
    afs_int32 code;

    tp = DumpName(adumpID);
    if (tp == NULL)
	return ENOMEM;
    code = unlink(tp);
    free(tp);
    if (code)
	return code;
    code = ScanForChildren(adumpID);
    return code;
}

#if 0
static afs_int32 DeleteTape(char * atapeName)
{
    char *tp;
    afs_int32 code;

    tp = TapeName(atapeName);
    if (tp == NULL)
	return ENOMEM;
    code = unlink(tp);
    free(tp);
    return code;
}
#endif

/* tailCompPtr
 *	name is a pathname style name, determine trailing name and return
 *	pointer to it
 */

char *
tailCompPtr(char *pathNamePtr)
{
    char *ptr;
    ptr = strrchr(pathNamePtr, '/');
    if (ptr == 0) {
	/* this should never happen */
	printf("tailCompPtr: could not find / in name(%s)\n", pathNamePtr);
	return (pathNamePtr);
    } else
	ptr++;			/* skip the / */
    return (ptr);
}

/* ScanDumpHdr
 *	scan a dump header out of a dump file, leaving the file ptr set after
 *	the header.
 * entry:
 *	afile - ptr to file, for reading.
 *	various - ptrs for return values
 * exit:
 *	aname - string of form volume_set.dump_level
 *	dumpName - pathname of dump schedule node
 *	aparent - id of parent
 *	aincTime
 *	acreateTime - time at which dump was created
 *	alevel - level of dump (0 = full, 1+ are incrementals)
 */
afs_int32
ScanDumpHdr(FILE *afile, char *aname, char *dumpName, afs_int32 *aparent, afs_int32 *aincTime, afs_int32 *acreateTime, afs_int32 *alevel)
{
    char tbuffer[256];
    char *tp;
    afs_int32 dbmagic, dbversion;
    afs_int32 code;

    tp = fgets(tbuffer, sizeof(tbuffer), afile);
    if (!tp)
	return -1;
    code =
	sscanf(tbuffer, "%d %d %s %s %ld %ld %ld %ld", &dbmagic, &dbversion,
	       aname, dumpName, (long int *) aparent, (long int *) aincTime,
	       (long int *) acreateTime, (long int *) alevel);
    if (code != 8)
	return -1;

    /* now check the magic and version numbers */
    if ((dbmagic != BC_DUMPDB_MAGIC) || (dbversion != BC_DUMPDB_VERSION))
	return (-1);

    return 0;
}

#if 0
/* scan a tape header out of a tape file, leaving the file ptr positioned just past the header */
static afs_int32 ScanTapeHdr(FILE *afile, afs_int32 *adumpID, afs_int32 *aseq, afs_int32 *adamage)
{
    char tbuffer[256];
    char *tp;
    afs_int32 code;

    tp = fgets(tbuffer, sizeof(tbuffer), afile);
    if (!tp)
	return -1;
    code = sscanf(tbuffer, "%ld %ld %ld", (long int *)adumpID,
		  (long int *)aseq, (long int *)adamage);
    if (code != 3)
	return -1;
    return 0;
}
#endif

/* ScanTapeVolume
 *	scan a tape volume record from a dump file, leaving the file ptr
 *	positioned past the just-scanned record.
 * exit:
 *	0 - success
 *	1 - EOF
 *	-1 for error
 */

afs_int32 ScanTapeVolume(FILE *afile, char *avolName, afs_int32 *avolID, char *atapeName, afs_int32 *apos, afs_int32 *aseq, afs_int32 *alastp, afs_int32 *cloneTime)
{
    char tbuffer[256];
    afs_int32 code;
    char *tp;

    tp = fgets(tbuffer, sizeof(tbuffer), afile);
    if (!tp) {			/* something went wrong, or eof hit */
	if (ferror(afile))
	    return -1;		/* error occurred */
	else
	    return 1;		/* eof */
    }
    code =
	sscanf(tbuffer, "%s %ld %s %ld %ld %ld %ld", avolName,
	       (long int *) avolID, atapeName, (long int *)apos,
	       (long int *) aseq, (long int *) alastp,
	       (long int *) cloneTime);
    if (code != 7)
	return -1;		/* bad input line */
    return 0;
}

/* ScanVolClone
 *	Search the dump for the volume with name volName, and return it's
 *	clone time.
 * exit:
 *	0 - clonetime set.
 *	-1 - volume with volName not found
 */

afs_int32 ScanVolClone(FILE *tdump, char *volName, afs_int32 *cloneTime)
{
    char avolName[256], atapeName[256];
    afs_int32 retval, avolID, apos, aseq, alastp;

    retval =
	ScanTapeVolume(tdump, &avolName[0], &avolID, &atapeName[0], &apos,
		       &aseq, &alastp, cloneTime);
    while (retval == 0) {
	if (strcmp(avolName, volName) == 0)
	    return (0);
	retval =
	    ScanTapeVolume(tdump, &avolName[0], &avolID, &atapeName[0], &apos,
			   &aseq, &alastp, cloneTime);
    }
    return (-1);
}

#if 0
/* seek a dump file (after a header scan has been done) to position apos */
static int SeekDump(FILE *afile, afs_int32 apos)
{
    afs_int32 i;
    char *tp;
    char tbuffer[256];

    /* now skip to appropriate position */
    for (i = 0; i < apos; i++) {
	tp = fgets(tbuffer, sizeof(tbuffer), afile);
	if (!tp) {
	    fclose(afile);
	    return -1;
	}
    }
    return 0;
}
#endif
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
	10	/*
	11	* ALL RIGHTS RESERVED
	12	*/
	13
	14	#include <afsconfig.h>
	15	#include <afs/param.h>
	16
	17	#include <roken.h>
	18
	19	#include <afs/cmd.h>
	20	#include <afs/afsutil.h>
	21	#include <afs/budb.h>
	22	#include <afs/bubasics.h>
	23	#include <afs/afsint.h>
	24	#include <afs/volser.h>
	25
	26	#include "bc.h"
	27
	28	/* protos */
	29
	30	static char * TapeName(char *);
	31	static char * DumpName(afs_int32 adumpID);
	32	static FILE * OpenDump(afs_int32 , char * );
	33	FILE * OpenTape(char * , char * );
	34	static afs_int32 ScanForChildren(afs_int32 );
	35	static afs_int32 DeleteDump(afs_int32 );
	36	char * tailCompPtr(char *);
	37	afs_int32 ScanDumpHdr(FILE , char , char , afs_int32 , afs_int32 *,
	38	afs_int32 , afs_int32 );
	39	afs_int32 ScanTapeVolume(FILE , char , afs_int32 , char , afs_int32 , afs_int32 ,
	40	afs_int32 , afs_int32 );
	41	afs_int32 ScanVolClone(FILE , char , afs_int32 *);
	42
	43
	44	/* basic format of a tape file is a file, whose name is "T<tapename>.db", and
	45	* which contains the fields
	46	* (afs_int32) dumpID, (afs_int32) tape-sequence-within-dump, (afs_int32) damage_flag
	47	* all as space-separated integers.
	48	*/
	49
	50	/* The format of a dump file is:
	51	* a file whose name is "D<dump#>.db"
	52	* and whose contents are a header line:
	53	* (string) dumpName, (long) parent-id, (long) incTime, (long) dumpEndTime, (long) level
	54	* and a bunch of bcdb_volumeEntries with this format:
	55	* (string) volume name, (long) volume ID, (string) tape name, (long) position-on-tape,
	56	* (long) sequence-in-volume-dump, (long) is-this-the-last-vol-frag, (long) incTime
	57	* again, all space-separated.
	58	* Note that dumpEndTime is stored and returned in the dump creation time field.
	59	*/
	60
	61	/* return the tape file name corresponding to a particular tape */
	62
	63	static char * TapeName(char *atapeName)
	64	{
65	char *tbuffer;
66
67	if (asprintf(&tbuffer, "%s/T%s.db", AFSDIR_SERVER_BACKUP_DIRPATH,
68	atapeName) < 0)
69	return NULL;
70	return tbuffer;
71	}
72
73	/* return the dump file name corresponding to a particular dump ID */
74
75	static char * DumpName(afs_int32 adumpID)
76	{
77	char *tbuffer;
78
79	if (asprintf(&tbuffer, "%s/D%d.db", AFSDIR_SERVER_BACKUP_DIRPATH,
80	adumpID) < 0)
81	return NULL;
82	return tbuffer;
83	}
84
85	static FILE * OpenDump(afs_int32 adumpID, char * awrite)
86	{
87	char *tp;
88	FILE *tfile;
89
90	tp = DumpName(adumpID);
91	if (tp == NULL)
92	return NULL;
93	tfile = fopen(tp, awrite);
94	free(tp);
95	return tfile;
96	}
97
98	/* OpenTape
99	* notes:
100	* non-static for recoverDB
101	*/
102
103	FILE * OpenTape(char * atapeName, char * awrite)
104	{
105	char *tp;
106	FILE *tfile;
107
108	tp = TapeName(atapeName);
109	if (tp == NULL)
110	return NULL;
111	tfile = fopen(tp, awrite);
112	free(tp);
113	return tfile;
114	}
115
116	/* scan for, and delete, all dumps whose parent dump ID is aparentID */
117
118	static afs_int32 ScanForChildren(afs_int32 aparentID)
119	{
120	DIR *tdir;
121	struct dirent *tde;
122	afs_int32 dumpID, parent;
123	FILE *tfile;
124	afs_int32 code;
125	afs_int32 j2, j3, j4;
126	char dname[256];
127	char dumpName[1024];
128
129	tdir = opendir(AFSDIR_SERVER_BACKUP_DIRPATH);
130	if (!tdir)
131	return -1;
132
133	for (tde = readdir(tdir); tde; tde = readdir(tdir)) {
134	code = sscanf(tde->d_name, "D%ld.db", (long int *) &dumpID);
135	if (code != 1)
136	continue;
137
138	tfile = OpenDump(dumpID, "r");
139	if (!tfile)
140	continue; /* shouldn't happen, but should continue anyway */
141
142	code = ScanDumpHdr(tfile, dname, dumpName, &parent, &j2, &j3, &j4);
143	fclose(tfile);
144	if (code) {
145	printf("backup:dsstub: bad dump header for dump %d\n", dumpID);
146	continue;
147	}
148
149	/* if this guy's parent is the ID we're scanning for, delete it */
150	if (aparentID == parent) {
151	code = DeleteDump(dumpID);
152	if (code)
153	printf("backup:dsstub: failed to delete child dump %d\n",
154	dumpID);
155	}
156	}
157	closedir(tdir);
158	return 0;
159	}
160
161	static afs_int32 DeleteDump(afs_int32 adumpID)
162	{
163	char *tp;
164	afs_int32 code;
165
166	tp = DumpName(adumpID);
167	if (tp == NULL)
168	return ENOMEM;
169	code = unlink(tp);
170	free(tp);
171	if (code)
172	return code;
173	code = ScanForChildren(adumpID);
174	return code;
175	}
176
177	#if 0
178	static afs_int32 DeleteTape(char * atapeName)
179	{
180	char *tp;
181	afs_int32 code;
182
183	tp = TapeName(atapeName);
184	if (tp == NULL)
185	return ENOMEM;
186	code = unlink(tp);
187	free(tp);
188	return code;
189	}
190	#endif
191
192	/* tailCompPtr
193	* name is a pathname style name, determine trailing name and return
194	* pointer to it
195	*/
196
197	char *
198	tailCompPtr(char *pathNamePtr)
199	{
200	char *ptr;
201	ptr = strrchr(pathNamePtr, '/');
202	if (ptr == 0) {
203	/* this should never happen */
204	printf("tailCompPtr: could not find / in name(%s)\n", pathNamePtr);
205	return (pathNamePtr);
206	} else
207	ptr++; /* skip the / */
208	return (ptr);
209	}
210
211	/* ScanDumpHdr
212	* scan a dump header out of a dump file, leaving the file ptr set after
213	* the header.
214	* entry:
215	* afile - ptr to file, for reading.
216	* various - ptrs for return values
217	* exit:
218	* aname - string of form volume_set.dump_level
219	* dumpName - pathname of dump schedule node
220	* aparent - id of parent
221	* aincTime
222	* acreateTime - time at which dump was created
223	* alevel - level of dump (0 = full, 1+ are incrementals)
224	*/
225	afs_int32
226	ScanDumpHdr(FILE afile, char aname, char dumpName, afs_int32 aparent, afs_int32 aincTime, afs_int32 acreateTime, afs_int32 *alevel)
227	{
228	char tbuffer[256];
229	char *tp;
230	afs_int32 dbmagic, dbversion;
231	afs_int32 code;
232
233	tp = fgets(tbuffer, sizeof(tbuffer), afile);
234	if (!tp)
235	return -1;
236	code =
237	sscanf(tbuffer, "%d %d %s %s %ld %ld %ld %ld", &dbmagic, &dbversion,
238	aname, dumpName, (long int ) aparent, (long int ) aincTime,
239	(long int ) acreateTime, (long int ) alevel);
240	if (code != 8)
241	return -1;
242
243	/* now check the magic and version numbers */
244	if ((dbmagic != BC_DUMPDB_MAGIC) \|\| (dbversion != BC_DUMPDB_VERSION))
245	return (-1);
246
247	return 0;
248	}
249
250	#if 0
251	/* scan a tape header out of a tape file, leaving the file ptr positioned just past the header */
252	static afs_int32 ScanTapeHdr(FILE afile, afs_int32 adumpID, afs_int32 aseq, afs_int32 adamage)
253	{
254	char tbuffer[256];
255	char *tp;
256	afs_int32 code;
257
258	tp = fgets(tbuffer, sizeof(tbuffer), afile);
259	if (!tp)
260	return -1;
261	code = sscanf(tbuffer, "%ld %ld %ld", (long int *)adumpID,
262	(long int )aseq, (long int )adamage);
263	if (code != 3)
264	return -1;
265	return 0;
266	}
267	#endif
268
269	/* ScanTapeVolume
270	* scan a tape volume record from a dump file, leaving the file ptr
271	* positioned past the just-scanned record.
272	* exit:
273	* 0 - success
274	* 1 - EOF
275	* -1 for error
276	*/
277
278	afs_int32 ScanTapeVolume(FILE afile, char avolName, afs_int32 avolID, char atapeName, afs_int32 apos, afs_int32 aseq, afs_int32 alastp, afs_int32 cloneTime)
279	{
280	char tbuffer[256];
281	afs_int32 code;
282	char *tp;
283
284	tp = fgets(tbuffer, sizeof(tbuffer), afile);
285	if (!tp) { /* something went wrong, or eof hit */
286	if (ferror(afile))
287	return -1; /* error occurred */
288	else
289	return 1; /* eof */
290	}
291	code =
292	sscanf(tbuffer, "%s %ld %s %ld %ld %ld %ld", avolName,
293	(long int ) avolID, atapeName, (long int )apos,
294	(long int ) aseq, (long int ) alastp,
295	(long int *) cloneTime);
296	if (code != 7)
297	return -1; /* bad input line */
298	return 0;
299	}
300
301	/* ScanVolClone
302	* Search the dump for the volume with name volName, and return it's
303	* clone time.
304	* exit:
305	* 0 - clonetime set.
306	* -1 - volume with volName not found
307	*/
308
309	afs_int32 ScanVolClone(FILE tdump, char volName, afs_int32 *cloneTime)
310	{
311	char avolName[256], atapeName[256];
312	afs_int32 retval, avolID, apos, aseq, alastp;
313
314	retval =
315	ScanTapeVolume(tdump, &avolName[0], &avolID, &atapeName[0], &apos,
316	&aseq, &alastp, cloneTime);
317	while (retval == 0) {
318	if (strcmp(avolName, volName) == 0)
319	return (0);
320	retval =
321	ScanTapeVolume(tdump, &avolName[0], &avolID, &atapeName[0], &apos,
322	&aseq, &alastp, cloneTime);
323	}
324	return (-1);
325	}
326
327	#if 0
328	/* seek a dump file (after a header scan has been done) to position apos */
329	static int SeekDump(FILE *afile, afs_int32 apos)
330	{
331	afs_int32 i;
332	char *tp;
333	char tbuffer[256];
334
335	/* now skip to appropriate position */
336	for (i = 0; i < apos; i++) {
337	tp = fgets(tbuffer, sizeof(tbuffer), afile);
338	if (!tp) {
339	fclose(afile);
340	return -1;
341	}
342	}
343	return 0;
344	}
345	#endif