/*
* 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
/* Interface and supporting routines for the backup system's ubik database */
#include <afsconfig.h>
-#include <afs/param.h>
-
-RCSID
- ("$Header$");
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#ifdef AFS_NT40_ENV
-#include <winsock2.h>
-#elif defined(AFS_SUN5_ENV)
-#include <netdb.h>
-#else
-#include <sys/param.h> /* for hostnames etc */
+#include <afs/stds.h>
+
+#include <roken.h>
+
+#ifdef IGNORE_SOME_GCC_WARNINGS
+# pragma GCC diagnostic warning "-Wstrict-prototypes"
#endif
+
+#include <afs/cmd.h>
#include <afs/auth.h>
#include <afs/cellconfig.h>
#include <ubik.h>
+#include <afs/afsint.h>
#include <afs/volser.h>
+#include <afs/volser_prototypes.h>
#include <afs/afsutil.h>
#include <afs/bubasics.h>
#include <afs/budb_client.h>
#include <afs/budb.h>
-#include <errno.h>
+#include <afs/com_err.h>
#include "bc.h"
#include "error_macros.h"
+#include "bucoord_internal.h"
+#include "bucoord_prototypes.h"
extern char *whoami;
/* -------------------------------------
- * Globals
+ * Globals
* -------------------------------------
*/
* -------------------------------------
*/
-bcdb_AddVolume(veptr)
- register struct budb_volumeEntry *veptr;
+afs_int32 bcdb_AddVolume(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(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(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);
}
* the current multiple bcdb_ call algorithm.
*/
-bcdb_FindDump(volumeName, beforeDate, deptr)
- char *volumeName;
- afs_int32 beforeDate;
- struct budb_dumpEntry *deptr;
+int
+bcdb_FindDump(char *volumeName, afs_int32 beforeDate,
+ struct budb_dumpEntry *deptr)
{
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);
}
* dumpID - id to lookup
* exit:
*/
-bcdb_FindDumpByID(dumpID, deptr)
- afs_int32 dumpID;
- register struct budb_dumpEntry *deptr;
+int
+bcdb_FindDumpByID(afs_int32 dumpID, struct budb_dumpEntry *deptr)
{
- register afs_int32 code;
+ afs_int32 code;
afs_int32 nextindex;
afs_int32 dbTime;
budb_dumpList dl;
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
-bcdb_FindLastVolClone(volSetName, dumpName, volName, clonetime)
- char *volSetName;
- char *dumpName;
- char *volName;
- afs_int32 *clonetime;
+bcdb_FindLastVolClone(char *volSetName, char *dumpName, char *volName,
+ afs_int32 *clonetime)
{
/* server notes
* search by dumpName
* Need new routine since params are two strings
*/
-bcdb_FindLatestDump(volSetName, dumpPath, deptr)
- char *volSetName;
- char *dumpPath;
- struct budb_dumpEntry *deptr;
+int
+bcdb_FindLatestDump(char *volSetName, char *dumpPath,
+ struct budb_dumpEntry *deptr)
{
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);
}
* tapeName: name of tape
*/
-bcdb_FindTape(dumpid, tapeName, teptr)
- afs_int32 dumpid;
- char *tapeName;
- struct budb_tapeEntry *teptr;
+int
+bcdb_FindTape(afs_int32 dumpid, char *tapeName,
+ struct budb_tapeEntry *teptr)
{
budb_tapeList tl;
afs_int32 next;
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);
return (code);
}
-bcdb_FindTapeSeq(dumpid, tapeSeq, teptr)
- afs_int32 dumpid;
- afs_int32 tapeSeq;
- struct budb_tapeEntry *teptr;
+int
+bcdb_FindTapeSeq(afs_int32 dumpid, afs_int32 tapeSeq,
+ struct budb_tapeEntry *teptr)
{
budb_tapeList tl;
afs_int32 next;
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)
}
/* bcdb_FindVolumes
- * notes:
+ * notes:
* - this is part of dblookup. The existing semantics will not work since
* they do lookups based on dump id.
* - in the restore code, it uses this to extract information about
*/
afs_int32
-bcdb_FindVolumes(dumpID, volumeName, returnArray, last, next, maxa, nEntries)
- afs_int32 dumpID;
- char *volumeName;
- struct budb_volumeEntry *returnArray;
- afs_int32 last;
- afs_int32 *next;
- afs_int32 maxa;
- afs_int32 *nEntries;
+bcdb_FindVolumes(afs_int32 dumpID, char *volumeName,
+ struct budb_volumeEntry *returnArray,
+ afs_int32 last, afs_int32 *next, afs_int32 maxa,
+ afs_int32 *nEntries)
{
budb_volumeList vl;
afs_int32 dbTime;
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 */
return (code);
}
-
-bcdb_FinishDump(deptr)
- register struct budb_dumpEntry *deptr;
+int
+bcdb_FinishDump(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);
}
-bcdb_FinishTape(teptr)
- register struct budb_tapeEntry *teptr;
+int
+bcdb_FinishTape(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);
}
*/
afs_int32
-bcdb_LookupVolume(volumeName, returnArray, last, next, maxa, nEntries)
- char *volumeName;
- struct budb_volumeEntry *returnArray;
- afs_int32 last;
- afs_int32 *next;
- afs_int32 maxa;
- afs_int32 *nEntries;
+bcdb_LookupVolume(char *volumeName, struct budb_volumeEntry *returnArray,
+ afs_int32 last, afs_int32 *next, afs_int32 maxa,
+ afs_int32 *nEntries)
{
budb_volumeList vl;
afs_int32 dbTime;
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 */
return (0);
}
-
-bcdb_UseTape(teptr, newFlag)
- register struct budb_tapeEntry *teptr;
- afs_int32 *newFlag;
+int
+bcdb_UseTape(struct budb_tapeEntry *teptr, 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);
}
/* ---- text configuration handling routines ----
- *
- * notes:
+ *
+ * notes:
* The caller should pass in/out a fid for an unlinked, open file to prevent
- * tampering with the files contents;
+ * tampering with the files contents;
*/
/* bcdb_GetTextFile
* ctPtr - ptr to client structure with all the required information
*/
-bcdb_GetTextFile(register udbClientTextP ctPtr)
+int
+bcdb_GetTextFile(udbClientTextP ctPtr)
{
afs_int32 bufferSize;
afs_int32 offset, nextOffset;
/* allocate a buffer */
bufferSize = 1024;
- charList.charListT_val = (char *)malloc(bufferSize);
+ charList.charListT_val = malloc(bufferSize);
if (charList.charListT_val == 0)
ERROR(BUDB_INTERNALERROR);
charList.charListT_len = bufferSize;
- offset = 0;
nextOffset = 0;
ctPtr->textSize = 0;
while (nextOffset != -1) {
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);
* filename - where to get the text from
*/
-bcdb_SaveTextFile(ctPtr)
- udbClientTextP ctPtr;
+int
+bcdb_SaveTextFile(udbClientTextP ctPtr)
{
afs_int32 bufferSize;
afs_int32 offset, chunkSize, fileSize;
charListT charList;
afs_int32 code = 0;
- afs_int32 filesize();
/* allocate a buffer */
bufferSize = 1024;
- charList.charListT_val = (char *)malloc(bufferSize);
+ charList.charListT_val = malloc(bufferSize);
if (charList.charListT_val == 0)
ERROR(BUDB_INTERNALERROR);
charList.charListT_len = bufferSize;
fileSize = (afs_int32) filesize(ctPtr->textStream);
- dprintf(("filesize is %d\n", fileSize));
+ afs_dprintf(("filesize is %d\n", fileSize));
rewind(ctPtr->textStream);
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;
offset = 0;
while (fileSize != 0) {
- chunkSize = MIN(fileSize, bufferSize);
+ chunkSize = min(fileSize, bufferSize);
code =
fread(charList.charListT_val, sizeof(char), chunkSize,
ctPtr->textStream);
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);
return (code);
}
-bcdb_FindLastTape(dumpID, dumpEntry, tapeEntry, volEntry)
- afs_int32 dumpID;
- struct budb_dumpEntry *dumpEntry;
- struct budb_tapeEntry *tapeEntry;
- struct budb_volumeEntry *volEntry;
+int
+bcdb_FindLastTape(afs_int32 dumpID, struct budb_dumpEntry *dumpEntry,
+ 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));
}
-bcdb_MakeDumpAppended(appendedDumpID, initialDumpID, startTapeSeq)
- afs_int32 appendedDumpID;
- afs_int32 initialDumpID;
- afs_int32 startTapeSeq;
+int
+bcdb_MakeDumpAppended(afs_int32 appendedDumpID, 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));
}
*/
afs_int32
-filesize(stream)
- FILE *stream;
+filesize(FILE *stream)
{
afs_int32 offset;
afs_int32 size;
* n - fail
*/
-bc_LockText(ctPtr)
- register udbClientTextP ctPtr;
+int
+bc_LockText(udbClientTextP ctPtr)
{
afs_int32 code;
afs_int32 timeout, j = 0;
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;
}
* n - fail
*/
-bc_UnlockText(ctPtr)
- register udbClientTextP ctPtr;
+int
+bc_UnlockText(udbClientTextP ctPtr)
{
afs_int32 code = 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 */
* n - out of date or error
*/
-bc_CheckTextVersion(ctPtr)
- register udbClientTextP ctPtr;
+int
+bc_CheckTextVersion(udbClientTextP ctPtr)
{
afs_int32 code;
afs_uint32 tversion;
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);
* -------------------------------------
*/
-/* vldbClientInit
+static afsconf_secflags
+parseSecFlags(int noAuthFlag, int localauth, const char **confdir) {
+ afsconf_secflags secFlags;
+
+ secFlags = 0;
+ if (noAuthFlag)
+ secFlags |= AFSCONF_SECOPTS_NOAUTH;
+
+ if (localauth) {
+ secFlags |= AFSCONF_SECOPTS_LOCALAUTH;
+ *confdir = AFSDIR_SERVER_ETC_DIRPATH;
+ } else {
+ *confdir = AFSDIR_CLIENT_ETC_DIRPATH;
+ }
+ return secFlags;
+}
+
+/* vldbClientInit
* Initialize a client for the vl ubik database.
*/
-vldbClientInit(noAuthFlag, localauth, cellName, cstruct, ttoken)
- int noAuthFlag;
- int localauth;
- char *cellName;
- struct ubik_client **cstruct;
- struct ktc_token *ttoken;
+int
+vldbClientInit(int noAuthFlag, int localauth, char *cellName,
+ struct ubik_client **cstruct,
+ time_t *expires)
{
afs_int32 code = 0;
struct afsconf_dir *acdir;
- struct rc_securityClass *sc;
- afs_int32 i, scIndex = 0; /* Index of Rx security object - noauth */
+ struct rx_securityClass *sc;
+ afs_int32 i, scIndex = RX_SECIDX_NULL;
struct afsconf_cell info;
- struct ktc_principal sname;
struct rx_connection *serverconns[VLDB_MAXSERVERS];
+ afsconf_secflags secFlags;
+ const char *confdir;
+
+ secFlags = parseSecFlags(noAuthFlag, localauth, &confdir);
+ secFlags |= AFSCONF_SECOPTS_FALLBACK_NULL;
+ /* This just preserves old behaviour of using the default cell when
+ * passed an empty string */
+ if (cellName && cellName[0] == '\0')
+ cellName = NULL;
/* Find out about the given cell */
- acdir =
- afsconf_Open((localauth ? AFSDIR_SERVER_ETC_DIRPATH :
- AFSDIR_CLIENT_ETC_DIRPATH));
+ acdir = afsconf_Open(confdir);
if (!acdir) {
- com_err(whoami, 0, "Can't open configuration directory '%s'",
- (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
- AFSDIR_CLIENT_ETC_DIRPATH));
+ afs_com_err(whoami, 0, "Can't open configuration directory '%s'", confdir);
ERROR(BC_NOCELLCONFIG);
}
- if (!cellName[0]) {
- char cname[64];
-
- code = afsconf_GetLocalCell(acdir, cname, sizeof(cname));
- if (code) {
- 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);
- ERROR(code);
- }
- strcpy(cellName, cname);
- }
-
code = afsconf_GetCellInfo(acdir, cellName, AFSCONF_VLDBSERVICE, &info);
if (code) {
- 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);
+ afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
+ cellName, confdir, AFSDIR_CELLSERVDB_FILE);
ERROR(BC_NOCELLCONFIG);
}
- /*
- * Grab tickets if we care about authentication.
- */
- ttoken->endTime = 0;
- if (localauth) {
- code = afsconf_GetLatestKey(acdir, 0, 0);
- if (code) {
- 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");
- ERROR(code);
- }
-
- ttoken->endTime = NEVERDATE;
- }
- } else {
- if (!noAuthFlag) {
- strcpy(sname.cell, info.name);
- sname.instance[0] = 0;
- strcpy(sname.name, "afs");
-
- code =
- ktc_GetToken(&sname, ttoken, sizeof(struct ktc_token), NULL);
- if (code) {
- com_err(whoami, code, 0,
- "; Can't get AFS tokens - running unauthenticated");
- } else {
- if ((ttoken->kvno < 0) || (ttoken->kvno > 255))
- com_err(whoami, 0,
- "Funny kvno (%d) in ticket, proceeding",
- ttoken->kvno);
-
- scIndex = 2;
- }
- }
-
- switch (scIndex) {
- case 0:
- sc = rxnull_NewClientSecurityObject();
- break;
- case 2:
- sc = (struct rx_securityClass *)
- rxkad_NewClientSecurityObject(rxkad_clear,
- &ttoken->sessionKey,
- ttoken->kvno, ttoken->ticketLen,
- ttoken->ticket);
- break;
- default:
- com_err(whoami, 0, "Unsupported authentication type %d", scIndex);
- ERROR(-1);
- break;
- }
- }
-
- if (!sc) {
- com_err(whoami, 0,
- "Can't create a security object with security index %d",
- scIndex);
- ERROR(-1);
+ code = afsconf_PickClientSecObj(acdir, secFlags, &info, cellName,
+ &sc, &scIndex, expires);
+ if (code) {
+ afs_com_err(whoami, code, "(configuring connection security)");
+ ERROR(BC_NOCELLCONFIG);
}
+ if (scIndex == RX_SECIDX_NULL && !noAuthFlag)
+ afs_com_err(whoami, 0, "Can't get tokens - running unauthenticated");
/* tell UV module about default authentication */
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);
}
*/
afs_int32
-udbClientInit(noAuthFlag, localauth, cellName)
- int noAuthFlag;
- int localauth;
- char *cellName;
+udbClientInit(int noAuthFlag, int localauth, char *cellName)
{
- struct ktc_principal principal;
- struct ktc_token token;
struct afsconf_cell info;
struct afsconf_dir *acdir;
+ const char *confdir;
int i;
+ afs_int32 secFlags;
afs_int32 code = 0;
- acdir =
- afsconf_Open((localauth ? AFSDIR_SERVER_ETC_DIRPATH :
- AFSDIR_CLIENT_ETC_DIRPATH));
- if (!acdir) {
- com_err(whoami, 0, "Can't open configuration directory '%s'",
- (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
- AFSDIR_CLIENT_ETC_DIRPATH));
- ERROR(BC_NOCELLCONFIG);
- }
+ secFlags = parseSecFlags(noAuthFlag, localauth, &confdir);
+ secFlags |= AFSCONF_SECOPTS_FALLBACK_NULL;
- if (!cellName[0]) {
- char cname[64];
+ if (cellName && cellName[0] == '\0')
+ cellName = NULL;
- code = afsconf_GetLocalCell(acdir, cname, sizeof(cname));
- if (code) {
- 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);
- ERROR(code);
- }
- strcpy(cellName, cname);
+ acdir = afsconf_Open(confdir);
+ if (!acdir) {
+ afs_com_err(whoami, 0, "Can't open configuration directory '%s'",
+ confdir);
+ ERROR(BC_NOCELLCONFIG);
}
code = afsconf_GetCellInfo(acdir, cellName, 0, &info);
if (code) {
- 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);
+ afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
+ cellName, confdir, AFSDIR_CELLSERVDB_FILE);
ERROR(BC_NOCELLCONFIG);
}
- udbHandle.uh_scIndex = RX_SCINDEX_NULL;
-
- if (localauth) {
- code = afsconf_GetLatestKey(acdir, 0, 0);
- if (code) {
- 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");
- ERROR(-1);
- }
- }
- } else {
- if (!noAuthFlag) {
- /* setup principal */
- strcpy(principal.cell, info.name);
- principal.instance[0] = 0;
- strcpy(principal.name, "afs");
-
- /* get token */
- code = ktc_GetToken(&principal, &token, sizeof(token), NULL);
- if (code) {
- com_err(whoami, code,
- "; Can't get tokens - running unauthenticated");
- } else {
- if ((token.kvno < 0) || (token.kvno > 255))
- com_err(whoami, 0,
- "Unexpected kvno (%d) in ticket - proceeding",
- token.kvno);
- udbHandle.uh_scIndex = RX_SCINDEX_KAD; /* Kerberos */
- }
- }
-
- switch (udbHandle.uh_scIndex) {
- case 0:
- udbHandle.uh_secobj = rxnull_NewClientSecurityObject();
- break;
-
- case 2:
- udbHandle.uh_secobj = (struct rx_securityClass *)
- rxkad_NewClientSecurityObject(rxkad_clear, &token.sessionKey,
- token.kvno, token.ticketLen,
- token.ticket);
- break;
-
- default:
- com_err(whoami, 0, "Unsupported authentication type %d",
- udbHandle.uh_scIndex);
- ERROR(-1);
- break;
- }
- }
-
- if (!udbHandle.uh_secobj) {
- com_err(whoami, 0,
- "Can't create a security object with security index %d",
- udbHandle.uh_secobj);
- ERROR(-1);
+ code = afsconf_PickClientSecObj(acdir, secFlags, &info, cellName,
+ &udbHandle.uh_secobj,
+ &udbHandle.uh_scIndex, NULL);
+ if (code) {
+ afs_com_err(whoami, code, "(configuring connection security)");
+ ERROR(BC_NOCELLCONFIG);
}
+ if (udbHandle.uh_scIndex == RX_SECIDX_NULL && !noAuthFlag)
+ afs_com_err(whoami, 0, "Can't get tokens - running unauthenticated");
- if (info.numServers > MAXSERVERS) {
- com_err(whoami, 0,
+ /* We have to have space for the trailing NULL that terminates the server
+ * conneciton array - so we can only store MAXSERVERS-1 real elements in
+ * that array.
+ */
+ if (info.numServers >= MAXSERVERS) {
+ 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;
+ info.numServers, cellName, MAXSERVERS-1);
+ info.numServers = MAXSERVERS - 1;
}
/* establish connections to the servers. Check for failed connections? */
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);
}
*/
afs_int32
-ubik_Call_SingleServer(aproc, aclient, aflags, p1, p2, p3, p4, p5, p6, p7, p8,
- p9, p10, p11, p12, p13, p14, p15, p16)
- register struct ubik_client *aclient;
- int (*aproc) ();
- afs_int32 aflags;
- char *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10, *p11, *p12, *p13,
- *p14, *p15, *p16;
+ubik_Call_SingleServer(int (*aproc) (), struct ubik_client *aclient,
+ afs_int32 aflags, char *p1, char *p2, char *p3,
+ char *p4, char *p5, char *p6, char *p7, char *p8,
+ char *p9, char *p10, char *p11, char *p12, char *p13,
+ char *p14, char *p15, char *p16)
{
- register afs_int32 code;
+ afs_int32 code;
afs_int32 someCode, newHost, thisHost;
- register afs_int32 i;
- register afs_int32 count;
+ afs_int32 i;
+ afs_int32 count;
int chaseCount;
int pass;
struct rx_connection *tc;
* calls
*/
if ((code == 0)
- && (aflags & UF_SINGLESERVER != 0)
+ && ((aflags & UF_SINGLESERVER) != 0)
) {
/* need to save state */
uServer.ucs_flags = UF_SINGLESERVER;
/* -------------------------------------
- * debug and test routines
+ * debug and test routines
* -------------------------------------
*/
* n - error.
*/
-udbLocalInit()
+int
+udbLocalInit(void)
{
- afs_int32 serverList[MAXSERVERS];
+ afs_uint32 serverList[MAXSERVERS];
char hostname[256];
char *args[3];
int i;
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);
}
- udbHandle.uh_scIndex = RX_SCINDEX_NULL;
+ udbHandle.uh_scIndex = RX_SECIDX_NULL;
udbHandle.uh_secobj = (struct rx_securityClass *)
rxnull_NewClientSecurityObject();
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);
}
* the udbClientTextP.textStream member.
* Output: The temp file name is returned in tmpFileName. This should be used
* to delete the file when done with it.
- * Return Values:
+ * Return Values:
* !0: error code
* 0: Success.
*/
bc_openTextFile(udbClientTextP ctPtr, char *tmpFileName)
{
int code = 0;
+ int fd;
- if (ctPtr->textStream != NULL)
+ if (ctPtr->textStream != NULL) {
fclose(ctPtr->textStream);
+ ctPtr->textStream = NULL;
+ }
sprintf(tmpFileName, "%s/bu_XXXXXX", gettmpdir());
-#ifdef AFS_LINUX20_ENV
- mkstemp(tmpFileName);
-#else
- mktemp(tmpFileName);
-#endif
- ctPtr->textStream = fopen(tmpFileName, "w+");
+ fd = mkstemp(tmpFileName);
+ if (fd == -1)
+ ERROR(BUDB_INTERNALERROR);
+ ctPtr->textStream = fdopen(fd, "w+");
if (ctPtr->textStream == NULL)
ERROR(BUDB_INTERNALERROR);
ERROR(errno);
#endif
- dprintf(("file is %s\n", tmpFileName));
+ afs_dprintf(("file is %s\n", tmpFileName));
normal_exit:
return code;
/* bc_closeTextFile: This function closes any actual temp files associated with
- * a udbClientText structure.
+ * a udbClientText structure.
* Input: ctPtr->textStream - stream to close
* tmpFileName - temp file name to delete
- * RetVal:
+ * RetVal:
* 0 - Success
* !0 - error code
*/
git://git.openafs.org / openafs.git / blobdiff