/*
* 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 <afs/param.h>
#include <afsconfig.h>
+#include <afs/param.h>
+#include <afs/stds.h>
-RCSID("$Header$");
+#include <roken.h>
-#include <stdio.h>
-#ifdef AFS_NT40_ENV
-#include <winsock2.h>
-#else
-#include <netinet/in.h>
-#include <sys/file.h>
-#endif
-#include <sys/types.h>
-#include <afs/stds.h>
#include <afs/bubasics.h>
+#include <afs/afsutil.h>
#include <rx/xdr.h>
#include <rx/rx.h>
-#include <string.h>
+
#include "budb.h"
#include "budb_errs.h"
#include "database.h"
-
+#include "budb_internal.h"
+#include "budb_prototypes.h"
/* ----------------------------------
* structure printing utilities
* ----------------------------------
*/
-printDbHeader(ptr)
- struct DbHeader *ptr;
+void
+printDbHeader(struct DbHeader *ptr)
{
+ time_t created = ptr->created;
printf("version = %d\n", ptr->dbversion);
- printf("created = %s", ctime((time_t *)&ptr->created));
- printf("cell = %s\n",ptr->cell);
+ printf("created = %s", ctime(&created));
+ printf("cell = %s\n", ptr->cell);
printf("lastDumpId = %u\n", ptr->lastDumpId);
printf("lastInstanceId = %d\n", ptr->lastInstanceId);
printf("lastTapeId = %d\n", ptr->lastTapeId);
}
-printDump(fid, dptr)
- FILE *fid;
- struct dump *dptr;
-{
- fprintf(fid,"id = %u\n", dptr->id);
- fprintf(fid,"idHashChain = %d\n", dptr->idHashChain);
- fprintf(fid,"name = %s\n", dptr->dumpName);
- fprintf(fid,"vsname = %s\n", dptr->volumeSet);
- fprintf(fid,"dumpPath = %s\n", dptr->dumpPath);
- fprintf(fid,"nameHashChain = %d\n", dptr->nameHashChain);
- fprintf(fid,"flags = 0x%x\n", dptr->flags);
- fprintf(fid,"parent = %u\n", dptr->parent);
- fprintf(fid,"created = %s", ctime((time_t *)&dptr->created));
- fprintf(fid,"nVolumes = %d\n", dptr->nVolumes);
+void
+printDump(FILE *fid, struct dump *dptr)
+{
+ time_t created = dptr->created;
+ fprintf(fid, "id = %u\n", dptr->id);
+ fprintf(fid, "idHashChain = %d\n", dptr->idHashChain);
+ fprintf(fid, "name = %s\n", dptr->dumpName);
+ fprintf(fid, "vsname = %s\n", dptr->volumeSet);
+ fprintf(fid, "dumpPath = %s\n", dptr->dumpPath);
+ fprintf(fid, "nameHashChain = %d\n", dptr->nameHashChain);
+ fprintf(fid, "flags = 0x%x\n", dptr->flags);
+ fprintf(fid, "parent = %u\n", dptr->parent);
+ fprintf(fid, "created = %s", ctime(&created));
+ fprintf(fid, "nVolumes = %d\n", dptr->nVolumes);
/* printTapeSet(&dptr->tapes); */
- fprintf(fid,"firstTape = %d\n", dptr->firstTape);
+ fprintf(fid, "firstTape = %d\n", dptr->firstTape);
/* printKtcPrincipal(&dptr->dumper); */
}
-printDumpEntry(deptr)
- struct budb_dumpEntry *deptr;
+void
+printDumpEntry(struct budb_dumpEntry *deptr)
{
+ time_t created = deptr->created;
printf("id = %u\n", deptr->id);
printf("Initial id = %u\n", deptr->initialDumpID);
printf("Appended id = %u\n", deptr->appendedDumpID);
printf("parent = %u\n", deptr->parent);
printf("level = %d\n", deptr->level);
printf("flags = 0x%x", deptr->flags);
- if (deptr->flags == 0) printf(": Successful");
- if (deptr->flags & BUDB_DUMP_INCOMPLETE) printf(": Incomplete");
- if (deptr->flags & BUDB_DUMP_TAPEERROR) printf(": Tape error");
- if (deptr->flags & BUDB_DUMP_INPROGRESS) printf(": In progress");
- if (deptr->flags & BUDB_DUMP_ABORTED) printf(": Aborted");
- if (deptr->flags & BUDB_DUMP_ADSM) printf(": (ADSM)"); /* XBSA interface to ADSM */
- if (deptr->flags & BUDB_DUMP_BUTA) printf(": (BUTA)"); /* buta dump */
- printf("\n");
+ if (deptr->flags == 0)
+ printf(": Successful");
+ if (deptr->flags & BUDB_DUMP_INCOMPLETE)
+ printf(": Incomplete");
+ if (deptr->flags & BUDB_DUMP_TAPEERROR)
+ printf(": Tape error");
+ if (deptr->flags & BUDB_DUMP_INPROGRESS)
+ printf(": In progress");
+ if (deptr->flags & BUDB_DUMP_ABORTED)
+ printf(": Aborted");
+ if (deptr->flags & BUDB_DUMP_ADSM)
+ printf(": (ADSM)"); /* XBSA interface to ADSM */
+ if (deptr->flags & BUDB_DUMP_BUTA)
+ printf(": (BUTA)"); /* buta dump */
+ printf("\n");
printf("volumeSet = %s\n", deptr->volumeSetName);
printf("dump path = %s\n", deptr->dumpPath);
printf("name = %s\n", deptr->name);
- printf("created = %s", ctime((time_t *)&deptr->created));
+ printf("created = %s", ctime(&created));
printf("nVolumes = %d\n", deptr->nVolumes);
printTapeSet(&deptr->tapes, (deptr->flags & BUDB_DUMP_XBSA_NSS));
printPrincipal(&deptr->dumper);
}
-/* printHashTable
- * print the hash table structure, i.e. the header structure.
- */
-
-printHashTable(fid, htptr)
- FILE *fid;
- struct hashTable *htptr;
-{
- fprintf(fid,"functionType = %d\n", htptr->functionType);
- fprintf(fid,"threadOffset = %d\n", htptr->threadOffset);
- fprintf(fid,"entries = %d\n", htptr->entries);
- fprintf(fid,"length = %d\n", htptr->length);
- fprintf(fid,"table = %d\n", htptr->table);
- fprintf(fid,"progress = %d\n", htptr->progress);
- fprintf(fid,"oldLength = %d\n", htptr->oldLength);
- fprintf(fid,"oldTable = %d\n", htptr->oldTable);
-}
-
/* printMemoryHashTable
* print the hash table structure, i.e. the header structure.
*/
-printMemoryHashTable(fid, mhtptr)
- FILE *fid;
- struct memoryHashTable *mhtptr;
+int
+printMemoryHashTable(FILE *fid, struct memoryHashTable *mhtptr)
{
- fprintf(fid,"threadOffset = %d\n", mhtptr->threadOffset);
- fprintf(fid,"length = %d\n", mhtptr->length);
- fprintf(fid,"progress = %d\n", mhtptr->progress);
- fprintf(fid,"size = %d\n", mhtptr->size);
- fprintf(fid,"oldsize = %d\n", mhtptr->oldSize);
+ fprintf(fid, "threadOffset = %d\n", mhtptr->threadOffset);
+ fprintf(fid, "length = %d\n", mhtptr->length);
+ fprintf(fid, "progress = %d\n", mhtptr->progress);
+ fprintf(fid, "size = %d\n", mhtptr->size);
+ fprintf(fid, "oldsize = %d\n", mhtptr->oldSize);
+ return 0;
}
-printPrincipal(ptr)
- struct ktc_principal *ptr;
+int
+printPrincipal(struct budb_principal *ptr)
{
printf("name = %s\n", ptr->name);
printf("instance = %s\n", ptr->instance);
printf("cell = %s\n", ptr->cell);
+ return 0;
}
-printStructDumpHeader(ptr)
- struct structDumpHeader *ptr;
+int
+printStructDumpHeader(struct structDumpHeader *ptr)
{
printf("type = %d\n", ptr->type);
printf("structure version = %d\n", ptr->structversion);
printf("size = %d bytes\n", ptr->size);
+ return 0;
}
-printTape(fid, tptr)
- FILE *fid;
- struct tape *tptr;
+int
+printTape(FILE *fid, struct tape *tptr)
{
- fprintf(fid,"name = %s\n", tptr->name);
- fprintf(fid,"nameHashChain = %d\n", tptr->nameHashChain);
- fprintf(fid,"flags = 0x%x\n", tptr->flags);
- fprintf(fid,"written = %s", ctime((time_t *)&tptr->written));
- fprintf(fid,"nMBytes = %d\n", tptr->nMBytes);
- fprintf(fid,"nBytes = %d\n", tptr->nBytes);
- fprintf(fid,"nFiles = %d\n", tptr->nFiles);
- fprintf(fid,"nVolumes = %d\n", tptr->nVolumes);
- fprintf(fid,"seq = %d\n", tptr->seq);
- fprintf(fid,"dump = %d\n", tptr->dump);
- fprintf(fid,"nextTape = %d\n", tptr->nextTape);
- fprintf(fid,"firstVol = %d\n", tptr->firstVol);
- fprintf(fid,"labelPos = %d\n", tptr->labelpos);
- fprintf(fid,"useCount = %d\n", tptr->useCount);
+ time_t written = tptr->written;
+ fprintf(fid, "name = %s\n", tptr->name);
+ fprintf(fid, "nameHashChain = %d\n", tptr->nameHashChain);
+ fprintf(fid, "flags = 0x%x\n", tptr->flags);
+ fprintf(fid, "written = %s", ctime(&written));
+ fprintf(fid, "nMBytes = %d\n", tptr->nMBytes);
+ fprintf(fid, "nBytes = %d\n", tptr->nBytes);
+ fprintf(fid, "nFiles = %d\n", tptr->nFiles);
+ fprintf(fid, "nVolumes = %d\n", tptr->nVolumes);
+ fprintf(fid, "seq = %d\n", tptr->seq);
+ fprintf(fid, "dump = %d\n", tptr->dump);
+ fprintf(fid, "nextTape = %d\n", tptr->nextTape);
+ fprintf(fid, "firstVol = %d\n", tptr->firstVol);
+ fprintf(fid, "labelPos = %d\n", tptr->labelpos);
+ fprintf(fid, "useCount = %d\n", tptr->useCount);
+ return 0;
}
-printTapeEntry(teptr)
- struct budb_tapeEntry *teptr;
+int
+printTapeEntry(struct budb_tapeEntry *teptr)
{
+ time_t written = teptr->written;
+ time_t expires = teptr->expires;
+
printf("name = %s\n", teptr->name);
printf("flags = 0x%x", teptr->flags);
- if (teptr->flags & BUDB_TAPE_TAPEERROR) printf(": Error");
- if (teptr->flags & BUDB_TAPE_DELETED) printf(": Deleted");
- if (teptr->flags & BUDB_TAPE_BEINGWRITTEN) printf(": In progress");
- if (teptr->flags & BUDB_TAPE_ABORTED) printf(": Aborted");
- if (teptr->flags & BUDB_TAPE_STAGED) printf(": Staged");
- if (teptr->flags & BUDB_TAPE_WRITTEN) printf(": Successful");
- printf("\n");
- printf("written = %s", ctime((time_t *)&teptr->written));
- printf("expires = %s", cTIME((time_t *)&teptr->expires));
+ if (teptr->flags & BUDB_TAPE_TAPEERROR)
+ printf(": Error");
+ if (teptr->flags & BUDB_TAPE_DELETED)
+ printf(": Deleted");
+ if (teptr->flags & BUDB_TAPE_BEINGWRITTEN)
+ printf(": In progress");
+ if (teptr->flags & BUDB_TAPE_ABORTED)
+ printf(": Aborted");
+ if (teptr->flags & BUDB_TAPE_STAGED)
+ printf(": Staged");
+ if (teptr->flags & BUDB_TAPE_WRITTEN)
+ printf(": Successful");
+ printf("\n");
+ printf("written = %s", ctime(&written));
+ printf("expires = %s", cTIME(&expires));
printf("kBytes Tape Used = %u\n", teptr->useKBytes);
printf("nMBytes Data = %d\n", teptr->nMBytes);
printf("nBytes Data = %d\n", teptr->nBytes);
printf("labelPos = %d\n", teptr->labelpos);
printf("useCount = %d\n", teptr->useCount);
printf("dump = %d\n", teptr->dump);
+ return 0;
}
-printTapeSet(tsptr, nss)
- struct budb_tapeSet *tsptr;
- afs_int32 nss; /* is the tapeserver name an accurate name */
+int
+printTapeSet(struct budb_tapeSet *tsptr,
+ afs_int32 nss) /* is the tapeserver name an accurate name */
{
- printf("Group id = %d\n",tsptr->id );
- printf("tapeServer = %s%s\n",
- tsptr->tapeServer, (nss?" (single server)":""));
- printf("format = %s\n",tsptr->format);
- printf("maxTapes = %d\n",tsptr->maxTapes);
+ printf("Group id = %d\n", tsptr->id);
+ printf("tapeServer = %s%s\n", tsptr->tapeServer,
+ (nss ? " (single server)" : ""));
+ printf("format = %s\n", tsptr->format);
+ printf("maxTapes = %d\n", tsptr->maxTapes);
/* printf("a = %d\n",tsptr->a ); */
/* printf("b = %d\n",tsptr->b); */
- printf("Start Tape Seq = %d\n",tsptr->b);
+ printf("Start Tape Seq = %d\n", tsptr->b);
+ return 0;
}
-printVolumeEntry(veptr)
- struct budb_volumeEntry *veptr;
+int
+printVolumeEntry(struct budb_volumeEntry *veptr)
{
+ time_t clone = veptr->clone;
printf("name = %s\n", veptr->name);
printf("flags = 0x%x", veptr->flags);
- if (veptr->flags & BUDB_VOL_TAPEERROR) printf(": Tape Error");
- if (veptr->flags & BUDB_VOL_FILEERROR) printf(": File Error");
- if (veptr->flags & BUDB_VOL_BEINGWRITTEN) printf(": In progress");
- if (veptr->flags & BUDB_VOL_FIRSTFRAG) printf(": First fragment");
- if (veptr->flags & BUDB_VOL_LASTFRAG) printf(": Last fragment");
- if (veptr->flags & BUDB_VOL_ABORTED) printf(": Aborted");
- printf("\n");
+ if (veptr->flags & BUDB_VOL_TAPEERROR)
+ printf(": Tape Error");
+ if (veptr->flags & BUDB_VOL_FILEERROR)
+ printf(": File Error");
+ if (veptr->flags & BUDB_VOL_BEINGWRITTEN)
+ printf(": In progress");
+ if (veptr->flags & BUDB_VOL_FIRSTFRAG)
+ printf(": First fragment");
+ if (veptr->flags & BUDB_VOL_LASTFRAG)
+ printf(": Last fragment");
+ if (veptr->flags & BUDB_VOL_ABORTED)
+ printf(": Aborted");
+ printf("\n");
printf("id = %d\n", veptr->id);
printf("server = %s\n", veptr->server);
printf("partition = %d\n", veptr->partition);
printf("tapeSeq = %d\n", veptr->tapeSeq);
printf("position = %d\n", veptr->position);
- printf("clone = %s", ctime((time_t *)&veptr->clone));
+ printf("clone = %s", ctime(&clone));
printf("startByte = %d\n", veptr->startByte);
printf("nBytes = %d\n", veptr->nBytes);
printf("seq = %d\n", veptr->seq);
printf("dump = %d\n", veptr->dump);
printf("tape = %s\n", veptr->tape);
+ return 0;
+}
+
+int
+printVolFragment(FILE *fid, struct volFragment *vfptr)
+{
+ time_t clone = vfptr->clone;
+ time_t incTime = vfptr->incTime;
+ fprintf(fid, "vol = %d\n", vfptr->vol);
+ fprintf(fid, "sameNameChain = %d\n", vfptr->sameNameChain);
+ fprintf(fid, "tape = %d\n", vfptr->tape);
+ fprintf(fid, "sameTapeChain = %d\n", vfptr->sameTapeChain);
+ fprintf(fid, "position = %d\n", vfptr->position);
+ fprintf(fid, "clone = %s", ctime(&clone));
+ fprintf(fid, "incTime = %s", ctime(&incTime));
+ fprintf(fid, "startByte = %d\n", vfptr->startByte);
+ fprintf(fid, "nBytes = %d\n", vfptr->nBytes);
+ fprintf(fid, "flags = %d\n", vfptr->flags);
+ fprintf(fid, "sequence = %d\n", vfptr->sequence);
+ return 0;
}
-
-printVolFragment(fid, vfptr)
- FILE *fid;
- struct volFragment *vfptr;
-{
- fprintf(fid,"vol = %d\n", vfptr->vol);
- fprintf(fid,"sameNameChain = %d\n", vfptr->sameNameChain);
- fprintf(fid,"tape = %d\n", vfptr->tape);
- fprintf(fid,"sameTapeChain = %d\n", vfptr->sameTapeChain);
- fprintf(fid,"position = %d\n", vfptr->position);
- fprintf(fid,"clone = %s", ctime((time_t *)&vfptr->clone));
- fprintf(fid,"incTime = %s", ctime((time_t *)&vfptr->incTime));
- fprintf(fid,"startByte = %d\n", vfptr->startByte);
- fprintf(fid,"nBytes = %d\n", vfptr->nBytes);
- fprintf(fid,"flags = %d\n", vfptr->flags);
- fprintf(fid,"sequence = %d\n", vfptr->sequence);
-}
-
-printVolInfo(fid, viptr)
- FILE *fid;
- struct volInfo *viptr;
-{
- fprintf(fid,"name = %s\n", viptr->name);
- fprintf(fid,"nameHashChain = %d\n", viptr->nameHashChain);
- fprintf(fid,"id = %d\n", viptr->id);
- fprintf(fid,"server = %s\n", viptr->server);
- fprintf(fid,"partition = %d\n", viptr->partition);
- fprintf(fid,"flags = 0x%x\n", viptr->flags);
- fprintf(fid,"sameNameHead = %d\n", viptr->sameNameHead);
- fprintf(fid,"sameNameChain = %d\n", viptr->sameNameChain);
- fprintf(fid,"firstFragment = %d\n", viptr->firstFragment);
- fprintf(fid,"nFrags = %d\n", viptr->nFrags);
+
+int
+printVolInfo(FILE *fid, struct volInfo *viptr)
+{
+ fprintf(fid, "name = %s\n", viptr->name);
+ fprintf(fid, "nameHashChain = %d\n", viptr->nameHashChain);
+ fprintf(fid, "id = %d\n", viptr->id);
+ fprintf(fid, "server = %s\n", viptr->server);
+ fprintf(fid, "partition = %d\n", viptr->partition);
+ fprintf(fid, "flags = 0x%x\n", viptr->flags);
+ fprintf(fid, "sameNameHead = %d\n", viptr->sameNameHead);
+ fprintf(fid, "sameNameChain = %d\n", viptr->sameNameChain);
+ fprintf(fid, "firstFragment = %d\n", viptr->firstFragment);
+ fprintf(fid, "nFrags = %d\n", viptr->nFrags);
+ return 0;
}
/* -----------------------------------------
* structure xdr routines
- * -----------------------------------------
+ * -----------------------------------------
*/
/* utilities - network to host conversion
* currently used for debug only
*/
-volFragment_ntoh(netVfPtr, hostVfPtr)
- struct volFragment *netVfPtr, *hostVfPtr;
+void
+volFragment_ntoh(struct volFragment *netVfPtr,
+ struct volFragment *hostVfPtr)
{
hostVfPtr->vol = ntohl(netVfPtr->vol);
hostVfPtr->sameNameChain = ntohl(netVfPtr->sameNameChain);
hostVfPtr->sequence = ntohs(netVfPtr->sequence);
}
-volInfo_ntoh(netViPtr, hostViPtr)
- struct volInfo *netViPtr, *hostViPtr;
+void
+volInfo_ntoh(struct volInfo *netViPtr,
+ struct volInfo *hostViPtr)
{
strcpy(hostViPtr->name, netViPtr->name);
hostViPtr->nameHashChain = ntohl(netViPtr->nameHashChain);
hostViPtr->nFrags = ntohl(netViPtr->nFrags);
}
-tape_ntoh(netTapePtr, hostTapePtr)
- struct tape *netTapePtr, *hostTapePtr;
+void
+tape_ntoh(struct tape *netTapePtr,
+ struct tape *hostTapePtr)
{
strcpy(hostTapePtr->name, netTapePtr->name);
hostTapePtr->nameHashChain = ntohl(netTapePtr->nameHashChain);
hostTapePtr->useCount = ntohl(netTapePtr->useCount);
}
-dump_ntoh(netDumpPtr, hostDumpPtr)
- struct dump *netDumpPtr, *hostDumpPtr;
+void
+dump_ntoh(struct dump *netDumpPtr,
+ struct dump *hostDumpPtr)
{
- hostDumpPtr->id = ntohl(netDumpPtr->id);
+ hostDumpPtr->id = ntohl(netDumpPtr->id);
hostDumpPtr->idHashChain = ntohl(netDumpPtr->idHashChain);
- strcpy(hostDumpPtr->dumpName, netDumpPtr->dumpName);
- strcpy(hostDumpPtr->dumpPath, netDumpPtr->dumpPath);
- strcpy(hostDumpPtr->volumeSet, netDumpPtr->volumeSet);
+ strlcpy(hostDumpPtr->dumpName, netDumpPtr->dumpName,
+ sizeof(hostDumpPtr->dumpName));
+ strlcpy(hostDumpPtr->dumpPath, netDumpPtr->dumpPath,
+ sizeof(hostDumpPtr->dumpPath));
+ strlcpy(hostDumpPtr->volumeSet, netDumpPtr->volumeSet,
+ sizeof(hostDumpPtr->volumeSet));
hostDumpPtr->nameHashChain = ntohl(netDumpPtr->nameHashChain);
hostDumpPtr->flags = ntohl(netDumpPtr->flags);
hostDumpPtr->parent = ntohl(netDumpPtr->parent);
hostDumpPtr->firstTape = ntohl(netDumpPtr->firstTape);
- principal_ntoh(&netDumpPtr->dumper, &hostDumpPtr->dumper);
+ hostDumpPtr->dumper = netDumpPtr->dumper;
}
-DbHeader_ntoh(netptr, hostptr)
- struct DbHeader *netptr, *hostptr;
+void
+DbHeader_ntoh(struct DbHeader *netptr,
+ struct DbHeader *hostptr)
{
hostptr->dbversion = ntohl(netptr->dbversion);
hostptr->created = ntohl(netptr->created);
hostptr->lastTapeId = ntohl(netptr->lastTapeId);
}
-dumpEntry_ntoh(netptr, hostptr)
- struct budb_dumpEntry *netptr, *hostptr;
+void
+dumpEntry_ntoh(struct budb_dumpEntry *netptr,
+ struct budb_dumpEntry *hostptr)
{
hostptr->id = ntohl(netptr->id);
hostptr->initialDumpID = ntohl(netptr->initialDumpID);
principal_ntoh(&netptr->dumper, &hostptr->dumper);
}
-principal_hton(hostptr, netptr)
- struct ktc_principal *hostptr, *netptr;
+void
+principal_hton(struct budb_principal *hostptr,
+ struct budb_principal *netptr)
{
strcpy(netptr->name, hostptr->name);
strcpy(netptr->instance, hostptr->instance);
strcpy(netptr->cell, hostptr->cell);
}
-principal_ntoh(netptr, hostptr)
- struct ktc_principal *netptr, *hostptr;
+void
+principal_ntoh(struct budb_principal *netptr,
+ struct budb_principal *hostptr)
{
strcpy(hostptr->name, netptr->name);
strcpy(hostptr->instance, netptr->instance);
strcpy(hostptr->cell, netptr->cell);
}
-structDumpHeader_hton(hostPtr, netPtr)
- struct structDumpHeader *hostPtr, *netPtr;
+void
+structDumpHeader_hton(struct structDumpHeader *hostPtr,
+ struct structDumpHeader *netPtr)
{
netPtr->type = htonl(hostPtr->type);
netPtr->structversion = htonl(hostPtr->structversion);
netPtr->size = htonl(hostPtr->size);
}
-structDumpHeader_ntoh(netPtr, hostPtr)
- struct structDumpHeader *hostPtr, *netPtr;
+void
+structDumpHeader_ntoh(struct structDumpHeader *netPtr,
+ struct structDumpHeader *hostPtr)
{
hostPtr->type = ntohl(netPtr->type);
hostPtr->structversion = ntohl(netPtr->structversion);
hostPtr->size = ntohl(netPtr->size);
}
-tapeEntry_ntoh(netptr, hostptr)
- struct budb_tapeEntry *netptr, *hostptr;
+void
+tapeEntry_ntoh(struct budb_tapeEntry *netptr,
+ struct budb_tapeEntry *hostptr)
{
strcpy(hostptr->name, netptr->name);
hostptr->flags = ntohl(netptr->flags);
hostptr->dump = ntohl(netptr->dump);
}
-tapeSet_hton(hostptr, netptr)
- struct budb_tapeSet *hostptr, *netptr;
+int
+tapeSet_hton(struct budb_tapeSet *hostptr,
+ struct budb_tapeSet *netptr)
{
netptr->id = htonl(hostptr->id);
- strcpy(netptr->tapeServer, hostptr->tapeServer);
- strcpy(netptr->format, hostptr->format);
+ strcpy(netptr->tapeServer, hostptr->tapeServer);
+ strcpy(netptr->format, hostptr->format);
netptr->maxTapes = htonl(hostptr->maxTapes);
netptr->a = htonl(hostptr->a);
netptr->b = htonl(hostptr->b);
+ return 0;
}
-tapeSet_ntoh(netptr, hostptr)
- struct budb_tapeSet *netptr, *hostptr;
+int
+tapeSet_ntoh(struct budb_tapeSet *netptr,
+ struct budb_tapeSet *hostptr)
{
hostptr->id = ntohl(netptr->id);
- strcpy(hostptr->tapeServer, netptr->tapeServer);
- strcpy(hostptr->format, netptr->format);
+ strcpy(hostptr->tapeServer, netptr->tapeServer);
+ strcpy(hostptr->format, netptr->format);
hostptr->maxTapes = ntohl(netptr->maxTapes);
hostptr->a = ntohl(netptr->a);
hostptr->b = ntohl(netptr->b);
+ return 0;
}
-textBlock_hton(hostptr, netptr)
- struct textBlock *hostptr, *netptr;
+void
+textBlock_hton(struct textBlock *hostptr,
+ struct textBlock *netptr)
{
netptr->version = htonl(hostptr->version);
netptr->size = htonl(hostptr->size);
netptr->newTextAddr = htonl(hostptr->newTextAddr);
}
-textBlock_ntoh(netptr, hostptr)
- struct textBlock *netptr, *hostptr;
+void
+textBlock_ntoh(struct textBlock *netptr,
+ struct textBlock *hostptr)
{
hostptr->version = ntohl(netptr->version);
hostptr->size = ntohl(netptr->size);
hostptr->newTextAddr = ntohl(netptr->newTextAddr);
}
-textLock_hton(hostptr, netptr)
- db_lockP hostptr, netptr;
+void
+textLock_hton(db_lockP hostptr, db_lockP netptr)
{
netptr->type = htonl(hostptr->type);
netptr->lockState = htonl(hostptr->lockState);
netptr->lockHost = htonl(hostptr->lockHost);
}
-textLock_ntoh(netptr, hostptr)
- db_lockP netptr, hostptr;
+void
+textLock_ntoh(db_lockP netptr, db_lockP hostptr)
{
hostptr->type = ntohl(netptr->type);
hostptr->lockState = ntohl(netptr->lockState);
hostptr->lockHost = ntohl(netptr->lockHost);
}
-volumeEntry_ntoh(netptr, hostptr)
- struct budb_volumeEntry *netptr, *hostptr;
+void
+volumeEntry_ntoh(struct budb_volumeEntry *netptr,
+ struct budb_volumeEntry *hostptr)
{
strcpy(hostptr->name, netptr->name);
hostptr->flags = ntohl(netptr->flags);
hostptr->partition = ntohl(netptr->partition);
hostptr->tapeSeq = ntohl(netptr->tapeSeq);
- hostptr->position = ntohl(netptr->position);
+ hostptr->position = ntohl(netptr->position);
hostptr->clone = ntohl(netptr->clone);
hostptr->incTime = ntohl(netptr->incTime);
hostptr->startByte = ntohl(netptr->startByte);
}
/* -------------------------------------
- * structure conversion & copy routines
+ * structure conversion & copy routines
* -------------------------------------
*/
-
-copy_ktcPrincipal_to_budbPrincipal(ktcPtr, budbPtr)
- struct ktc_principal *ktcPtr;
- struct budb_principal *budbPtr;
+void
+copy_ktcPrincipal_to_budbPrincipal(struct ktc_principal *ktcPtr,
+ struct budb_principal *budbPtr)
{
strncpy(budbPtr->name, ktcPtr->name, sizeof(budbPtr->name));
strncpy(budbPtr->instance, ktcPtr->instance, sizeof(budbPtr->instance));
* dumpPtr - host format
*/
-dumpToBudbDump(dumpPtr, budbDumpPtr)
- dbDumpP dumpPtr;
- struct budb_dumpEntry *budbDumpPtr;
+int
+dumpToBudbDump(dbDumpP dumpPtr, struct budb_dumpEntry *budbDumpPtr)
{
budbDumpPtr->id = dumpPtr->id;
budbDumpPtr->initialDumpID = dumpPtr->initialDumpID;
budbDumpPtr->created = dumpPtr->created;
budbDumpPtr->nVolumes = dumpPtr->nVolumes;
- bcopy(&dumpPtr->tapes, &budbDumpPtr->tapes, sizeof(struct budb_tapeSet));
- copy_ktcPrincipal_to_budbPrincipal(&dumpPtr->dumper, &budbDumpPtr->dumper);
- return(0);
+ memcpy(&budbDumpPtr->tapes, &dumpPtr->tapes, sizeof(struct budb_tapeSet));
+ copy_ktcPrincipal_to_budbPrincipal(&dumpPtr->dumper,
+ &budbDumpPtr->dumper);
+ return (0);
}
-tapeToBudbTape(tapePtr, budbTapePtr)
- struct tape *tapePtr;
- struct budb_tapeEntry *budbTapePtr;
+int
+tapeToBudbTape(struct tape *tapePtr, struct budb_tapeEntry *budbTapePtr)
{
strcpy(budbTapePtr->name, tapePtr->name);
budbTapePtr->flags = tapePtr->flags;
budbTapePtr->labelpos = tapePtr->labelpos;
budbTapePtr->useCount = tapePtr->useCount;
budbTapePtr->useKBytes = tapePtr->useKBytes;
- return(0);
+ return (0);
}
-volsToBudbVol(volFragPtr, volInfoPtr, budbVolPtr)
- struct volFragment *volFragPtr;
- struct volInfo *volInfoPtr;
- struct budb_volumeEntry *budbVolPtr;
+int
+volsToBudbVol(struct volFragment *volFragPtr, struct volInfo *volInfoPtr,
+ struct budb_volumeEntry *budbVolPtr)
{
strcpy(budbVolPtr->name, volInfoPtr->name);
budbVolPtr->flags = volInfoPtr->flags;
budbVolPtr->id = volInfoPtr->id;
strcpy(budbVolPtr->server, volInfoPtr->server);
budbVolPtr->partition = volInfoPtr->partition;
- budbVolPtr->tapeSeq = 0; /* Don't know it so mark invalid */
+ budbVolPtr->tapeSeq = 0; /* Don't know it so mark invalid */
budbVolPtr->position = volFragPtr->position;
budbVolPtr->clone = volFragPtr->clone;
budbVolPtr->startByte = volFragPtr->startByte;
budbVolPtr->nBytes = volFragPtr->nBytes;
budbVolPtr->seq = volFragPtr->sequence;
- return(0);
+ return (0);
}
/* ----------------------------------
- * structure initialization routines
+ * structure initialization routines
* ---------------------------------
*/
* n - error
*/
-default_tapeset(tapesetPtr, dumpname)
- struct budb_tapeSet *tapesetPtr;
- char *dumpname;
+int
+default_tapeset(struct budb_tapeSet *tapesetPtr, char *dumpname)
{
- bzero(tapesetPtr, sizeof(*tapesetPtr));
+ memset(tapesetPtr, 0, sizeof(*tapesetPtr));
strcpy(tapesetPtr->format, dumpname);
strcat(tapesetPtr->format, ".%d");
tapesetPtr->a = 1;
tapesetPtr->b = 1;
tapesetPtr->maxTapes = 0;
+ return 0;
}
git://git.openafs.org / openafs.git / blobdiff