/*
* 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>
-RCSID
- ("$Header$");
+#include <afs/procmgmt.h>
+#include <roken.h>
-#include <sys/types.h>
-#include <errno.h>
-#ifdef AFS_NT40_ENV
-#include <winsock2.h>
-#else
-#include <sys/file.h>
-#include <netinet/in.h>
-#endif
-#include <rx/xdr.h>
+#include <afs/opr.h>
#include <rx/rx.h>
#include <afs/afsint.h>
-#include <stdio.h>
-#include <afs/procmgmt.h>
-#include <afs/assert.h>
#include <afs/prs_fs.h>
-#include <sys/stat.h>
#include <afs/nfs.h>
#include <lwp.h>
#include <lock.h>
-#include <afs/auth.h>
#include <afs/cellconfig.h>
#include <afs/keys.h>
#include <ubik.h>
#include <afs/tcdata.h>
+#include <afs/budb_client.h>
+#include <afs/bucoord_prototypes.h>
+
#include "error_macros.h"
#include "butc_xbsa.h"
-extern afs_int32 xbsaType;
-
-callPermitted(call)
- struct rx_call *call;
+#include "butc_prototypes.h"
+#include "butc_internal.h"
+#include "afs/audit.h"
+
+static int CopyDumpDesc(struct tc_dumpDesc *, tc_dumpArray *);
+static int CopyRestoreDesc(struct tc_restoreDesc *, tc_restoreArray *);
+static int CopyTapeSetDesc(struct tc_tapeSet *, struct tc_tapeSet *);
+
+/* Helpers implementing RPC backends */
+static afs_int32 SLabelTape(struct rx_call *acid, struct tc_tapeLabel *label,
+ afs_uint32 *taskId);
+static afs_int32 SPerformDump(struct rx_call *rxCallId,
+ struct tc_dumpInterface *tcdiPtr,
+ tc_dumpArray *tc_dumpArrayPtr, afs_int32 *taskId);
+static afs_int32 SPerformRestore(struct rx_call *acid, char *dumpSetName,
+ tc_restoreArray *arestores, afs_int32 *taskId);
+static afs_int32 SReadLabel(struct rx_call *acid, struct tc_tapeLabel *label,
+ afs_uint32 *taskId);
+static afs_int32 SRestoreDb(struct rx_call *rxCall, afs_uint32 *taskId);
+static afs_int32 SSaveDb(struct rx_call *rxCall, Date archiveTime,
+ afs_uint32 *taskId);
+static afs_int32 SScanDumps(struct rx_call *acid, afs_int32 addDbFlag,
+ afs_uint32 *taskId);
+static afs_int32 STCInfo(struct rx_call *acid, struct tc_tcInfo *tciptr);
+static afs_int32 SDeleteDump(struct rx_call *acid, afs_uint32 dumpID,
+ afs_uint32 *taskId);
+
+int
+callPermitted(struct rx_call *call)
{
- /* before this code can be used, the rx connection, on the bucoord side, must */
- /* be changed so that it will set up for token passing instead of using a */
- /* simple rx connection that, below, returns a value of 0 from rx_SecurityClassOf */
+ /*
+ * Before this code can be used, the rx connection, on the bucoord side,
+ * must be changed so that it will set up for token passing instead of
+ * using a simple rx connection that, below, returns a value of
+ * RX_SECIDX_NULL from rx_SecurityClassOf.
+ */
return 1;
}
+/* -----------------------------
+ * misc. routines
+ * -----------------------------
+ */
+
+static int
+CopyDumpDesc(struct tc_dumpDesc *toDump, tc_dumpArray *fromDump)
+{
+ struct tc_dumpDesc *toPtr, *fromPtr;
+ int i;
+
+ toPtr = toDump;
+ fromPtr = fromDump->tc_dumpArray_val;
+ for (i = 0; i < fromDump->tc_dumpArray_len; i++) {
+ toPtr->vid = fromPtr->vid;
+ toPtr->vtype = fromPtr->vtype;
+ toPtr->partition = fromPtr->partition;
+ toPtr->date = fromPtr->date;
+ toPtr->cloneDate = fromPtr->cloneDate;
+ toPtr->hostAddr = fromPtr->hostAddr;
+ strcpy(toPtr->name, fromPtr->name);
+ fromPtr++;
+ toPtr++;
+ }
+ return 0;
+}
+
+
+static int
+CopyRestoreDesc(struct tc_restoreDesc *toRestore, tc_restoreArray *fromRestore)
+{
+ struct tc_restoreDesc *toPtr, *fromPtr;
+ int i;
+
+ toPtr = toRestore;
+ fromPtr = fromRestore->tc_restoreArray_val;
+ for (i = 0; i < fromRestore->tc_restoreArray_len; i++) {
+ toPtr->flags = fromPtr->flags;
+ toPtr->position = fromPtr->position;
+ strcpy(toPtr->tapeName, fromPtr->tapeName);
+ toPtr->dbDumpId = fromPtr->dbDumpId;
+ toPtr->initialDumpId = fromPtr->initialDumpId;
+ toPtr->origVid = fromPtr->origVid;
+ toPtr->vid = fromPtr->vid;
+ toPtr->partition = fromPtr->partition;
+ toPtr->dumpLevel = fromPtr->dumpLevel;
+ toPtr->hostAddr = fromPtr->hostAddr;
+ strcpy(toPtr->newName, fromPtr->newName);
+ strcpy(toPtr->oldName, fromPtr->oldName);
+ fromPtr++;
+ toPtr++;
+
+ }
+ return 0;
+}
+
+static int
+CopyTapeSetDesc(struct tc_tapeSet *toPtr, struct tc_tapeSet *fromPtr)
+{
+
+ toPtr->id = fromPtr->id;
+ toPtr->maxTapes = fromPtr->maxTapes;
+ toPtr->a = fromPtr->a;
+ toPtr->b = fromPtr->b;
+ strcpy(toPtr->tapeServer, fromPtr->tapeServer);
+ strcpy(toPtr->format, fromPtr->format);
+
+ toPtr->expDate = fromPtr->expDate;
+ toPtr->expType = fromPtr->expType;
+ return 0;
+}
+
/* -------------------------
* butc - interface routines - alphabetic order
* -------------------------
*/
afs_int32
-STC_LabelTape(acid, label, taskId)
- struct rx_call *acid;
- struct tc_tapeLabel *label;
- afs_uint32 *taskId;
+STC_LabelTape(struct rx_call *acid, struct tc_tapeLabel *label, afs_uint32 *taskId)
+{
+ afs_int32 code;
+
+ code = SLabelTape(acid, label, taskId);
+ osi_auditU(acid, TC_LabelTapeEvent, code,
+ AUD_TLBL, label, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SLabelTape(struct rx_call *acid, struct tc_tapeLabel *label, afs_uint32 *taskId)
{
#ifdef AFS_PTHREAD_ENV
pthread_t pid;
PROCESS pid;
#endif
struct labelTapeIf *ptr;
- statusP statusPtr;
+ statusP statusPtr = NULL;
afs_int32 code;
- extern int Labeller();
- extern statusP createStatusNode();
- extern afs_int32 allocTaskId();
-
#ifdef xbsa
if (CONF_XBSA)
return (TC_BADTASK); /* LabelTape does not apply if XBSA */
if (callPermitted(acid) == 0)
return (TC_NOTPERMITTED);
- ptr = (struct labelTapeIf *)malloc(sizeof(*ptr));
+ ptr = malloc(sizeof(*ptr));
if (!ptr)
ERROR_EXIT(TC_NOMEMORY);
memcpy(&ptr->label, label, sizeof(ptr->label));
*/
afs_int32
-STC_PerformDump(rxCallId, tcdiPtr, tc_dumpArrayPtr, taskId)
- struct rx_call *rxCallId;
- struct tc_dumpInterface *tcdiPtr;
- tc_dumpArray *tc_dumpArrayPtr;
- afs_int32 *taskId;
+STC_PerformDump(struct rx_call *call, struct tc_dumpInterface *di,
+ tc_dumpArray *da, afs_int32 *taskId)
+{
+ afs_int32 code;
+
+ code = SPerformDump(call, di, da, taskId);
+ osi_auditU(call, TC_PerformDumpEvent, code,
+ AUD_TDI, di, AUD_TDA, da, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SPerformDump(struct rx_call *rxCallId, struct tc_dumpInterface *tcdiPtr,
+ tc_dumpArray *tc_dumpArrayPtr, afs_int32 *taskId)
{
struct dumpNode *newNode = 0;
statusP statusPtr = 0;
#endif
afs_int32 code = 0;
- extern statusP createStatusNode();
- extern Dumper();
-
if (callPermitted(rxCallId) == 0)
return (TC_NOTPERMITTED);
/*set up the parameters in the node, to be used by LWP */
strcpy(newNode->dumpSetName, tcdiPtr->dumpName);
- newNode->dumpName = (char *)malloc(strlen(tcdiPtr->dumpPath) + 1);
- strcpy(newNode->dumpName, tcdiPtr->dumpPath);
-
- newNode->volumeSetName =
- (char *)malloc(strlen(tcdiPtr->volumeSetName) + 1);
- strcpy(newNode->volumeSetName, tcdiPtr->volumeSetName);
+ newNode->dumpName = strdup(tcdiPtr->dumpPath);
+ newNode->volumeSetName = strdup(tcdiPtr->volumeSetName);
CopyTapeSetDesc(&(newNode->tapeSetDesc), &tcdiPtr->tapeSet);
- newNode->dumps = (struct tc_dumpDesc *)
- malloc(sizeof(struct tc_dumpDesc) *
- tc_dumpArrayPtr->tc_dumpArray_len);
+ newNode->dumps = malloc(sizeof(struct tc_dumpDesc) *
+ tc_dumpArrayPtr->tc_dumpArray_len);
newNode->arraySize = tc_dumpArrayPtr->tc_dumpArray_len;
CopyDumpDesc(newNode->dumps, tc_dumpArrayPtr);
}
afs_int32
-STC_PerformRestore(acid, dumpSetName, arestores, taskID)
- struct rx_call *acid;
- char *dumpSetName; /* not used */
- tc_restoreArray *arestores;
- afs_int32 *taskID;
+STC_PerformRestore(struct rx_call *call, char *dumpSetName,
+ tc_restoreArray *ra, afs_int32 *taskId)
+{
+ afs_int32 code;
+
+ code = SPerformRestore(call, dumpSetName, ra, taskId);
+ osi_auditU(call, TC_PerformRestoreEvent, code,
+ AUD_STR, dumpSetName, AUD_TRA, ra, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SPerformRestore(struct rx_call *acid, char *dumpSetName,
+ tc_restoreArray *arestores, afs_int32 *taskID)
{
struct dumpNode *newNode;
statusP statusPtr;
PROCESS pid;
#endif
- extern int Restorer();
- extern statusP createStatusNode();
-
if (callPermitted(acid) == 0)
return (TC_NOTPERMITTED);
/* this creates a node in list, alots an id for it and prepares it for locking */
CreateNode(&newNode);
- newNode->restores = (struct tc_restoreDesc *)
- malloc(sizeof(struct tc_restoreDesc) *
- arestores->tc_restoreArray_len);
+ newNode->restores = malloc(sizeof(struct tc_restoreDesc) *
+ arestores->tc_restoreArray_len);
newNode->arraySize = arestores->tc_restoreArray_len;
CopyRestoreDesc(newNode->restores, arestores);
*taskID = newNode->taskID;
}
afs_int32
-STC_ReadLabel(acid, label, taskId)
- struct rx_call *acid;
- struct tc_tapeLabel *label;
- afs_uint32 *taskId;
+STC_ReadLabel(struct rx_call *call, struct tc_tapeLabel *label, afs_uint32 *taskId)
{
afs_int32 code;
- extern int ReadLabel();
+ code = SReadLabel(call, label, taskId);
+ osi_auditU(call, TC_ReadLabelEvent, code,
+ AUD_TLBL, label, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SReadLabel(struct rx_call *acid, struct tc_tapeLabel *label, afs_uint32 *taskId)
+{
+ afs_int32 code;
+ memset(label, 0, sizeof(*label));
+ /* Synchronous, so no "real" ID; don't send stack garbage on the wire */
+ *taskId = 0;
#ifdef xbsa
if (CONF_XBSA)
return (TC_BADTASK); /* ReadLabel does not apply if XBSA */
*/
afs_int32
-STC_RestoreDb(rxCall, taskId)
- struct rx_call *rxCall;
- afs_uint32 *taskId;
+STC_RestoreDb(struct rx_call *call, afs_uint32 *taskId)
+{
+ afs_int32 code;
+
+ code = SRestoreDb(call, taskId);
+ osi_auditU(call, TC_RestoreDbEvent, code, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SRestoreDb(struct rx_call *rxCall, afs_uint32 *taskId)
{
#ifdef AFS_PTHREAD_ENV
pthread_t pid;
statusP statusPtr;
afs_int32 code = 0;
- extern afs_int32 restoreDbFromTape();
- extern statusP createStatusNode();
- extern afs_int32 allocTaskId();
-
#ifdef xbsa
if (CONF_XBSA)
return (TC_BADTASK); /* LabelTape does not apply if XBSA */
ERROR_EXIT(code);
AFS_SIGSET_CLEAR();
- code = pthread_create(&pid, &tattr, restoreDbFromTape, (void *)*taskId);
+ code = pthread_create(&pid, &tattr, restoreDbFromTape, (void *)(intptr_t)*taskId);
AFS_SIGSET_RESTORE();
#else
code =
- LWP_CreateProcess(restoreDbFromTape, 32768, 1, (void *)*taskId,
+ LWP_CreateProcess(restoreDbFromTape, 32768, 1, (void *)(intptr_t)*taskId,
"Db restore", &pid);
#endif
*/
afs_int32
-STC_SaveDb(rxCall, archiveTime, taskId)
- struct rx_call *rxCall;
- Date archiveTime;
- afs_uint32 *taskId;
+STC_SaveDb(struct rx_call *call, Date archiveTime, afs_uint32 *taskId)
+{
+ afs_int32 code;
+
+ code = SSaveDb(call, archiveTime, taskId);
+ osi_auditU(call, TC_SaveDbEvent, code,
+ AUD_DATE, archiveTime, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SSaveDb(struct rx_call *rxCall, Date archiveTime, afs_uint32 *taskId)
{
#ifdef AFS_PTHREAD_ENV
pthread_t pid;
#else
PROCESS pid;
#endif
- statusP statusPtr;
+ statusP statusPtr = NULL;
afs_int32 code = 0;
struct saveDbIf *ptr;
- extern afs_int32 saveDbToTape();
- extern statusP createStatusNode();
- extern afs_int32 allocTaskId();
-
#ifdef xbsa
if (CONF_XBSA)
return (TC_BADTASK); /* LabelTape does not apply if XBSA */
*taskId = allocTaskId();
- ptr = (struct saveDbIf *)malloc(sizeof(struct saveDbIf));
+ ptr = malloc(sizeof(struct saveDbIf));
if (!ptr)
ERROR_EXIT(TC_NOMEMORY);
ptr->archiveTime = archiveTime;
*/
afs_int32
-STC_ScanDumps(acid, addDbFlag, taskId)
- struct rx_call *acid;
- afs_int32 addDbFlag;
- afs_uint32 *taskId;
+STC_ScanDumps(struct rx_call *call, afs_int32 addDbFlag, afs_uint32 *taskId)
+{
+ afs_int32 code;
+
+ code = SScanDumps(call, addDbFlag, taskId);
+ osi_auditU(call, TC_ScanDumpsEvent, code,
+ AUD_INT, addDbFlag, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SScanDumps(struct rx_call *acid, afs_int32 addDbFlag, afs_uint32 *taskId)
{
#ifdef AFS_PTHREAD_ENV
pthread_t pid;
PROCESS pid;
#endif
struct scanTapeIf *ptr;
- statusP statusPtr;
+ statusP statusPtr = NULL;
afs_int32 code = 0;
- extern afs_int32 ScanDumps();
- extern afs_int32 allocTaskId();
- extern statusP createStatusNode();
-
#ifdef xbsa
if (CONF_XBSA)
return (TC_BADTASK); /* ScanDumps does not apply if XBSA */
*taskId = allocTaskId();
- ptr = (struct scanTapeIf *)malloc(sizeof(*ptr));
+ ptr = malloc(sizeof(*ptr));
if (!ptr)
ERROR_EXIT(TC_NOMEMORY);
ptr->addDbFlag = addDbFlag;
*/
afs_int32
-STC_TCInfo(acid, tciptr)
- struct rx_call *acid;
- struct tc_tcInfo *tciptr;
+STC_TCInfo(struct rx_call *call, struct tc_tcInfo *ti)
+{
+ afs_int32 code;
+
+ code = STCInfo(call, ti);
+ osi_auditU(call, TC_TCInfoEvent, code, AUD_INT, ti->tcVersion, AUD_END);
+ return code;
+}
+
+static afs_int32
+STCInfo(struct rx_call *acid, struct tc_tcInfo *tciptr)
{
if (callPermitted(acid) == 0)
return (TC_NOTPERMITTED);
/* STC_DeleteDump
*/
afs_int32
-STC_DeleteDump(acid, dumpID, taskId)
- struct rx_call *acid;
- afs_uint32 dumpID;
- afs_uint32 *taskId;
+STC_DeleteDump(struct rx_call *call, afs_uint32 dumpID, afs_uint32 *taskId)
+{
+ afs_int32 code;
+
+ code = SDeleteDump(call, dumpID, taskId);
+ osi_auditU(call, TC_DeleteDumpEvent, code,
+ AUD_DATE, dumpID, AUD_INT, *taskId, AUD_END);
+ return code;
+}
+
+static afs_int32
+SDeleteDump(struct rx_call *acid, afs_uint32 dumpID, afs_uint32 *taskId)
{
- struct deleteDumpIf *ptr = 0;
- statusP statusPtr = 0;
afs_int32 code = TC_BADTASK; /* If not compiled -Dxbsa then fail */
#ifdef xbsa
+ struct deleteDumpIf *ptr = 0;
+ statusP statusPtr = 0;
#ifdef AFS_PTHREAD_ENV
pthread_t pid;
pthread_attr_t tattr;
PROCESS pid;
#endif
#endif
- extern afs_int32 DeleteDump();
- extern statusP createStatusNode();
- extern afs_int32 allocTaskId();
*taskId = 0;
if (!CONF_XBSA)
if (callPermitted(acid) == 0)
return (TC_NOTPERMITTED);
- ptr = (struct deleteDumpIf *)malloc(sizeof(*ptr));
+ ptr = malloc(sizeof(*ptr));
if (!ptr)
ERROR_EXIT(TC_NOMEMORY);
return (code);
}
-/* -----------------------------
- * misc. routines
- * -----------------------------
- */
-
-static
-CopyDumpDesc(toDump, fromDump)
- struct tc_dumpDesc *toDump;
- tc_dumpArray *fromDump;
-{
- struct tc_dumpDesc *toPtr, *fromPtr;
- int i;
-
- toPtr = toDump;
- fromPtr = fromDump->tc_dumpArray_val;
- for (i = 0; i < fromDump->tc_dumpArray_len; i++) {
- toPtr->vid = fromPtr->vid;
- toPtr->vtype = fromPtr->vtype;
- toPtr->partition = fromPtr->partition;
- toPtr->date = fromPtr->date;
- toPtr->cloneDate = fromPtr->cloneDate;
- toPtr->hostAddr = fromPtr->hostAddr;
- strcpy(toPtr->name, fromPtr->name);
- fromPtr++;
- toPtr++;
- }
- return 0;
-}
-
-
-static
-CopyRestoreDesc(toRestore, fromRestore)
- struct tc_restoreDesc *toRestore;
- tc_restoreArray *fromRestore;
-{
- struct tc_restoreDesc *toPtr, *fromPtr;
- int i;
-
- toPtr = toRestore;
- fromPtr = fromRestore->tc_restoreArray_val;
- for (i = 0; i < fromRestore->tc_restoreArray_len; i++) {
- toPtr->flags = fromPtr->flags;
- toPtr->position = fromPtr->position;
- strcpy(toPtr->tapeName, fromPtr->tapeName);
- toPtr->dbDumpId = fromPtr->dbDumpId;
- toPtr->initialDumpId = fromPtr->initialDumpId;
- toPtr->origVid = fromPtr->origVid;
- toPtr->vid = fromPtr->vid;
- toPtr->partition = fromPtr->partition;
- toPtr->dumpLevel = fromPtr->dumpLevel;
- toPtr->hostAddr = fromPtr->hostAddr;
- strcpy(toPtr->newName, fromPtr->newName);
- strcpy(toPtr->oldName, fromPtr->oldName);
- fromPtr++;
- toPtr++;
-
- }
- return 0;
-}
-
-static
-CopyTapeSetDesc(toPtr, fromPtr)
- struct tc_tapeSet *toPtr, *fromPtr;
-{
-
- toPtr->id = fromPtr->id;
- toPtr->maxTapes = fromPtr->maxTapes;
- toPtr->a = fromPtr->a;
- toPtr->b = fromPtr->b;
- strcpy(toPtr->tapeServer, fromPtr->tapeServer);
- strcpy(toPtr->format, fromPtr->format);
-
- toPtr->expDate = fromPtr->expDate;
- toPtr->expType = fromPtr->expType;
- return 0;
-}
git://git.openafs.org / openafs.git / blobdiff