/* Interface and supporting routines for the backup system's ubik database */
#include <afsconfig.h>
-#include <afs/param.h>
+#include <afs/stds.h>
RCSID
("$Header$");
-#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#ifdef AFS_NT40_ENV
#include <afs/bubasics.h>
#include <afs/budb_client.h>
#include <afs/budb.h>
+#include <afs/com_err.h>
#include <errno.h>
#include "bc.h"
#include "error_macros.h"
+/* protos */
+afs_int32 bcdb_AddVolume(register struct budb_volumeEntry *);
+afs_int32 bcdb_AddVolumes(register struct budb_volumeEntry *, afs_int32 );
+afs_int32 bcdb_CreateDump(register struct budb_dumpEntry *) ;
+afs_int32 bcdb_deleteDump(afs_int32, afs_int32, afs_int32, budb_dumpsList *);
+/*note the pinter to the function comes from ubik/ubikclient ubik_Call function.*/
+afs_int32 bcdb_listDumps (afs_int32, afs_int32,afs_int32,afs_int32, budb_dumpsList *,
+ budb_dumpsList *);
+afs_int32 bcdb_DeleteVDP(char *, char *, afs_int32 );
+afs_int32 bcdb_FindClone(afs_int32, char *, afs_int32 *);
+
extern char *whoami;
/* -------------------------------------
* -------------------------------------
*/
-bcdb_AddVolume(veptr)
- register struct budb_volumeEntry *veptr;
+afs_int32 bcdb_AddVolume(register struct budb_volumeEntry *veptr)
{
afs_int32 code;
- code = ubik_Call(BUDB_AddVolume, udbHandle.uh_client, 0, veptr);
+ code = ubik_BUDB_AddVolume(udbHandle.uh_client, 0, veptr);
return (code);
}
-bcdb_AddVolumes(veptr, count)
- register struct budb_volumeEntry *veptr;
- afs_int32 count;
+afs_int32 bcdb_AddVolumes(register struct budb_volumeEntry *veptr, afs_int32 count)
{
struct budb_volumeList volumeList;
afs_int32 code;
volumeList.budb_volumeList_len = count;
volumeList.budb_volumeList_val = veptr;
- code = ubik_Call(BUDB_AddVolumes, udbHandle.uh_client, 0, &volumeList);
+ code = ubik_BUDB_AddVolumes(udbHandle.uh_client, 0, &volumeList);
return (code);
}
-bcdb_CreateDump(deptr)
- register struct budb_dumpEntry *deptr;
+afs_int32 bcdb_CreateDump(register struct budb_dumpEntry *deptr)
{
afs_int32 code;
- code = ubik_Call(BUDB_CreateDump, udbHandle.uh_client, 0, deptr);
+ code = ubik_BUDB_CreateDump(udbHandle.uh_client, 0, deptr);
return (code);
}
-bcdb_deleteDump(dumpID, fromTime, toTime, dumps)
- afs_int32 dumpID;
- afs_int32 fromTime;
- afs_int32 toTime;
- budb_dumpsList *dumps;
+afs_int32 bcdb_deleteDump(afs_int32 dumpID, afs_int32 fromTime, afs_int32 toTime,
+ budb_dumpsList *dumps)
{
afs_int32 code;
budb_dumpsList dumpsList, *dumpsPtr;
dumpsPtr = (dumps ? dumps : &dumpsList);
code =
- ubik_Call(BUDB_DeleteDump, udbHandle.uh_client, 0, dumpID, fromTime,
+ ubik_BUDB_DeleteDump(udbHandle.uh_client, 0, dumpID, fromTime,
toTime, dumpsPtr);
if (dumpsList.budb_dumpsList_val)
free(dumpsList.budb_dumpsList_val);
return (code);
}
-bcdb_listDumps(sflags, groupId, fromTime, toTime, dumps, flags)
- afs_int32 groupId;
- afs_int32 fromTime;
- afs_int32 toTime;
- budb_dumpsList *dumps;
- budb_dumpsList *flags;
+afs_int32 bcdb_listDumps (afs_int32 sflags, afs_int32 groupId,afs_int32 fromTime, afs_int32 toTime,budb_dumpsList *dumps, budb_dumpsList *flags)
{
- afs_int32 code, sflag = 0;
+ afs_int32 code;
budb_dumpsList dumpsList, *dumpsPtr;
budb_dumpsList flagsList, *flagsPtr;
flagsPtr = (flags ? flags : &flagsList);
code =
- ubik_Call(BUDB_ListDumps, udbHandle.uh_client, 0, sflags, "", groupId,
+ ubik_BUDB_ListDumps(udbHandle.uh_client, 0, sflags, "", groupId,
fromTime, toTime, dumpsPtr, flagsPtr);
if (dumpsList.budb_dumpsList_val)
}
-bcdb_DeleteVDP(dumpSetName, dumpPath, dumpID)
- char *dumpSetName;
- char *dumpPath;
- afs_int32 dumpID;
+afs_int32 bcdb_DeleteVDP(char *dumpSetName, char *dumpPath, afs_int32 dumpID)
{
afs_int32 code;
code =
- ubik_Call(BUDB_DeleteVDP, udbHandle.uh_client, 0, dumpSetName,
+ ubik_BUDB_DeleteVDP(udbHandle.uh_client, 0, dumpSetName,
dumpPath, dumpID);
return (code);
}
* -2 - no clone times found, clone time set to 0
*/
-afs_int32
-bcdb_FindClone(dumpID, volName, clonetime)
- afs_int32 dumpID;
- char *volName;
- afs_int32 *clonetime;
+afs_int32 bcdb_FindClone(afs_int32 dumpID, char *volName, afs_int32 *clonetime)
{
afs_int32 code;
code =
- ubik_Call(BUDB_FindClone, udbHandle.uh_client, 0, dumpID, volName,
+ ubik_BUDB_FindClone(udbHandle.uh_client, 0, dumpID, volName,
clonetime);
return (code);
}
{
afs_int32 code;
code =
- ubik_Call(BUDB_FindDump, udbHandle.uh_client, 0, volumeName,
+ ubik_BUDB_FindDump(udbHandle.uh_client, 0, volumeName,
beforeDate, deptr);
return (code);
}
dl.budb_dumpList_val = 0;
/* outline algorithm */
- code = ubik_Call(BUDB_GetDumps, udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_DUMPID, "", /* no name */
+ code = ubik_BUDB_GetDumps(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_DUMPID, "", /* no name */
dumpID, /* start */
0, /* end */
0, /* index */
{
afs_int32 code;
code =
- ubik_Call(BUDB_FindLatestDump, udbHandle.uh_client, 0, volSetName,
+ ubik_BUDB_FindLatestDump(udbHandle.uh_client, 0, volSetName,
dumpPath, deptr);
return (code);
}
tl.budb_tapeList_val = 0;
code =
- ubik_Call(BUDB_GetTapes, udbHandle.uh_client, 0, BUDB_MAJORVERSION,
+ ubik_BUDB_GetTapes(udbHandle.uh_client, 0, BUDB_MAJORVERSION,
BUDB_OP_TAPENAME | BUDB_OP_DUMPID, tapeName, dumpid, 0, 0,
&next, &dbTime, &tl);
tl.budb_tapeList_val = 0;
code =
- ubik_Call(BUDB_GetTapes, udbHandle.uh_client, 0, BUDB_MAJORVERSION,
+ ubik_BUDB_GetTapes(udbHandle.uh_client, 0, BUDB_MAJORVERSION,
BUDB_OP_TAPESEQ | BUDB_OP_DUMPID, "", dumpid, tapeSeq, 0,
&next, &dbTime, &tl);
if (code)
vl.budb_volumeList_val = returnArray;
/* outline algorithm */
- code = ubik_Call(BUDB_GetVolumes, udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_VOLUMENAME | BUDB_OP_DUMPID, volumeName, /* name */
+ code = ubik_BUDB_GetVolumes(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_VOLUMENAME | BUDB_OP_DUMPID, volumeName, /* name */
dumpID, /* start */
0, /* end */
last, /* index */
register struct budb_dumpEntry *deptr;
{
afs_int32 code;
- code = ubik_Call(BUDB_FinishDump, udbHandle.uh_client, 0, deptr);
+ code = ubik_BUDB_FinishDump(udbHandle.uh_client, 0, deptr);
return (code);
}
register struct budb_tapeEntry *teptr;
{
afs_int32 code;
- code = ubik_Call(BUDB_FinishTape, udbHandle.uh_client, 0, teptr);
+ code = ubik_BUDB_FinishTape(udbHandle.uh_client, 0, teptr);
return (code);
}
vl.budb_volumeList_val = returnArray;
/* outline algorithm */
- code = ubik_Call(BUDB_GetVolumes, udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_VOLUMENAME, volumeName, /* name */
+ code = ubik_BUDB_GetVolumes(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_VOLUMENAME, volumeName, /* name */
0, /* start */
0, /* end */
last, /* index */
afs_int32 *newFlag;
{
afs_int32 code;
- code = ubik_Call(BUDB_UseTape, udbHandle.uh_client, 0, teptr, newFlag);
+ code = ubik_BUDB_UseTape(udbHandle.uh_client, 0, teptr, newFlag);
return (code);
}
offset = nextOffset;
charList.charListT_len = bufferSize;
code =
- ubik_Call(BUDB_GetText, udbHandle.uh_client, 0, ctPtr->lockHandle,
+ ubik_BUDB_GetText(udbHandle.uh_client, 0, ctPtr->lockHandle,
ctPtr->textType, bufferSize, offset, &nextOffset,
&charList);
/* get text version */
code =
- ubik_Call(BUDB_GetTextVersion, udbHandle.uh_client, 0,
+ ubik_BUDB_GetTextVersion(udbHandle.uh_client, 0,
ctPtr->textType, &ctPtr->textVersion);
if (code)
ERROR(code);
if (fileSize == 0) {
charList.charListT_len = 0;
code =
- ubik_Call(BUDB_SaveText, udbHandle.uh_client, 0,
+ ubik_BUDB_SaveText(udbHandle.uh_client, 0,
ctPtr->lockHandle, ctPtr->textType, 0,
BUDB_TEXT_COMPLETE, &charList);
goto error_exit;
charList.charListT_len = chunkSize;
code =
- ubik_Call(BUDB_SaveText, udbHandle.uh_client, 0,
+ ubik_BUDB_SaveText(udbHandle.uh_client, 0,
ctPtr->lockHandle, ctPtr->textType, offset,
(chunkSize == fileSize) ? BUDB_TEXT_COMPLETE : 0,
&charList);
struct budb_tapeEntry *tapeEntry;
struct budb_volumeEntry *volEntry;
{
- return (ubik_Call
- (BUDB_FindLastTape, udbHandle.uh_client, 0, dumpID, dumpEntry,
+ return (ubik_BUDB_FindLastTape(udbHandle.uh_client, 0, dumpID, dumpEntry,
tapeEntry, volEntry));
}
afs_int32 initialDumpID;
afs_int32 startTapeSeq;
{
- return (ubik_Call
- (BUDB_MakeDumpAppended, udbHandle.uh_client, 0, appendedDumpID,
+ return (ubik_BUDB_MakeDumpAppended(udbHandle.uh_client, 0, appendedDumpID,
initialDumpID, startTapeSeq));
}
while (1) {
code =
- ubik_Call(BUDB_GetLock, udbHandle.uh_client, 0,
+ ubik_BUDB_GetLock(udbHandle.uh_client, 0,
udbHandle.uh_instanceId, ctPtr->textType, timeout,
&ctPtr->lockHandle);
if ((code != BUDB_LOCKED) && (code != BUDB_SELFLOCKED)) {
/* Mention something every 30 seconds */
if (++j >= 30) {
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Waiting for db configuration text unlock");
j = 0;
}
return (0);
code =
- ubik_Call(BUDB_FreeLock, udbHandle.uh_client, 0, ctPtr->lockHandle);
+ ubik_BUDB_FreeLock(udbHandle.uh_client, 0, ctPtr->lockHandle);
ctPtr->lockHandle = 0;
/* Don't try to analyse the error. Let the lock timeout */
return (BC_VERSIONMISMATCH);
code =
- ubik_Call(BUDB_GetTextVersion, udbHandle.uh_client, 0,
+ ubik_BUDB_GetTextVersion(udbHandle.uh_client, 0,
ctPtr->textType, &tversion);
if (code)
return (code);
afsconf_Open((localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH));
if (!acdir) {
- com_err(whoami, 0, "Can't open configuration directory '%s'",
+ afs_com_err(whoami, 0, "Can't open configuration directory '%s'",
(localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH));
ERROR(BC_NOCELLCONFIG);
code = afsconf_GetLocalCell(acdir, cname, sizeof(cname));
if (code) {
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Can't get the local cell name - check %s/%s",
(localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_THISCELL_FILE);
code = afsconf_GetCellInfo(acdir, cellName, AFSCONF_VLDBSERVICE, &info);
if (code) {
- com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
+ afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
cellName,
(localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_CELLSERVDB_FILE);
if (localauth) {
code = afsconf_GetLatestKey(acdir, 0, 0);
if (code) {
- com_err(whoami, code, "; Can't get key from local key file");
+ afs_com_err(whoami, code, "; Can't get key from local key file");
ERROR(code);
} else {
code = afsconf_ClientAuth(acdir, &sc, &scIndex);
if (code) {
- com_err(whoami, code, "; Calling ClientAuth");
+ afs_com_err(whoami, code, "; Calling ClientAuth");
ERROR(code);
}
code =
ktc_GetToken(&sname, ttoken, sizeof(struct ktc_token), NULL);
if (code) {
- com_err(whoami, code, 0,
+ afs_com_err(whoami, code, 0,
"; Can't get AFS tokens - running unauthenticated");
} else {
if ((ttoken->kvno < 0) || (ttoken->kvno > 255))
- com_err(whoami, 0,
+ afs_com_err(whoami, 0,
"Funny kvno (%d) in ticket, proceeding",
ttoken->kvno);
ttoken->ticket);
break;
default:
- com_err(whoami, 0, "Unsupported authentication type %d", scIndex);
+ afs_com_err(whoami, 0, "Unsupported authentication type %d", scIndex);
ERROR(-1);
break;
}
}
if (!sc) {
- com_err(whoami, 0,
+ afs_com_err(whoami, 0,
"Can't create a security object with security index %d",
scIndex);
ERROR(-1);
UV_SetSecurity(sc, scIndex);
if (info.numServers > VLDB_MAXSERVERS) {
- com_err(whoami, 0,
+ afs_com_err(whoami, 0,
"Warning: %d VLDB servers exist for cell '%s', can only remember the first %d",
info.numServers, cellName, VLDB_MAXSERVERS);
info.numServers = VLDB_MAXSERVERS;
*cstruct = 0;
code = ubik_ClientInit(serverconns, cstruct);
if (code) {
- com_err(whoami, code, "; Can't initialize ubik connection to vldb");
+ afs_com_err(whoami, code, "; Can't initialize ubik connection to vldb");
ERROR(code);
}
afsconf_Open((localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH));
if (!acdir) {
- com_err(whoami, 0, "Can't open configuration directory '%s'",
+ afs_com_err(whoami, 0, "Can't open configuration directory '%s'",
(localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH));
ERROR(BC_NOCELLCONFIG);
code = afsconf_GetLocalCell(acdir, cname, sizeof(cname));
if (code) {
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Can't get the local cell name - check %s/%s",
(localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_THISCELL_FILE);
code = afsconf_GetCellInfo(acdir, cellName, 0, &info);
if (code) {
- com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
+ afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
cellName,
(localauth ? AFSDIR_SERVER_ETC_DIRPATH :
AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_CELLSERVDB_FILE);
if (localauth) {
code = afsconf_GetLatestKey(acdir, 0, 0);
if (code) {
- com_err(whoami, code, "; Can't get key from local key file");
+ afs_com_err(whoami, code, "; Can't get key from local key file");
ERROR(-1);
} else {
code =
afsconf_ClientAuth(acdir, &udbHandle.uh_secobj,
&udbHandle.uh_scIndex);
if (code) {
- com_err(whoami, code, "; Calling ClientAuth");
+ afs_com_err(whoami, code, "; Calling ClientAuth");
ERROR(-1);
}
}
/* get token */
code = ktc_GetToken(&principal, &token, sizeof(token), NULL);
if (code) {
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Can't get tokens - running unauthenticated");
} else {
if ((token.kvno < 0) || (token.kvno > 255))
- com_err(whoami, 0,
+ afs_com_err(whoami, 0,
"Unexpected kvno (%d) in ticket - proceeding",
token.kvno);
udbHandle.uh_scIndex = RX_SCINDEX_KAD; /* Kerberos */
break;
default:
- com_err(whoami, 0, "Unsupported authentication type %d",
+ afs_com_err(whoami, 0, "Unsupported authentication type %d",
udbHandle.uh_scIndex);
ERROR(-1);
break;
}
if (!udbHandle.uh_secobj) {
- com_err(whoami, 0,
+ afs_com_err(whoami, 0,
"Can't create a security object with security index %d",
udbHandle.uh_secobj);
ERROR(-1);
}
if (info.numServers > MAXSERVERS) {
- com_err(whoami, 0,
+ afs_com_err(whoami, 0,
"Warning: %d BDB servers exist for cell '%s', can only remember the first %d",
info.numServers, cellName, MAXSERVERS);
info.numServers = MAXSERVERS;
code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client);
if (code) {
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Can't initialize ubik connection to backup database");
ERROR(code);
}
for (i = 0; i < info.numServers; i++)
rx_SetConnDeadTime(udbHandle.uh_client->conns[i], 1);
code =
- ubik_Call(BUDB_GetInstanceId, udbHandle.uh_client, 0,
+ ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
&udbHandle.uh_instanceId);
/* Reset dead time back up to default */
/* If did not find a site on first quick pass, try again */
if (code == -1)
code =
- ubik_Call(BUDB_GetInstanceId, udbHandle.uh_client, 0,
+ ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
&udbHandle.uh_instanceId);
if (code) {
- com_err(whoami, code, "; Can't access backup database");
+ afs_com_err(whoami, code, "; Can't access backup database");
ERROR(code);
}
code = ubik_ParseClientList(3, args, serverList);
if (code) {
- com_err(whoami, code, "; udbLocalInit: parsing ubik server list");
+ afs_com_err(whoami, code, "; udbLocalInit: parsing ubik server list");
return (-1);
}
BUDB_SERVICE, udbHandle.uh_secobj,
udbHandle.uh_scIndex);
if (udbHandle.uh_serverConn[i] == 0) {
- com_err(whoami, 0, "connection %d failed", i);
+ afs_com_err(whoami, 0, "connection %d failed", i);
continue;
}
}
udbHandle.uh_serverConn[i] = 0;
code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client);
if (code) {
- com_err(whoami, code, "; in ubik_ClientInit");
+ afs_com_err(whoami, code, "; in ubik_ClientInit");
return (code);
}
code =
- ubik_Call(BUDB_GetInstanceId, udbHandle.uh_client, 0,
+ ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
&udbHandle.uh_instanceId);
if (code) {
- com_err(whoami, code, "; Can't estblish instance Id");
+ afs_com_err(whoami, code, "; Can't estblish instance Id");
return (code);
}
git://git.openafs.org / openafs.git / blobdiff