--- /dev/null
+/*
+ * 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
+ */
+
+#ifdef xbsa
+
+#include <afs/param.h>
+#include <sys/types.h>
+#include <afs/stds.h>
+#include <stdio.h>
+
+
+#if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV)
+#include <dlfcn.h>
+#endif
+
+#include <errno.h>
+#include "butc_xbsa.h"
+#include <afs/butx.h>
+
+/* Global Definations */
+#define APPLTYPE "afs-butc"
+#define TDP_LIBNAME "libApiDS.a"
+#define FIRST_HANDLE 1
+#define NOHANDLE 0
+#define XAPI_FSINFO "FS for XOpen API"
+#define DIR_DELIMITER '/'
+#define STR_DIR_DELIMITER '/'
+
+xGlobal xopenGbl;
+char traceStr[DSM_MAX_RC_MSG_LENGTH+1];
+char traceStr2[(DSM_MAX_RC_MSG_LENGTH+1) - 30];
+char ourMsg[DSM_MAX_RC_MSG_LENGTH + 1];
+static int dsm_init = 0 ;
+
+/* >>> TSM function pointers. */
+dsInt16_t (* AFSdsmBeginQuery)( dsUint32_t dsmHandle, dsmQueryType queryType, dsmQueryBuff *queryBuffer);
+dsInt16_t (* AFSdsmGetNextQObj)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr) ;
+dsInt16_t (* AFSdsmEndQuery)( dsUint32_t dsmHandle);
+dsInt16_t (* AFSdsmRCMsg)( dsUint32_t dsmHandle, dsInt16_t dsmRC, char *msg);
+dsInt16_t (* AFSdsmLogEventEx)( dsUint32_t dsmHandle, dsmLogExIn_t *dsmLogExInP, dsmLogExOut_t *dsmLogExOutP);
+dsInt16_t (* AFSdsmTrace)( dsUint32_t dsmHandle, char * string );
+dsInt16_t (* AFSdsmTerminate)( dsUint32_t dsmHandle);
+dsInt16_t (* AFSdsmSendData)( dsUint32_t dsmHandle, DataBlk *dataBlkPtri);
+dsInt16_t (* AFSdsmBeginTxn)( dsUint32_t dsmHandle);
+dsInt16_t (* AFSdsmDeleteObj)( dsUint32_t dsmHandle, dsmDelType delType, dsmDelInfo delInfo);
+dsInt16_t (* AFSdsmEndTxn)( dsUint32_t dsmHandle, dsUint8_t vote, dsUint16_t *reason);
+void (* AFSdsmQueryApiVersion)( dsmApiVersion *apiVersionP);
+dsInt16_t (* AFSdsmInit)( dsUint32_t *dsmHandle, dsmApiVersion *dsmApiVersionP, char *clientNodeNameP, char *clientOwnerNameP, char *clientPasswordP, char *applicationType, char *configfile, char *options);
+dsInt16_t (* AFSdsmQuerySessInfo)( dsUint32_t dsmHandle, ApiSessInfo *SessInfoP);
+dsInt16_t (* AFSdsmBeginGetData)(dsUint32_t dsmHandle, dsBool_t mountWait, dsmGetType getType, dsmGetList *dsmGetObjListP);
+dsInt16_t (* AFSdsmGetObj)( dsUint32_t dsmHandle, ObjID *objIdP, DataBlk *dataBlkPtr);
+dsInt16_t (* AFSdsmEndGetObj)( dsUint32_t dsmHandle);
+dsInt16_t (* AFSdsmEndGetData)( dsUint32_t dsmHandle);
+dsInt16_t (* AFSdsmGetData)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr);
+dsInt16_t (* AFSdsmEndSendObj)( dsUint32_t dsmHandle);
+dsInt16_t (* AFSdsmRegisterFS)( dsUint32_t dsmHandle, regFSData *regFilespaceP);
+dsInt16_t (* AFSdsmBindMC)( dsUint32_t dsmHandle, dsmObjName *objNameP, dsmSendType sendType, mcBindKey *mcBindKeyP);
+dsInt16_t (* AFSdsmSendObj)( dsUint32_t dsmHandle, dsmSendType sendType, void *sendBuff, dsmObjName *objNameP, ObjAttr *objAttrPtr, DataBlk *dataBlkPtr);
+dsInt16_t (* AFSdsmChangePW)( dsUint32_t dsmHandle, char *oldPW, char *newPW);
+#if 0
+dsInt16_t (* AFSdsmCleanUp)( dsBool_t mtFlag);
+dsInt16_t (* AFSdsmDeleteAccess)( dsUint32_t dsmHandle, dsUint32_t ruleNum);
+dsInt16_t (* AFSdsmDeleteFS)( dsUint32_t dsmHandle, char *fsName, dsUint8_t repository);
+dsInt16_t (* AFSdsmEndGetDataEx)( dsmEndGetDataExIn_t *dsmEndGetDataExInP, dsmEndGetDataExOut_t *dsmEndGetDataExOutP);
+dsInt16_t (* AFSdsmEndSendObjEx)( dsmEndSendObjExIn_t *dsmEndSendObjExInP, dsmEndSendObjExOut_t *dsmEndSendObjExOutP);
+dsInt16_t (* AFSdsmEndTxnEx)( dsmEndTxnExIn_t *dsmEndTxnExInP, dsmEndTxnExOut_t *dsmEndTxnExOutP);
+dsInt16_t (* AFSdsmGroupHandler)( dsmGroupHandlerIn_t *dsmGroupHandlerInP, dsmGroupHandlerOut_t *dsmGroupHandlerOutP);
+dsInt16_t (* AFSdsmInitEx)( dsUint32_t *dsmHandleP, dsmInitExIn_t *dsmInitExInP, dsmInitExOut_t *dsmInitExOutP);
+dsInt16_t (* AFSdsmLogEvent)( dsUint32_t dsmHandle, logInfo *lopInfoP);
+dsInt16_t (* AFSdsmQueryAccess)( dsUint32_t dsmHandle, qryRespAccessData **accessListP, dsUint16_t *numberOfRules);
+void (* AFSdsmQueryApiVersionEx)( dsmApiVersionEx *apiVersionP);
+dsInt16_t (* AFSdsmQueryCliOptions)( optStruct *optstructP);
+dsInt16_t (* AFSdsmQuerySessOptions)( dsUint32_t dsmHandle, optStruct *optstructP);
+dsInt16_t (* AFSdsmRenameObj)( dsmRenameIn_t *dsmRenameInP, dsmRenameOut_t *dsmRenameOutP);
+dsInt16_t (* AFSdsmSetAccess)( dsUint32_t dsmHandle, dsmAccessType accessType, dsmObjName *objNameP, char *node, char *owner);
+dsInt16_t (* AFSdsmSetUp)( dsBool_t mtFlag, envSetUp *envSetUpPi);
+dsInt16_t (* AFSdsmUpdateFS)( dsUint32_t dsmHandle, char *fs, dsmFSUpd *fsUpdP, dsUint32_t fsUpdAct);
+dsInt16_t (* AFSdsmUpdateObj)( dsUint32_t dsmHandle, dsmSendType sendType, void *sendBuff, dsmObjName *objNameP, ObjAttr *objAttrPtr, dsUint32_t objUpdAct);
+#endif
+/* <<< TSM function pointers. */
+
+typedef struct s_delList {
+ struct s_delList *next;
+ ObjID objId;
+} delList;
+
+static dsInt16_t buildList(
+ dsUint32_t dsmHandle,
+ dsmObjName *objNameP,
+ delList **llHeadPP,
+ delList **llTailPP)
+{
+ dsInt16_t rc;
+ qryArchiveData queryBuffer; /* for query Archive*/
+ qryRespArchiveData qaDataArea;
+ DataBlk qDataBlkArea;
+ char descrStar[] = "*";
+ delList *lnew = NULL, *ll = NULL;
+
+ queryBuffer.stVersion = qryArchiveDataVersion ;
+ queryBuffer.objName = objNameP;
+ queryBuffer.owner = xopenGbl.dsmSessInfo.owner;
+ queryBuffer.insDateLowerBound.year = DATE_MINUS_INFINITE;
+ queryBuffer.insDateUpperBound.year = DATE_PLUS_INFINITE;
+ queryBuffer.expDateLowerBound.year = DATE_MINUS_INFINITE;
+ queryBuffer.expDateUpperBound.year = DATE_PLUS_INFINITE;
+ queryBuffer.descr = descrStar;
+
+ if ((rc=AFSdsmBeginQuery(dsmHandle, qtArchive,
+ (void *)&queryBuffer )) != DSM_RC_OK)
+ {
+ XOPENRETURN(dsmHandle,"buildList(AFSdsmBeginQuery)",rc,__FILE__,__LINE__);
+ }
+ qaDataArea.stVersion = qryRespArchiveDataVersion;
+ qDataBlkArea.stVersion = DataBlkVersion ;
+ qDataBlkArea.bufferPtr = (char *)&qaDataArea;
+ qDataBlkArea.bufferLen = sizeof(qryRespArchiveData);
+ while ((rc = AFSdsmGetNextQObj(dsmHandle, &qDataBlkArea)) == DSM_RC_MORE_DATA)
+ {
+ if (!(lnew = (delList *)dsMalloc(sizeof(delList))))
+ XOPENRETURN(dsmHandle,"buildList(AFSdsmGetNextQObj)",
+ DSM_RC_NO_MEMORY,__FILE__,__LINE__);
+
+ if (!*llHeadPP)
+ {
+ *llHeadPP = lnew;
+ *llTailPP = lnew;
+ }
+ else
+ {
+ ll = *llTailPP;
+ ll->next = lnew;
+ *llTailPP = lnew;
+ }
+
+ lnew->next = NULL;
+ lnew->objId.hi = qaDataArea.objId.hi;
+ lnew->objId.lo = qaDataArea.objId.lo;
+ }
+
+ if (rc != DSM_RC_FINISHED)
+ {
+ AFSdsmEndQuery(dsmHandle);
+ XOPENRETURN(dsmHandle,"buildList(AFSdsmGetNextQObj)",
+ rc,__FILE__,__LINE__);
+ }
+
+ if ((rc = AFSdsmEndQuery(dsmHandle)) != DSM_RC_OK)
+ {
+ sprintf(traceStr2, "buildList: AFSdsmEndQuery rc = %d", rc);
+ ourTrace(dsmHandle,TrFL,traceStr2);
+ }
+ XOPENRETURN(dsmHandle,"buildList",rc,__FILE__,__LINE__);
+}
+
+static dsInt16_t freeList(
+ delList **llHeadPP,
+ delList **llTailPP)
+{
+
+ delList *ll;
+ ll = *llHeadPP;
+ while (ll)
+ {
+ *llHeadPP = ll->next;
+ dsFree(ll);
+ ll = *llHeadPP;
+ }
+ *llHeadPP = NULL;
+ *llTailPP = NULL;
+ XOPENRETURN(0,"freeList",0,__FILE__,__LINE__);
+}
+
+void ourTrace(long BSAHandle,
+ char *fileName,
+ int lineNumber,
+ char *traceStr2)
+{
+
+ sprintf(traceStr,"%s (%d) ",fileName, lineNumber);
+
+ if (traceStr2 != NULL && *traceStr2 != '\0')
+ strcat(traceStr, traceStr2);
+
+ AFSdsmTrace(BSAHandle, traceStr);
+ return;
+}
+
+void ourLogEvent_Ex(dsUint32_t dsmHandle, dsmLogType type, char *message,
+ char *appMsg, dsmLogSeverity severity)
+{
+ dsmLogExIn_t dsmLogIn;
+ dsmLogExOut_t dsmLogOut;
+ dsInt16_t rc = 0;
+ memset(&dsmLogOut, '\0', sizeof(dsmLogExOut_t));
+
+ if (dsmHandle)
+ {
+ dsmLogIn.stVersion = dsmLogExInVersion;
+ dsmLogIn.severity = severity;
+ dsmLogIn.logType = type;
+
+ strcpy(dsmLogIn.appMsgID, appMsg);
+ dsmLogIn.message = message;
+ rc = AFSdsmLogEventEx(dsmHandle, &dsmLogIn, &dsmLogOut);
+ }
+}
+
+char* ourRCMsg(dsInt16_t ourRC, char *msgPrefix)
+{
+ char appStr[BSA_MAX_DESC];
+ char *chP;
+ int bytesToCp;
+
+ memset(&ourMsg, 0x00, DSM_MAX_RC_MSG_LENGTH + 1);
+ if(msgPrefix != NULL)
+ {
+ /*================================================================
+ call stdXOpenMsgMap if return code values are within the TSM
+ return code range (96 - 104). Reformat the message prefix
+ (ANS0660 - ANS0668).
+ ================================================================*/
+ if ((ourRC >= custMin_retcode) && (ourRC <= custMax_retcode))
+ {
+ stdXOpenMsgMap(ourRC, ourMsg);
+ /* set standard XOpen message prefix range: 660 - 668 */
+ ourRC = ((ourRC * 10) / 16) + (ourRC % 16) + 600;
+ sprintf(msgPrefix, "ANSO%d", ourRC);
+ }
+ else
+ /*===============================================================
+ call dsmRCMsg if return code values other then the above ranges.
+ Get message prefix from the return message of dsmRCMsg.
+ ===============================================================*/
+ {
+ AFSdsmRCMsg(NOHANDLE, ourRC, ourMsg);
+ /*=========================================================
+ search for the first ' ' and copy from beginning of string
+ until before the two charecter before ' '.
+ e.g. To get the code value from the messages of
+ "ANS1038S Invalid option specified", we only want to
+ get strings "ANS1038".
+ ========================================================*/
+ chP = (char *) strchr(ourMsg, ' ');
+ bytesToCp = strlen(ourMsg) - (strlen(chP) + 1);
+ strncpy(appStr, ourMsg, bytesToCp);
+ sprintf(msgPrefix, "%s", appStr);
+ }
+ }
+return ourMsg;
+} /* ourRCMsg() */
+
+void StrUpper(char *s)
+{
+ while (*s != '\0')
+ {
+ if (isalpha((int)(unsigned char)*s))
+ *s = (char)toupper((int)(unsigned char)*s);
+ s++;
+
+ } /* end while */
+} /* StrUpper() */
+
+BSA_Int16 xparsePath(
+ long BSAHandle,
+ char *pathname,
+ char *hl,
+ char *ll)
+{
+ /*=== code taken from dscparse.c ParseDestOperand function ===*/
+
+ dsInt16_t opLen;
+ dsInt16_t x;
+
+ *hl = *ll = '\0';
+
+ strcpy(hl, pathname); /* use hl as working area */
+ if ((opLen = strlen(hl)) > 0)
+ {
+ /*=== Find the ll portion of the name ===*/
+ #ifdef MBCS
+ {
+ char *llstart;
+ llstart = strrchr(hl,DIR_DELIMITER);
+ if (llstart == NULL)
+ x = 0;
+ else
+ x = llstart - hl;
+ }
+ #else
+ for (x = opLen-1; x>0 && hl[x]!=DIR_DELIMITER; x--);
+ #endif
+
+ /*=== If there is no leading delimiter then add one ===*/
+ if (hl[x] != DIR_DELIMITER)
+ strcpy(ll, STR_DIR_DELIMITER);
+
+ strncat(ll, hl+x, opLen-x);
+
+ hl[x] = '\0'; /* Shorten hl by length of ll */
+ }
+ return 0;
+}
+
+BSA_Int16 xlateRC(
+ long BSAHandle,
+ BSA_Int16 dsmRC,
+ BSA_Int16 *bsaRCP)
+
+{
+ switch (dsmRC)
+ {
+ case DSM_RC_OK:
+ *bsaRCP=BSA_RC_OK; break;
+
+ case DSM_RC_ABORT_ACTIVE_NOT_FOUND:
+ *bsaRCP=BSA_RC_ABORT_ACTIVE_NOT_FOUND; break;
+
+ case DSM_RC_ABORT_SYSTEM_ERROR:
+ *bsaRCP=BSA_RC_ABORT_SYSTEM_ERROR; break;
+
+ case DSM_RC_ABORT_BAD_VERIFIER:
+ case DSM_RC_AUTH_FAILURE:
+ case DSM_RC_REJECT_ID_UNKNOWN:
+ case DSM_RC_REJECT_DUPLICATE_ID:
+ *bsaRCP=BSA_RC_AUTHENTICATION_FAILURE; break;
+
+ case DSM_RC_BAD_CALL_SEQUENCE:
+ *bsaRCP=BSA_RC_BAD_CALL_SEQUENCE; break;
+
+ case DSM_RC_INVALID_DS_HANDLE:
+ *bsaRCP=BSA_RC_BAD_HANDLE; break;
+
+ case DSM_RC_BUFF_TOO_SMALL:
+ *bsaRCP=BSA_RC_BUFFER_TOO_SMALL; break;
+
+ case DSM_RC_DESC_TOOLONG:
+ *bsaRCP=BSA_RC_DESC_TOO_LONG; break;
+
+ case DSM_RC_FILESPACE_TOOLONG:
+ *bsaRCP=BSA_RC_OBJECTSPACE_TOO_LONG; break;
+
+ /* some other condition here ? */
+ case DSM_RC_PASSWD_TOOLONG:
+ *bsaRCP=BSA_RC_INVALID_TOKEN; break;
+
+ case DSM_RC_INVALID_VOTE:
+ *bsaRCP=BSA_RC_INVALID_VOTE; break;
+
+ case DSM_RC_INVALID_OPT:
+ *bsaRCP=BSA_RC_INVALID_KEYWORD; break;
+
+ /* ? what conditions cause this - object already exists ?
+ case DSM_RC_?:
+ *bsaRCP=BSA_RC_MATCH_EXISTS; break;
+ */
+
+ case DSM_RC_MORE_DATA:
+ *bsaRCP=BSA_RC_MORE_DATA; break;
+
+ /* not supported - for QueryAccessRule
+ case :
+ *bsaRCP=BSA_RC_MORE_RULES; break;
+ */
+
+ case DSM_RC_NEWPW_REQD:
+ *bsaRCP=BSA_RC_NEWTOKEN_REQD; break;
+
+ case DSM_RC_ABORT_NO_MATCH:
+ case DSM_RC_FILE_SPACE_NOT_FOUND:
+ /*=== rc for query ===*/
+ *bsaRCP=BSA_RC_NO_MATCH; break;
+ /*=== if this return code comes on Delete, use OBJECT_NOT_FOUND
+ - see xopndel.c ===*/
+
+ case DSM_RC_FINISHED:
+ *bsaRCP=BSA_RC_NO_MORE_DATA; break;
+
+ case DSM_RC_ABORT_NO_LOG_SPACE:
+ case DSM_RC_ABORT_NO_DB_SPACE:
+ case DSM_RC_ABORT_NO_MEMORY:
+ case DSM_RC_ABORT_NO_REPOSIT_SPACE:
+ case DSM_RC_REJECT_NO_RESOURCES:
+ case DSM_RC_REJECT_NO_MEMORY:
+ case DSM_RC_REJECT_NO_DB_SPACE:
+ case DSM_RC_REJECT_NO_LOG_SPACE:
+ *bsaRCP=BSA_RC_NO_RESOURCES; break;
+
+ case DSM_RC_NULL_DATABLKPTR:
+ *bsaRCP=BSA_RC_NULL_DATABLKPTR; break;
+
+ case DSM_RC_NULL_OBJNAME:
+ *bsaRCP=BSA_RC_NULL_OBJNAME; break;
+
+ case DSM_RC_NULL_BUFPTR:
+ *bsaRCP=BSA_RC_NULL_POINTER; break;
+
+ /* not supported - for DeleteAccessRule
+ case :
+ *bsaRCP=BSA_RC_NULL_RULEID; break;
+ */
+
+ case DSM_RC_HL_TOOLONG:
+ case DSM_RC_LL_TOOLONG:
+ *bsaRCP=BSA_RC_OBJECT_NAME_TOO_LONG; break;
+
+ /* not supported - for DeletePolicyDomain
+ case :
+ *bsaRCP=BSA_RC_OBJECT_NOT_EMPTY; break;
+ */
+
+ /* same as NO_MATCH for DeleteObject
+ case :
+ *bsaRCP=BSA_RC_OBJECT_NOT_FOUND; break;
+ */
+
+ case DSM_RC_OBJINFO_TOOLONG:
+ *bsaRCP=BSA_RC_OBJINFO_TOO_LONG; break;
+
+ /* same as BSA_RC_OBJECT_NAME_TOO_LONG
+ case :
+ *bsaRCP=BSA_RC_OBJNAME_TOO_LONG; break;
+ */
+
+ /* not supported - for CreatePolicySet, etc
+ case :
+ *bsaRCP=BSA_RC_OPERATION_NOT_AUTHORIZED; break;
+ */
+
+ case DSM_RC_OLDPW_REQD:
+ *bsaRCP=BSA_RC_OLDTOKEN_REQD; break;
+
+ case DSM_RC_REJECT_VERIFIER_EXPIRED:
+ *bsaRCP=BSA_RC_TOKEN_EXPIRED; break;
+
+ case DSM_RC_WILL_ABORT:
+ case DSM_RC_CHECK_REASON_CODE:
+ *bsaRCP=BSA_RC_TXN_ABORTED; break;
+
+ case DSM_RC_UNMATCHED_QUOTE:
+ *bsaRCP=BSA_RC_UNMATCHED_QUOTE; break;
+
+ /* not supported - for DeleteUser
+ case :
+ *bsaRCP=BSA_RC_USER_OWNS_OBJECT; break;
+ */
+
+ default:
+ {
+ /*=========================================================
+ No suitable match, so print message in log, if we still
+ have a handle. AFSdsmInit calls ApiCleanUp in certain error
+ situations. We lose the handle in those cases so check
+ for it.
+ =========================================================*/
+
+ char rcMsg[DSM_MAX_RC_MSG_LENGTH] ;
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+ dsUint32_t dsmHandle;
+
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ if (BSAHandle)
+ {
+ dsmHandle = BSAHandle;
+ AFSdsmRCMsg(dsmHandle,dsmRC,rcMsg) ;
+ strcat(rcMsg, "\n");
+ sprintf(traceStr2,
+ "xlateRC - %s", rcMsg);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ strcpy(ourMessage, ourRCMsg(dsmRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ }
+
+ *bsaRCP = ADSM_RC_ERROR;
+ }
+ }
+
+ /*=== trace only if we have a valid handle ===*/
+ if (dsmRC && BSAHandle)
+ {
+ sprintf(traceStr2, "xlateRC: TSM rc >%d< , BSA rc >%d<", dsmRC, *bsaRCP);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ }
+ return DSM_RC_OK ;
+}
+
+void stdXOpenMsgMap(dsInt16_t rc, char *msg)
+{
+ switch(rc)
+ {
+ case ADSM_RC_ERROR:
+ strcpy(msg, "TSM rc error, see ADSM error log.");
+ case ADSM_RC_INVALID_NODE:
+ strcpy(msg, "BSAObjectOwner doesn't match value session Init.");
+ break;
+
+ case ADSM_RC_INVALID_COPYTYPE:
+ strcpy(msg, "Invalid copy type.");
+ break;
+
+ case ADSM_RC_INVALID_OBJTYPE:
+ strcpy(msg, "Invalid object type.");
+ break;
+
+ case ADSM_RC_INVALID_STATUS:
+ strcpy(msg, "Invalid Object Status.");
+ break;
+
+ case ADSM_RC_INVALID_ST_VER:
+ strcpy(msg, "Invalid object descriptor structure version.");
+ break;
+
+ case ADSM_RC_OWNER_TOO_LONG:
+ strcpy(msg, "Object owner name too long.");
+ break;
+
+ case ADSM_RC_PSWD_TOO_LONG:
+ strcpy(msg, "Client password too long.");
+ break;
+
+ case ADSM_RC_PSWD_GEN:
+ strcpy(msg, "Password input required .");
+ break;
+
+ default:
+ strcpy(msg, "No message available");
+ break;
+ }
+}
+
+BSA_Int16 fillArchiveResp(
+long BSAHandle,
+ObjectDescriptor *BSAobjDescP,
+qryRespArchiveData *respArchiveP
+)
+{
+ XAPIObjInfo *xapiObjInfoP;
+
+ strcpy(BSAobjDescP->Owner.appObjectOwner, respArchiveP->owner);
+ strcpy(BSAobjDescP->objName.objectSpaceName, respArchiveP->objName.fs);
+
+ /*=== concatenate hl and ll for pathName ===*/
+ strcpy(BSAobjDescP->objName.pathName, respArchiveP->objName.hl);
+ strcat(BSAobjDescP->objName.pathName, respArchiveP->objName.ll);
+
+ BSAobjDescP->createTime.tm_year = respArchiveP->insDate.year-1900;
+ BSAobjDescP->createTime.tm_mon = respArchiveP->insDate.month-1;
+ BSAobjDescP->createTime.tm_mday = respArchiveP->insDate.day ;
+ BSAobjDescP->createTime.tm_hour = respArchiveP->insDate.hour ;
+ BSAobjDescP->createTime.tm_min = respArchiveP->insDate.minute ;
+ BSAobjDescP->createTime.tm_sec = respArchiveP->insDate.second ;
+
+ BSAobjDescP->copyId.left = respArchiveP->objId.hi;
+ BSAobjDescP->copyId.right = respArchiveP->objId.lo;
+
+ BSAobjDescP->restoreOrder.left = respArchiveP->restoreOrderExt.lo_hi;
+ BSAobjDescP->restoreOrder.right = respArchiveP->restoreOrderExt.lo_lo;
+
+ strcpy(BSAobjDescP->lGName, respArchiveP->mcName) ;
+
+ xapiObjInfoP = (XAPIObjInfo *)&(respArchiveP->objInfo);
+ BSAobjDescP->size.left = xapiObjInfoP->size.left;
+ BSAobjDescP->size.right= xapiObjInfoP->size.right;
+ strcpy(BSAobjDescP->resourceType, xapiObjInfoP->resourceType);
+ strcpy(BSAobjDescP->desc, xapiObjInfoP->partDesc);
+ strcpy(BSAobjDescP->objectInfo, xapiObjInfoP->partObjInfo);
+
+ if (respArchiveP->objName.objType == DSM_OBJ_DIRECTORY)
+ BSAobjDescP->objectType = BSAObjectType_DIRECTORY;
+ else
+ BSAobjDescP->objectType = BSAObjectType_FILE;
+ /*=== future - type DATABASE ?? ===*/
+
+ BSAobjDescP->status = BSAObjectStatus_ACTIVE;
+ XOPENRETURN(BSAHandle, "fillArchiveResp",
+ BSA_RC_SUCCESS,__FILE__,__LINE__);
+}
+
+BSA_Int16 fillBackupResp(
+long BSAHandle,
+ObjectDescriptor *BSAobjDescP,
+qryRespBackupData *respBackupP
+)
+{
+ XAPIObjInfo *xapiObjInfoP;
+
+ strcpy(BSAobjDescP->Owner.appObjectOwner, respBackupP->owner);
+ strcpy(BSAobjDescP->objName.objectSpaceName, respBackupP->objName.fs);
+
+ /*=== concatenate hl and ll for pathName ===*/
+ strcpy(BSAobjDescP->objName.pathName, respBackupP->objName.hl);
+ strcat(BSAobjDescP->objName.pathName, respBackupP->objName.ll);
+
+ BSAobjDescP->createTime.tm_year = respBackupP->insDate.year-1900;
+ BSAobjDescP->createTime.tm_mon = respBackupP->insDate.month-1;
+ BSAobjDescP->createTime.tm_mday = respBackupP->insDate.day ;
+ BSAobjDescP->createTime.tm_hour = respBackupP->insDate.hour ;
+ BSAobjDescP->createTime.tm_min = respBackupP->insDate.minute ;
+ BSAobjDescP->createTime.tm_sec = respBackupP->insDate.second ;
+
+ BSAobjDescP->copyId.left = respBackupP->objId.hi;
+ BSAobjDescP->copyId.right = respBackupP->objId.lo;
+
+ BSAobjDescP->restoreOrder.left = respBackupP->restoreOrderExt.lo_hi;
+ BSAobjDescP->restoreOrder.right = respBackupP->restoreOrderExt.lo_lo;
+
+ strcpy(BSAobjDescP->lGName, respBackupP->mcName) ;
+
+ xapiObjInfoP = (XAPIObjInfo *)&(respBackupP->objInfo);
+ BSAobjDescP->size.left = xapiObjInfoP->size.left;
+ BSAobjDescP->size.right= xapiObjInfoP->size.right;
+ strcpy(BSAobjDescP->resourceType, xapiObjInfoP->resourceType);
+ strcpy(BSAobjDescP->desc, xapiObjInfoP->partDesc);
+ strcpy(BSAobjDescP->objectInfo, xapiObjInfoP->partObjInfo);
+
+ if (respBackupP->objName.objType == DSM_OBJ_DIRECTORY)
+ BSAobjDescP->objectType = BSAObjectType_DIRECTORY;
+ else
+ BSAobjDescP->objectType = BSAObjectType_FILE;
+ /*=== future - type DATABASE ?? ===*/
+
+ if (respBackupP->objState == DSM_ACTIVE)
+ BSAobjDescP->status = BSAObjectStatus_ACTIVE;
+ else
+ BSAobjDescP->status = BSAObjectStatus_INACTIVE;
+ /*=== ?? check for any other ===*/
+
+ XOPENRETURN(BSAHandle, "fillRBackupResp",
+ BSA_RC_SUCCESS,__FILE__,__LINE__);
+}
+
+
+afs_int32 dsm_MountLibrary()
+{
+void * dynlib = NULL ;
+
+#ifdef DEBUG_BUTC
+ printf("dsm_MountLibrary : inside function. \n");
+#endif
+#if defined(AFS_AIX_ENV)
+ dynlib = dlopen("/usr/lib/libApiDS.a(dsmapish.o)", RTLD_NOW | RTLD_LOCAL | RTLD_MEMBER);
+#elif defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV)
+ dynlib = dlopen("/usr/lib/libApiDS.so", RTLD_NOW | RTLD_LOCAL);
+#else
+ dynlib = NULL;
+#endif
+
+ if (dynlib == NULL) {
+ ELog(0,"dsm_MountLibrary: The dlopen call to load the libApiDS shared library failed\n");
+ return(BUTX_NOLIBRARY);
+ }
+
+#ifdef DEBUG_BUTC
+ printf("dsm_MountLibrary : SUCCESS to Open the libApiDS shared library. \n");
+#endif
+#if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV)
+ AFSdsmBeginQuery = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmQueryType queryType, dsmQueryBuff *queryBuffer)) dlsym((void *)dynlib, "dsmBeginQuery");
+ AFSdsmGetNextQObj = (dsInt16_t (*)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmGetNextQObj") ;
+ AFSdsmEndQuery = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndQuery");
+ AFSdsmRCMsg = (dsInt16_t (*)( dsUint32_t dsmHandle, dsInt16_t dsmRC, char *msg))dlsym((void *)dynlib, "dsmRCMsg");
+ AFSdsmLogEventEx = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmLogExIn_t *dsmLogExInP, dsmLogExOut_t *dsmLogExOutP))dlsym((void *)dynlib, "dsmLogEventEx");
+ AFSdsmTrace = (dsInt16_t (*)( dsUint32_t dsmHandle, char * string ))dlsym((void *)dynlib, "dsmTrace");
+ AFSdsmTerminate = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmTerminate");
+ AFSdsmSendData = (dsInt16_t (*)( dsUint32_t dsmHandle, DataBlk *dataBlkPtri))dlsym((void *)dynlib, "dsmSendData");
+ AFSdsmBeginTxn = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmBeginTxn");
+ AFSdsmDeleteObj = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmDelType delType, dsmDelInfo delInfo))dlsym((void *)dynlib, "dsmDeleteObj");
+ AFSdsmEndTxn = (dsInt16_t (*)( dsUint32_t dsmHandle, dsUint8_t vote, dsUint16_t *reason))dlsym((void *)dynlib, "dsmEndTxn");
+ AFSdsmQueryApiVersion = (void (*)( dsmApiVersion *apiVersionP))dlsym((void *)dynlib, "dsmQueryApiVersion");
+ AFSdsmInit = (dsInt16_t (*)( dsUint32_t *dsmHandle, dsmApiVersion *dsmApiVersionP, char *clientNodeNameP, char *clientOwnerNameP, char *clientPasswordP, char *applicationType, char *configfile, char *options))dlsym((void *)dynlib, "dsmInit");
+ AFSdsmQuerySessInfo = (dsInt16_t (*)( dsUint32_t dsmHandle, ApiSessInfo *SessInfoP))dlsym((void *)dynlib, "dsmQuerySessInfo");
+ AFSdsmBeginGetData = (dsInt16_t (*)(dsUint32_t dsmHandle, dsBool_t mountWait, dsmGetType getType, dsmGetList *dsmGetObjListP))dlsym((void *)dynlib, "dsmBeginGetData");
+ AFSdsmGetObj = (dsInt16_t (*)( dsUint32_t dsmHandle, ObjID *objIdP, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmGetObj");
+ AFSdsmEndGetObj = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndGetObj");
+ AFSdsmEndGetData = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndGetData");
+ AFSdsmGetData = (dsInt16_t (*)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmGetData");
+ AFSdsmEndSendObj = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndSendObj");
+ AFSdsmRegisterFS = (dsInt16_t (*)( dsUint32_t dsmHandle, regFSData *regFilespaceP))dlsym((void *)dynlib, "dsmRegisterFS");
+ AFSdsmBindMC = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmObjName *objNameP, dsmSendType sendType, mcBindKey *mcBindKeyP))dlsym((void *)dynlib, "dsmBindMC");
+ AFSdsmSendObj = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmSendType sendType, void *sendBuff, dsmObjName *objNameP, ObjAttr *objAttrPtr, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmSendObj");
+ AFSdsmChangePW = (dsInt16_t (*)( dsUint32_t dsmHandle, char *oldPW, char *newPW))dlsym((void *)dynlib, "dsmChangePW");
+
+
+ if ( !AFSdsmBeginQuery || !AFSdsmGetNextQObj || !AFSdsmEndQuery ||
+ !AFSdsmRCMsg || !AFSdsmLogEventEx || !AFSdsmTrace ||
+ !AFSdsmTerminate || !AFSdsmEndGetObj || !AFSdsmSendData ||
+ !AFSdsmBeginTxn || !AFSdsmDeleteObj || !AFSdsmEndGetData ||
+ !AFSdsmEndTxn || !AFSdsmQueryApiVersion || !AFSdsmInit ||
+ !AFSdsmGetData || !AFSdsmQuerySessInfo || !AFSdsmBeginGetData ||
+ !AFSdsmGetObj || !AFSdsmEndSendObj || !AFSdsmRegisterFS ||
+ !AFSdsmBindMC || !AFSdsmSendObj || !AFSdsmChangePW )
+ {
+ ELog(0,"dsm_MountLibrary: The dlopen call to load the TSM shared library failed\n");
+ return(BUTX_NOLIBRARY);
+ }
+#ifdef DEBUG_BUTC
+ printf("dsm_MountLibrary : All TSM function pointers initialized. \n");
+#endif
+
+#endif
+ dsm_init = 1 ;
+#ifdef DEBUG_BUTC
+ printf("dsm_MountLibrary : leaving function. \n");
+#endif
+ return 0 ;
+
+}
+
+BSA_Int16 BSAInit( long *BSAHandleP,
+ SecurityToken *clientPasswordP,
+ ObjectOwner *objectOwnerP,
+ char **envP )
+{
+ dsInt16_t rc = 0;
+ dsInt16_t saverc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle; /* use diff field when talking to base
+ code in case either format changes */
+ dsmApiVersion xapiHdrVer; /* Xopen API build version */
+ dsmApiVersion apiLibVer; /* Xopen API Libary version */
+
+ dsUint32_t xapiVersion, apiVersion;
+ envSetUp dsmEnvSetUp;
+
+ /*==================================================================
+ Today the BSA constants have the same values as the DSM constants.
+ If this changes, use strncpy.
+ =================================================================*/
+
+ char rcmsg[DSM_MAX_RC_MSG_LENGTH + 1];
+ char dsmNode[DSM_MAX_NODE_LENGTH];
+ char dsmOwner[DSM_MAX_OWNER_LENGTH];
+ char dsmPswd[DSM_MAX_VERIFIER_LENGTH];
+ char *dsmNodeP;
+ char *dsmOwnerP;
+ char *dsmPswdP;
+ char options[DSM_MAX_RC_MSG_LENGTH];
+ char *optionP = NULL;
+ char TDPLibName[BSA_MAX_DESC];
+ char TDPILibName[BSA_MAX_DESC];
+ int i=0;
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+ char rcMsg[DSM_MAX_RC_MSG_LENGTH + 1];
+
+ dsmHandle = 0;
+ *BSAHandleP = 0;
+
+#ifdef DEBUG_BUTC
+ printf("BSAInit : inside function. \n");
+#endif
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(rcMsg, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ /*==================================================================
+ Trace won't work before AFSdsmInit, moved to after call to AFSdsmInit
+ The XOpen library is built by statically linking with the API and
+ client common modules. So, the version checking is unnecessary.
+ We'll fill in the value anyway for consistency.
+ ==================================================================*/
+ memset(&xapiHdrVer,0x00,sizeof(dsmApiVersion));
+ memset(&apiLibVer,0x00,sizeof(dsmApiVersion));
+ memset(&dsmEnvSetUp,0x00,sizeof(envSetUp));
+
+ AFSdsmQueryApiVersion(&apiLibVer);
+
+ xapiHdrVer.version = DSM_API_VERSION; /* Set the applications */
+ xapiHdrVer.release = DSM_API_RELEASE; /* compile time version. */
+ xapiHdrVer.level = DSM_API_LEVEL; /* version */
+
+ xapiVersion = (1000 * DSM_API_VERSION) + (100 * DSM_API_RELEASE)
+ + DSM_API_LEVEL;
+
+ apiVersion = (1000 * apiLibVer.version) + (100 * apiLibVer.release)
+ + apiLibVer.level;
+
+ /* check for compatibility problems */
+ if (apiVersion < xapiVersion)
+ return ADSM_RC_ERROR;
+
+ /*==== Init global area ===*/
+
+ memset(&xopenGbl,0x00, sizeof(xGlobal)); /* Zero out block. */
+
+ memset(dsmNode,0x00,DSM_MAX_NODE_LENGTH);
+ memset(dsmOwner,0x00,DSM_MAX_OWNER_LENGTH);
+ memset(dsmPswd,0x00,DSM_MAX_VERIFIER_LENGTH);
+ memset(options,0x00,DSM_MAX_RC_MSG_LENGTH);
+ memset(TDPLibName,0x00,BSA_MAX_DESC);
+ memset(TDPILibName,0x00,BSA_MAX_DESC);
+
+ memset(rcmsg, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+
+ /*=== Validate the inputs ===*/
+
+ if (objectOwnerP)
+ {
+ if (strlen(objectOwnerP->bsaObjectOwner) > BSA_MAX_BSAOBJECT_OWNER)
+ {
+ bsaRC = ADSM_RC_OWNER_TOO_LONG;
+ return(bsaRC);
+ }
+
+ if (strlen(objectOwnerP->appObjectOwner) > BSA_MAX_APPOBJECT_OWNER)
+ {
+ bsaRC = ADSM_RC_OWNER_TOO_LONG;
+ return(bsaRC);
+ }
+
+ if (objectOwnerP->bsaObjectOwner[0] == '\0') /* empty string */
+ dsmNodeP = NULL;
+ else
+ {
+ strcpy(dsmNode, objectOwnerP->bsaObjectOwner);
+ dsmNodeP = dsmNode;
+ }
+
+ if (objectOwnerP->appObjectOwner[0] == '\0') /* empty string */
+ dsmOwnerP = NULL;
+ else
+ {
+ strcpy(dsmOwner, objectOwnerP->appObjectOwner);
+ dsmOwnerP = dsmOwner;
+ }
+ }
+ else
+ {
+ dsmNodeP = NULL;
+ dsmOwnerP = NULL;
+ }
+
+ if (clientPasswordP != NULL)
+ {
+ if (strlen((const char *)clientPasswordP) > BSA_MAX_TOKEN_SIZE)
+ {
+ bsaRC = ADSM_RC_PSWD_TOO_LONG;
+ return(bsaRC);
+ }
+
+ strcpy(dsmPswd, (const char *)clientPasswordP);
+ dsmPswdP = dsmPswd;
+ }
+ else
+ dsmPswdP = NULL;
+ {
+ while ((envP[i] != NULL) && (envP[i] != '\0'))
+ {
+ strcat(options, "-");
+ strcat(options, envP[i]);
+ if ((envP[i+1] != NULL) && (envP[i+1] != '\0'))
+ strcat(options, " ");
+ i++;
+ }
+
+ if (options[0] == '\0') /* empty string */
+ optionP = NULL;
+ else
+ optionP = options;
+
+ rc = AFSdsmInit(&dsmHandle, /* On return contains session handle. */
+ &xapiHdrVer, /* Version of the API we are using. */
+ dsmNodeP, /* node name */
+ dsmOwnerP, /* owner name */
+ dsmPswdP, /* password */
+ APPLTYPE, /* Name of our node type. */
+ NULL, /* no API config file name */
+ optionP); /* option string */
+ }
+
+ if (rc == DSM_RC_OK)
+ {
+ /*=== now that AFSdsmInit issued, we can trace ===*/
+ sprintf(traceStr2,
+ "BSAInit: original bsaOwner=%s, appOwner=%s, token=%s, Appl Type=%s, options=%s.",
+ dsmNode, dsmOwner, dsmPswd, APPLTYPE, options);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ {
+ strcpy(TDPLibName, TDP_LIBNAME);
+ sprintf(traceStr2,
+ "BSAInit: Using TSM Native API library : %s", TDPLibName);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ }
+ }
+
+
+ /*=================================================================
+ If the password expired, continue initialization so the session
+ can continue.
+
+ Save the 'password expired' rc away, so we can return it to the
+ caller.
+
+ The application will be responsible for issuing a BSAChangeToken()
+ to update the password.
+ =================================================================*/
+ if (rc == DSM_RC_REJECT_VERIFIER_EXPIRED)
+ {
+ /*=== don't return yet - init global so session can continue ===*/
+
+ saverc = rc;
+ rc = DSM_RC_OK;
+ }
+ else
+ if ((rc == DSM_RC_NO_OWNER_REQD) ||
+ (rc == DSM_RC_NO_NODE_REQD)) /* pswd=generate */
+ {
+ AFSdsmTerminate(dsmHandle);
+ bsaRC = ADSM_RC_PSWD_GEN;
+ return (bsaRC);
+ }
+
+
+ /*==================================================================
+ If we ran into any problems so far, rc will be non-zero or 'true'.
+
+ This is not true for password expired, since we reset rc to zero
+ in that case. We'll have to check for that later so we return
+ the 'password expired' indication to the caller.
+ ==================================================================*/
+
+ if (rc)
+ {
+ AFSdsmRCMsg(dsmHandle, rc, rcmsg);
+ sprintf(traceStr2, "BSAInit(AFSdsmInit): Messages - %s ", rcmsg);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ strcpy(ourMessage, ourRCMsg(rc, errPrefix));
+ ourLogEvent_Ex(dsmHandle, logLocal, ourMessage, errPrefix, logSevError);
+ xlateRC(*BSAHandleP, rc, &bsaRC); /* BSAHandle still 0, but not used */
+ AFSdsmTerminate(dsmHandle); /* clean up memory blocks */
+ return (bsaRC);
+ }
+
+
+ {
+ char msg[256]; /* format string and watch for NULLs */
+
+ strcpy(msg, "BSAInit for node=");
+
+ if (objectOwnerP)
+ {
+ if (dsmNodeP)
+ strcat(msg, dsmNodeP);
+ else
+ strcat(msg, "<empty>");
+ }
+ else
+ strcat(msg, "<NULL>");
+
+ strcat(msg, ", owner=");
+
+ if (objectOwnerP)
+ {
+ if (dsmOwnerP)
+ strcat(msg, dsmOwnerP);
+ else
+ strcat(msg, "<empty>");
+ }
+ else
+ strcat(msg, "<NULL>");
+
+ strcat(msg, ".\n");
+
+ sprintf(traceStr, msg);
+ }
+
+ *BSAHandleP = (long)dsmHandle;
+
+
+ /*=================================================================
+ For password expired processing the application is responsible for
+ issuing BSAChangeToken() to update the password, when they see the
+ 'expired password' return code.
+
+ The BSAChangeToken() command will issue the AFSdsmQuerySessInfo()
+ call, so don't issue it here.
+ =================================================================*/
+
+ if (!saverc) /* don't call this if we got pswd expire */
+ {
+ /*=== now query session info to populate the global structure ===*/
+
+ xopenGbl.dsmSessInfo.stVersion = ApiSessInfoVersion;
+ rc = AFSdsmQuerySessInfo(dsmHandle, /* Session handle */
+ &xopenGbl.dsmSessInfo); /* Output struct */
+
+ if (rc)
+ {
+ sprintf(traceStr2, "BSAInit(AFSdsmQuerySessInfo): error rc = %d", rc);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ AFSdsmTerminate(dsmHandle);
+ *BSAHandleP = 0;
+ }
+ else
+ {
+ sprintf(traceStr2, "BSAInit: Actual node=%s, actual DSM owner=%s, servername=%s.",
+ xopenGbl.dsmSessInfo.id, xopenGbl.dsmSessInfo.owner,
+ xopenGbl.dsmSessInfo.adsmServerName);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ }
+ }
+ else
+ {
+ /*============================================================
+ Indicate in the session flags that we encountered a password
+ expiration condition. The application will know that this
+ happened via the return code.
+ ===========================================================*/
+
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_PSWD_EXPIRE);
+ }
+
+ /*=== Save bsaObjectOwner (node name) value passed on Init ===*/
+
+ if (dsmNodeP)
+ strcpy(xopenGbl.bsaObjectOwner, dsmNodeP);
+
+ /*================================================================
+ Check to see if we saved away the 'expired password' return code.
+ if so, return it to the caller.
+ ================================================================*/
+
+ if (saverc)
+ rc = saverc;
+
+ xlateRC(*BSAHandleP, rc, &bsaRC);
+#ifdef DEBUG_BUTC
+ printf("BSAInit : Leaving Function. \n");
+#endif
+ return (bsaRC);
+}
+
+BSA_Int16 BSATerminate(
+ long BSAHandle
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+ sprintf(traceStr2, "BSATerminate ENTRY: BSAHandle is %d.",
+ BSAHandle);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+
+ rc = AFSdsmTerminate(dsmHandle);
+ dsmHandle = 0;
+ xlateRC(dsmHandle, rc, &bsaRC);
+
+ return (bsaRC);
+
+}
+
+BSA_Int16 BSAChangeToken(
+ long BSAHandle,
+ SecurityToken *oldTokenP,
+ SecurityToken *newTokenP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+
+ sprintf(traceStr2, "BSAChangeToken ENTRY: BSAHandle:%d old:>%s< new:>%s<",
+ BSAHandle,oldTokenP,newTokenP);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+
+ rc = AFSdsmChangePW(dsmHandle, (char *)oldTokenP, (char *)newTokenP);
+
+ if (rc)
+ {
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle,"BSAChangeToken(AFSdsmChangePW)",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_PSWD_EXPIRE); /* set off */
+
+ /*=== now query session info to populate the global structure ===*/
+
+ xopenGbl.dsmSessInfo.stVersion = ApiSessInfoVersion;
+ rc = AFSdsmQuerySessInfo(dsmHandle, /* Our session handle */
+ &xopenGbl.dsmSessInfo); /* Output structure. */
+ if (rc)
+ {
+ /*=== appl should call Terminate ===*/
+ sprintf(traceStr2, "BSAChangeToken(AFSdsmQuerySessInfo): error rc = %d", rc);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ }
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle,"BSAChangeToken",
+ bsaRC,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSASetEnvironment(
+ long BSAHandle,
+ char **envP
+)
+{
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ sprintf(traceStr2, "BSASetEnvironment ENTRY: BSAHandle:%d envP:>%p< ",
+ BSAHandle,envP);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ XOPENRETURN(BSAHandle,"BSASetEnvironment",
+ BSA_RC_BAD_CALL_SEQUENCE,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSAGetEnvironment(
+ long BSAHandle,
+ ObjectOwner *objOwnerP,
+ char **envP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ char envString[ADSM_ENV_STRS][BSA_MAX_DESC];
+ char maxObjStr[6]; /* conversion field. value range is 16-256 */
+ dsUint32_t maxObjNum;
+ dsInt16_t i, j;
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ for (i=0; i<ADSM_ENV_STRS; i++)
+ {
+ memset(envString[i], 0x00, BSA_MAX_DESC);
+ }
+ sprintf(traceStr2, "BSAGetEnvironment ENTRY: BSAHandle:%d ObjOwner:'%s' appOwner:'%s' envP:>%p<.",
+ BSAHandle,
+ objOwnerP->bsaObjectOwner,
+ objOwnerP->appObjectOwner,
+ envP);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ dsmHandle = BSAHandle;
+
+ /*===============================================================
+ check if BSAInit has been done for now we have only one possible
+ handle value - change in future
+ ==============================================================*/
+ if ((dsmHandle != FIRST_HANDLE) ||
+ (xopenGbl.dsmSessInfo.stVersion != ApiSessInfoVersion))
+ XOPENRETURN(BSAHandle,"BSAGetEnvironment",
+ BSA_RC_BAD_CALL_SEQUENCE, __FILE__,__LINE__);
+
+ if (objOwnerP)
+ {
+ strcpy(objOwnerP->bsaObjectOwner, xopenGbl.dsmSessInfo.id);
+ strcpy(objOwnerP->appObjectOwner, xopenGbl.dsmSessInfo.owner);
+ }
+ else
+ XOPENRETURN(BSAHandle,"BSAGetEnvironment",
+ BSA_RC_NULL_POINTER, __FILE__,__LINE__);
+
+ rc = AFSdsmQuerySessInfo(dsmHandle, /* Session Handle */
+ &xopenGbl.dsmSessInfo); /* Output struct */
+
+ if (rc)
+ {
+ sprintf(traceStr2, "BSAGetEnvironment(AFSdsmQuerySessInfo): error rc = %d", rc);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ AFSdsmTerminate(dsmHandle);
+ /* *BSAHandleP = 0; */
+ }
+ else
+ {
+ sprintf(traceStr2, "BSAGetEnvironment: Actual node=%s, actual DSM owner=%s, ServerName=%s.",
+ xopenGbl.dsmSessInfo.id, xopenGbl.dsmSessInfo.owner, xopenGbl.dsmSessInfo.adsmServerName);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ }
+
+ strcpy(envString[0],"TSMSRVR=");
+ strcat(envString[0],xopenGbl.dsmSessInfo.serverHost);
+
+ strcpy(envString[1],"TSMMAXOBJ=");
+ maxObjNum = xopenGbl.dsmSessInfo.maxObjPerTxn; /* convert to 32 bit */
+ sprintf(maxObjStr,"%lu", maxObjNum );
+ strcat(envString[1], maxObjStr);
+
+ strcpy(envString[2], "TSMSRVRSTANZA=");
+ strcat(envString[2], xopenGbl.dsmSessInfo.adsmServerName);
+
+ sprintf(traceStr2, "BSAGetEnvironment Value : TSM Server '%s', TSM Max Object '%s',TSM Server STANZA '%s'",
+ envString[0], envString[1], envString[2]);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ for (i=0; i< ADSM_ENV_STRS; i++) {
+ if ( *envP == NULL ) { /* watch for NULL pointers */
+ /* Allocating memory for *envP.*/
+ *envP = (char *) malloc(sizeof(char) * BSA_MAX_DESC +1);
+
+ /* copy the content of envString[i] to *envP. */
+ strcpy(*envP,envString[i]);
+ envP++;
+ }
+ }
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle,"BSAGetEnvironment",
+ bsaRC,__FILE__,__LINE__)
+}
+
+BSA_Int16 BSABeginTxn(
+ long BSAHandle
+)
+{
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ sprintf(traceStr2, "BSABeginTxn ENTRY: BSAHandle:%d", BSAHandle);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ /*========================================================
+ don't actually issue BeginTxn yet, because we will do our
+ own for Get and Query
+ ========================================================*/
+
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_BSA_TXN); /* set on */
+ XOPENRETURN(BSAHandle, "BSABeginTxn",
+ BSA_RC_SUCCESS,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSAEndTxn(
+ long BSAHandle,
+ Vote vote
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ dsUint8_t dsmVote;
+ dsUint16_t reason ;
+ char rsMsg[DSM_MAX_RC_MSG_LENGTH + 1];
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(rsMsg, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ sprintf(traceStr2, "BSAEndTxn ENTRY: BSAHandle:%d Vote:>%d<", BSAHandle, vote);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ dsmHandle = BSAHandle;
+
+ if (xopenGbl.sessFlags & FL_IN_DSM_TXN)
+ {
+ if (vote == BSAVote_COMMIT)
+ dsmVote = DSM_VOTE_COMMIT;
+ else
+ if (vote == BSAVote_ABORT)
+ dsmVote = DSM_VOTE_ABORT;
+ else
+ {
+ sprintf(traceStr2, "BSAEndTxn: invalid vote (%d)", vote);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_INVALID_VOTE;
+ XOPENRETURN(BSAHandle, "BSAEndTxn",bsaRC,__FILE__,__LINE__);
+ }
+
+
+ sprintf(traceStr2, "BSAEndTxn: issue AFSdsmEndTxn, vote=%s",
+ dsmVote == DSM_VOTE_COMMIT ? "COMMIT" : "ABORT");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ /*===========================================================
+ check if this EndTxn call was proceeded by a Send call which
+ returned WILL_ABORT. If so, make sure the vote is COMMIT
+ so we will get the server's reason code.
+ ===========================================================*/
+ if (xopenGbl.sessFlags & FL_RC_WILL_ABORT)
+ {
+ dsmVote = DSM_VOTE_COMMIT;
+
+ sprintf(traceStr2, "BSAEndTxn: sproceeded by RC_WILL_ABORT, so use vote=COMMIT");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_RC_WILL_ABORT); /* set off*/
+ }
+
+ rc = AFSdsmEndTxn(dsmHandle, dsmVote, &reason);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_DSM_TXN); /* set off */
+
+ /*====================================================
+ if the caller wanted to Abort, then return rc=OK, not
+ our usual 2302 and reason 3
+ =====================================================*/
+ if ((dsmVote == DSM_VOTE_ABORT) &&
+ (rc == DSM_RC_CHECK_REASON_CODE) &&
+ (reason == DSM_RC_ABORT_BY_CLIENT))
+
+ rc = DSM_RC_OK;
+
+ if (rc)
+ {
+ sprintf(traceStr2, "BSAEndTxn(AFSdsmEndTxn) error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ AFSdsmRCMsg(BSAHandle, reason, rsMsg);
+ sprintf(traceStr2, "BSAEndTxn: reason code = %d, Message='%s'", reason, rsMsg);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ strcpy(ourMessage, ourRCMsg(reason, errPrefix));
+ ourLogEvent_Ex(BSAHandle,logBoth, ourMessage, errPrefix, logSevError);
+ }
+ xlateRC(BSAHandle, rc, &bsaRC);
+
+ if (rc == DSM_RC_CHECK_REASON_CODE) /* return reason code instead */
+ {
+ xlateRC(BSAHandle, reason, &bsaRC);
+ }
+ }
+
+ /*=== check if Query was terminated ===*/
+ if (xopenGbl.sessFlags & FL_IN_BSA_QRY)
+ {
+ AFSdsmEndQuery(dsmHandle);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
+ }
+
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_TXN); /* set off */
+ XOPENRETURN(BSAHandle, "BSAEndTxn",
+ bsaRC,__FILE__,__LINE__);
+}
+
+void BSAQueryApiVersion(
+ApiVersion *BSAapiVerP
+)
+
+{
+ /*===============================================================
+ Don't actually call the base QueryApiVersion call.
+ Use the defines from custom.h since this is what the application
+ sees in the header file. The constants should be the same,
+ but may get out of sync occasionally.
+ ===============================================================*/
+ BSAapiVerP->version = BSA_API_VERSION;
+ BSAapiVerP->release = BSA_API_RELEASE;
+ BSAapiVerP->level = BSA_API_LEVEL;
+ return;
+}
+
+BSA_Int16 BSAQueryObject(
+long BSAHandle,
+QueryDescriptor *BSAqryDescP,
+ObjectDescriptor *BSAobjDescP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ dsmObjName objName;
+ dsUint8_t dsmObjType;
+ dsmQueryType query_type;
+ dsmQueryBuff *query_buff;
+ DataBlk qData;
+ qryArchiveData archiveData;
+ qryRespArchiveData respArchive;
+ qryBackupData backupData;
+ qryRespBackupData respBackup;
+ BSAObjectOwner upperNode; /* upper cased node name */
+
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ dsmHandle = BSAHandle;
+
+ memset(&backupData, 0x00, sizeof(qryBackupData));
+
+ sprintf(traceStr2, "BSAQueryObject ENTRY: BSAHandle:%d ObjOwner(qryDesc):'%s' appOwner(qryDesc):'%s' \n ObjName(qryDesc):'%.*s%.*s' \n copyType:%d ObjectType:%d status:%d ",
+ BSAHandle,
+ BSAqryDescP->owner.bsaObjectOwner,
+ BSAqryDescP->owner.appObjectOwner,
+ 100,BSAqryDescP->objName.objectSpaceName,
+ 100,BSAqryDescP->objName.pathName,
+ BSAqryDescP->copyType,
+ BSAqryDescP->objectType,
+ BSAqryDescP->status);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ /*=====================================================
+ init objDesc area to 0's before we start to erase any
+ garbage that might be there.
+ =====================================================*/
+ memset(BSAobjDescP, 0x00, sizeof(ObjectDescriptor));
+
+ /*=== init global look ahead pointer to NULL ===*/
+ if (xopenGbl.nextQryP != NULL)
+ {
+ dsFree(xopenGbl.nextQryP);
+ xopenGbl.nextQryP = NULL;
+ }
+
+ /*=========================================================
+ if the node name is different - we won't query it compare
+ both the value passed on the BSAInit and the final value
+ used for the session (which may be different for Generate).
+ =========================================================*/
+ strcpy(upperNode, BSAqryDescP->owner.bsaObjectOwner);
+ StrUpper(upperNode);
+ if ((strcmp(upperNode, xopenGbl.dsmSessInfo.id)) &&
+ (strcmp(BSAqryDescP->owner.bsaObjectOwner, xopenGbl.bsaObjectOwner)))
+ {
+ sprintf(traceStr2,
+ "BSAQueryObject: BSAObjectOwner(%s) doesn't match value for session(%s).", upperNode, xopenGbl.dsmSessInfo.id);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_NODE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*=====================================================
+ currently BSA_MAX_OSNAME = DSM_MAX_FSNAME_LENGTH
+ if this changes, use strncpy
+ ====================================================*/
+ if (strlen(BSAqryDescP->objName.objectSpaceName) > BSA_MAX_OSNAME)
+ {
+ sprintf(traceStr2, "BSAQueryObject: objectSpaceName too long (%d).",
+ strlen(BSAqryDescP->objName.objectSpaceName));
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_OBJNAME_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+ /*=================================================================
+ the entire pathname gets copied into hl during parsing, so check
+ for that max len as well. For now these are the same value.
+ ================================================================*/
+ if (strlen(BSAqryDescP->objName.pathName) >
+ min(DSM_MAX_HL_LENGTH, BSA_MAX_PATHNAME))
+ {
+ sprintf(traceStr2, "BSAQueryObject: pathName too long (%d)",
+ strlen(BSAqryDescP->objName.pathName));
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ bsaRC = BSA_RC_OBJNAME_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+ if ((BSAqryDescP->objectType == BSAObjectType_FILE) ||
+ (BSAqryDescP->objectType == BSAObjectType_DATABASE))
+ dsmObjType = DSM_OBJ_FILE;
+ else
+ if (BSAqryDescP->objectType == BSAObjectType_DIRECTORY)
+ dsmObjType = DSM_OBJ_DIRECTORY;
+ else
+ if (BSAqryDescP->objectType == BSAObjectType_ANY)
+ dsmObjType = DSM_OBJ_ANY_TYPE;
+ else
+ {
+ sprintf(traceStr2,
+ "BSAQueryObject: invalid objectType (%d)", BSAqryDescP->objectType);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_OBJTYPE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
+ {
+ sprintf(traceStr2, "BSAQueryObject: issued without BSABeginTxn");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /* store object name in ADSM structure */
+ strcpy(objName.fs,BSAqryDescP->objName.objectSpaceName) ;
+
+ if (!strcmp(BSAqryDescP->objName.pathName, "/*")) /* if they use a wildcard */
+ { /* we need to use a wild card on both hl and ll since the path gets split */
+ strcpy(objName.hl, "*"); /* don't include delimiter in case there is
+ no hl */
+ strcpy(objName.ll, "/*");
+ }
+ else
+ xparsePath(BSAHandle, BSAqryDescP->objName.pathName, objName.hl, objName.ll);
+
+ objName.objType = dsmObjType ;
+
+ /*=== save copy type for GetNextQuery call later ===*/
+ xopenGbl.copyType = BSAqryDescP->copyType;
+
+ if (BSAqryDescP->copyType == BSACopyType_ARCHIVE)
+ {
+ if (strlen(BSAqryDescP->desc) > ADSM_MAX_DESC)
+ {
+
+ sprintf(traceStr2, "BSAQueryObject: description longer than ADSM max (%d). ", strlen(BSAqryDescP->desc));
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_DESC_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ archiveData.stVersion = qryArchiveDataVersion;
+ archiveData.objName = &objName;
+ archiveData.owner = (char *)&BSAqryDescP->owner.appObjectOwner;
+
+ /*=================================================================
+ in the tm structure the month count starts with 0 and year is
+ the value since 1900.
+ Adjust the year value only if it isn't one of the boundary values
+ =================================================================*/
+
+ archiveData.insDateLowerBound.year = BSAqryDescP->createTimeLB.tm_year;
+ if (archiveData.insDateLowerBound.year != ADSM_LOWEST_BOUND)
+ archiveData.insDateLowerBound.year += 1900;
+ archiveData.insDateLowerBound.month = BSAqryDescP->createTimeLB.tm_mon+1;
+ archiveData.insDateLowerBound.day = BSAqryDescP->createTimeLB.tm_mday;
+ archiveData.insDateLowerBound.hour = BSAqryDescP->createTimeLB.tm_hour;
+ archiveData.insDateLowerBound.minute = BSAqryDescP->createTimeLB.tm_min;
+ archiveData.insDateLowerBound.second = BSAqryDescP->createTimeLB.tm_sec;
+
+ archiveData.insDateUpperBound.year = BSAqryDescP->createTimeUB.tm_year;
+ if (archiveData.insDateUpperBound.year != ADSM_HIGHEST_BOUND)
+ archiveData.insDateUpperBound.year += 1900;
+ archiveData.insDateUpperBound.month = BSAqryDescP->createTimeUB.tm_mon+1;
+ archiveData.insDateUpperBound.day = BSAqryDescP->createTimeUB.tm_mday;
+ archiveData.insDateUpperBound.hour = BSAqryDescP->createTimeUB.tm_hour;
+ archiveData.insDateUpperBound.minute = BSAqryDescP->createTimeUB.tm_min;
+ archiveData.insDateUpperBound.second = BSAqryDescP->createTimeUB.tm_sec;
+
+ archiveData.expDateLowerBound.year = BSAqryDescP->expireTimeLB.tm_year;
+ if (archiveData.expDateLowerBound.year != ADSM_LOWEST_BOUND)
+ archiveData.expDateLowerBound.year += 1900;
+ archiveData.expDateLowerBound.month = BSAqryDescP->expireTimeLB.tm_mon+1;
+ archiveData.expDateLowerBound.day = BSAqryDescP->expireTimeLB.tm_mday;
+ archiveData.expDateLowerBound.hour = BSAqryDescP->expireTimeLB.tm_hour;
+ archiveData.expDateLowerBound.minute = BSAqryDescP->expireTimeLB.tm_min;
+ archiveData.expDateLowerBound.second = BSAqryDescP->expireTimeLB.tm_sec;
+
+ archiveData.expDateUpperBound.year = BSAqryDescP->expireTimeUB.tm_year;
+ if (archiveData.expDateUpperBound.year != ADSM_HIGHEST_BOUND)
+ archiveData.expDateUpperBound.year += 1900;
+ archiveData.expDateUpperBound.month = BSAqryDescP->expireTimeUB.tm_mon+1;
+ archiveData.expDateUpperBound.day = BSAqryDescP->expireTimeUB.tm_mday;
+ archiveData.expDateUpperBound.hour = BSAqryDescP->expireTimeUB.tm_hour;
+ archiveData.expDateUpperBound.minute = BSAqryDescP->expireTimeUB.tm_min;
+ archiveData.expDateUpperBound.second = BSAqryDescP->expireTimeUB.tm_sec;
+
+ archiveData.descr = (char *)&BSAqryDescP->desc;
+ query_type = qtArchive;
+ query_buff = (dsmQueryBuff *)&archiveData;
+
+ qData.stVersion = DataBlkVersion;
+ qData.bufferLen = sizeof(qryRespArchiveData);
+ qData.bufferPtr = (char *)&respArchive;
+ respArchive.stVersion = qryRespArchiveDataVersion;
+ }
+ else
+ if (BSAqryDescP->copyType == BSACopyType_BACKUP)
+ {
+ if (BSAqryDescP->status == BSAObjectStatus_ACTIVE)
+ backupData.objState = DSM_ACTIVE;
+ else
+ if (BSAqryDescP->status == BSAObjectStatus_INACTIVE)
+ backupData.objState = DSM_INACTIVE;
+ else
+ if (BSAqryDescP->status == BSAObjectStatus_ANY)
+ backupData.objState = DSM_ANY_MATCH;
+ else
+ {
+ sprintf(traceStr2,
+ "BSAQueryObject: invalid status (%d)",
+ BSAqryDescP->status);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_STATUS;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ backupData.stVersion = qryBackupDataVersion;
+ backupData.objName = &objName;
+ backupData.owner = (char *)&BSAqryDescP->owner.appObjectOwner;
+
+ query_type = qtBackup;
+ query_buff = (dsmQueryBuff *)&backupData;
+
+ qData.stVersion = DataBlkVersion;
+ qData.bufferLen = sizeof(qryRespBackupData);
+ qData.bufferPtr = (char *)&respBackup;
+ respBackup.stVersion = qryRespBackupDataVersion;;
+ }
+ else
+ {
+ sprintf(traceStr2,
+ "BSAQueryObject: invalid copyType (%d)",
+ BSAqryDescP->copyType);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_COPYTYPE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*=== now set flag for query ===*/
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_BSA_QRY); /* set on */
+
+ if ((rc = AFSdsmBeginQuery(dsmHandle,query_type,query_buff)))
+ {
+
+ sprintf(traceStr2, "BSAQueryObject(AFSdsmBeginQuery) error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSAQueryObject(AFSdsmBeginQuery)",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ rc = AFSdsmGetNextQObj(dsmHandle,&qData);
+ if (((rc == DSM_RC_OK) || (rc == DSM_RC_MORE_DATA)) && qData.numBytes)
+ {
+ BSAobjDescP->version = ObjectDescriptorVersion;
+ strcpy(BSAobjDescP->Owner.bsaObjectOwner, xopenGbl.dsmSessInfo.id);
+ BSAobjDescP->copyType = BSAqryDescP->copyType;
+ strcpy(BSAobjDescP->cGName, "\0"); /* no copy group name returned */
+
+ if (BSAqryDescP->copyType == BSACopyType_ARCHIVE)
+ {
+ fillArchiveResp(dsmHandle, BSAobjDescP, &respArchive);
+ }
+ else /* backup */
+ {
+ fillBackupResp(dsmHandle, BSAobjDescP, &respBackup);
+ }
+ /*=== look ahead and see if there is more or if this is really done ===*/
+ rc = AFSdsmGetNextQObj(dsmHandle,&qData);
+ if (( (rc == DSM_RC_OK) || (rc == DSM_RC_MORE_DATA)) && qData.numBytes)
+ { /*=== save the response we just got for later call ===*/
+ if (BSAqryDescP->copyType == BSACopyType_ARCHIVE)
+ {
+ if (!(xopenGbl.nextQryP = (char *)dsMalloc(sizeof(qryRespArchiveData))))
+ {
+
+ sprintf(traceStr2, "BSAQueryObject: no memory for look ahead buffer");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
+ bsaRC = BSA_RC_NO_RESOURCES;
+ XOPENRETURN(BSAHandle, "BSAQueryObject(AFSdsmGetNextQObj)",
+ bsaRC,__FILE__,__LINE__);
+ }
+ memcpy(xopenGbl.nextQryP, &respArchive, sizeof(qryRespArchiveData));
+ }
+ else
+ {
+ if (!(xopenGbl.nextQryP = (char *)dsMalloc(sizeof(qryRespBackupData))))
+ {
+
+ sprintf(traceStr2, "BSAQueryObject: no memory for look ahead buffer");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
+ bsaRC = BSA_RC_NO_RESOURCES;
+ XOPENRETURN(BSAHandle, "BSAQueryObject(AFSdsmGetNextQObj)",
+ bsaRC,__FILE__,__LINE__);
+
+ }
+ memcpy(xopenGbl.nextQryP, &respBackup, sizeof(qryRespBackupData));
+ }
+ }
+ else
+ {
+
+ sprintf(traceStr2, "BSAQueryObject(AFSdsmGetNextQObj) rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ AFSdsmEndQuery(dsmHandle);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
+ }
+
+ }
+ else /* could be FINISHED or an error */
+ {
+
+ sprintf(traceStr2, "BSAQueryObject(AFSdsmGetNextQObj) rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ AFSdsmEndQuery(dsmHandle);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
+ }
+
+ if (rc == DSM_RC_OK)
+ {
+ sprintf(traceStr2, "BSAQueryObject(AFSdsmGetNextQObj) rc = %d, ObjOwner(objDesc):'%s' appOwner(objDesc):'%s' \n ObjName(objDesc):'%.*s%.*s' \n copyType:%d copyId:'%d %d' cGName:'%s'",
+ rc,
+ BSAobjDescP->Owner.bsaObjectOwner,
+ BSAobjDescP->Owner.appObjectOwner,
+ 100,BSAobjDescP->objName.objectSpaceName,
+ 100,BSAobjDescP->objName.pathName,
+ BSAobjDescP->copyType,
+ BSAobjDescP->copyId.left,
+ BSAobjDescP->copyId.right,
+ BSAobjDescP->cGName == NULL ? "" : BSAobjDescP->cGName);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ }
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSAQueryObject",
+ bsaRC, __FILE__,__LINE__);
+}
+
+BSA_Int16 BSAGetObject(
+ long BSAHandle,
+ ObjectDescriptor *BSAobjDescP,
+ DataBlock *BSAdataBlockP
+)
+{
+ dsInt16_t rc = 0;
+ dsInt16_t rc1 = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ DataBlk getBlk;
+ dsmGetType getType;
+ dsmGetList dsmObjList ;
+ char rcMsg[DSM_MAX_RC_MSG_LENGTH + 1];
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+
+ memset(rcMsg, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ sprintf(traceStr2, "BSAGetObject ENTRY: BSAHandle:%d version:%d copyType:%d copyId:'%d %d' \n bufferLen:%d numBytes:%d ",
+ BSAHandle,
+ BSAobjDescP->version,
+ BSAobjDescP->copyType,
+ BSAobjDescP->copyId.left,
+ BSAobjDescP->copyId.right,
+ BSAdataBlockP->bufferLen,
+ BSAdataBlockP->numBytes);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ xopenGbl.oper = OPER_RECV_START; /* save state for EndData later */
+
+ if (BSAobjDescP->version != ObjectDescriptorVersion)
+ {
+ sprintf(traceStr2,"Warning: BSAGetObject: objectDesc.version unexpected %d.", BSAobjDescP->version);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ /*==================================================================
+ don't treat this as an error now since it isn't defined in the spec
+ bsaRC = ADSM_RC_INVALID_ST_VER;
+ return(bsaRC);
+ =================================================================*/
+ }
+
+ if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
+ {
+ sprintf(traceStr2, "BSAGetObject: issued without BSABeginTxn");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
+ XOPENRETURN(BSAHandle, "BSAGetObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*=== Get the data ===*/
+ if (BSAobjDescP->copyType == BSACopyType_ARCHIVE)
+ getType = gtArchive;
+ else
+ if (BSAobjDescP->copyType == BSACopyType_BACKUP)
+ getType = gtBackup;
+ else
+ {
+ sprintf(traceStr2,
+ "BSAGetObject: invalid copyType (%d)",
+ BSAobjDescP->copyType);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_COPYTYPE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSAGetObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*=== now update state since we'll issue a base API call ===*/
+ xopenGbl.oper = OPER_RECV_ISSUED; /* save state for EndData later */
+ /*=== setup for a single object get ===*/
+
+ dsmObjList.stVersion = dsmGetListVersion ;
+ dsmObjList.numObjId = 1 ;
+ dsmObjList.objId = (ObjID *)dsMalloc(sizeof(ObjID) * dsmObjList.numObjId) ;
+
+ dsmObjList.objId[0].hi = BSAobjDescP->copyId.left ;
+ dsmObjList.objId[0].lo = BSAobjDescP->copyId.right ;
+
+ if ((rc = AFSdsmBeginGetData(dsmHandle,bTrue, /* always say MountWait */
+ getType,
+ &dsmObjList)) != DSM_RC_OK)
+ {
+ sprintf(traceStr2, "BSAGetObject: Call to AFSdsmBeginGetData error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSAGetObject(AFSdsmBeginGetData)",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*********************************************************************/
+ getBlk.stVersion = DataBlkVersion ;
+ getBlk.bufferPtr = BSAdataBlockP->bufferPtr ;
+ getBlk.bufferLen = BSAdataBlockP->bufferLen;
+ getBlk.numBytes = 0;
+
+ rc = AFSdsmGetObj(dsmHandle, &(dsmObjList.objId[0]), &getBlk) ;
+
+ if ((rc == DSM_RC_FINISHED) &&
+ (getBlk.numBytes != 0)) /* actually is data received */
+ rc = DSM_RC_MORE_DATA; /* use different rc for consistency */
+ /* with Query. No data returned */
+ /* if rc = FINISHED. */
+ if ((rc == DSM_RC_FINISHED) ||
+ (rc == DSM_RC_MORE_DATA))
+ {
+ /*=== data is already in the buffer ===*/
+ BSAdataBlockP->numBytes = (BSA_UInt16)getBlk.numBytes;
+ }
+ else
+ {
+ /*=== appl may call BSAEndData to clean up trxn but don't count on it... ===*/
+ rc1 = AFSdsmEndGetObj(dsmHandle);
+ rc1 = AFSdsmEndGetData(dsmHandle);
+ xopenGbl.sessFlags =
+ (xopenGbl.sessFlags | FL_END_DATA_DONE); /* turn flag on */
+ }
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSAGetObject",
+ bsaRC,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSAGetData(
+ long BSAHandle,
+ DataBlock *BSAdataBlockP
+)
+{
+ dsInt16_t rc = 0;
+ dsInt16_t rc1 = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ DataBlk getBlk;
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+
+
+ sprintf(traceStr2, "BSAGetData ENTRY: BSAHandle:%d, bufferLen:%d, numBytes:%d",
+ BSAHandle,
+ BSAdataBlockP->bufferLen,
+ BSAdataBlockP->numBytes);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ getBlk.stVersion = DataBlkVersion ;
+ getBlk.bufferPtr = BSAdataBlockP->bufferPtr ;
+ getBlk.bufferLen = BSAdataBlockP->bufferLen;
+ getBlk.numBytes = 0;
+
+ rc = AFSdsmGetData(dsmHandle, &getBlk) ;
+
+ if ((rc == DSM_RC_FINISHED) &&
+ (getBlk.numBytes != 0)) /* actually is data received */
+ rc = DSM_RC_MORE_DATA; /* use different rc for consistency */
+ /* with Query. No data returned */
+ /* if rc = FINISHED. */
+
+ if ((rc == DSM_RC_FINISHED) ||
+ (rc == DSM_RC_MORE_DATA))
+ {
+ /*=== data is already in the buffer ===*/
+ BSAdataBlockP->numBytes = (BSA_UInt16)getBlk.numBytes;
+ }
+ else
+ {
+ sprintf(traceStr2, "BSAGetData: Call to AFSdsmGetData error rc = %d", rc);
+ ourTrace(BSAHandle, TrFL,traceStr2);
+
+ /*=== appl may call BSAEndData to clean up trxn but don't count on it... ===*/
+ rc1 = AFSdsmEndGetObj(dsmHandle);
+ rc1 = AFSdsmEndGetData(dsmHandle);
+ xopenGbl.sessFlags =
+ (xopenGbl.sessFlags | FL_END_DATA_DONE); /* turn flag on */
+ }
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSAGetData(AFSdsmGetData)",
+ bsaRC,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSASendData(
+ long BSAHandle,
+ DataBlock *BSAdataBlockP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ DataBlk dataBlkArea;
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+
+
+ sprintf(traceStr2, "BSASendData ENTRY: BSAHandle:%d bufferLen: %d numBytes: %d ",
+ BSAHandle,
+ BSAdataBlockP->bufferLen,
+ BSAdataBlockP->numBytes);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ /*=== check for NULL dataBlock pointer ===*/
+ if (BSAdataBlockP == NULL)
+ XOPENRETURN(BSAHandle, "BSASendData",
+ BSA_RC_NULL_POINTER,__FILE__,__LINE__);
+ dataBlkArea.stVersion = DataBlkVersion ;
+ dataBlkArea.bufferPtr = BSAdataBlockP->bufferPtr ;
+ dataBlkArea.bufferLen = BSAdataBlockP->bufferLen;
+
+ rc = AFSdsmSendData(dsmHandle, &dataBlkArea);
+
+ if (rc)
+ {
+
+ sprintf(traceStr2, "BSASendData(AFSdsmSendData) error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ if (rc == DSM_RC_WILL_ABORT) /* save flag */
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_RC_WILL_ABORT);
+ }
+ BSAdataBlockP->numBytes = (BSA_UInt16)dataBlkArea.numBytes;
+ sprintf(traceStr2, "BSASendData(AFSdsmSendData): BSAHandle:%d bufferLen: %d numBytes sent: %d ",
+ BSAHandle,
+ BSAdataBlockP->bufferLen,
+ BSAdataBlockP->numBytes);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSASendData",
+ BSA_RC_SUCCESS,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSAEndData(
+ long BSAHandle
+)
+{
+ dsInt16_t rc = 0;
+ dsInt16_t rc1 = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+
+
+ sprintf(traceStr2, "BSAEndData ENTRY: BSAHandle:%d", BSAHandle);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ /*=======================================================
+ check the state - don't issue base API call unless one
+ was called previously, or else we get a sequence error.
+ ======================================================*/
+
+ if (xopenGbl.oper == OPER_SEND_ISSUED)
+ {
+ rc = AFSdsmEndSendObj(dsmHandle);
+ if (rc)
+ {
+
+ sprintf(traceStr2, "BSAEndData(AFSdsmEndSendObj) error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xlateRC(BSAHandle, rc, &bsaRC);
+ }
+ }
+ else
+ if (xopenGbl.oper == OPER_RECV_ISSUED)
+ {
+ if (xopenGbl.sessFlags & FL_END_DATA_DONE) /* EndData processing */
+ xopenGbl.sessFlags = /* already done */
+ (xopenGbl.sessFlags ^ FL_END_DATA_DONE); /* turn flag off */
+ else
+ {
+ rc = AFSdsmEndGetObj(dsmHandle);
+ if (rc)
+ {
+ sprintf(traceStr2, "BSAEndData(AFSdsmEndGetObj) error rc = %d", rc);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ /*==============================================================
+ this may get 'Out of sequence error' if previous GetObject
+ had rc=2 (no match). Don't return this to caller - too confusing
+ ===============================================================*/
+ if (rc != DSM_RC_BAD_CALL_SEQUENCE)
+ xlateRC(BSAHandle, rc, &bsaRC);
+ }
+
+ rc = AFSdsmEndGetData(dsmHandle);
+ if (rc)
+ {
+ sprintf(traceStr2, "BSAEndData(AFSdsmEndGetData) error rc = %d", rc);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ xlateRC(BSAHandle, rc, &bsaRC);
+ }
+ }
+ }
+ else /* invalid state */
+ if ((xopenGbl.oper != OPER_RECV_START) &&
+ (xopenGbl.oper != OPER_SEND_START))
+ {
+ sprintf(traceStr2, "BSAEndData: BSAEndData but not Send or Recv");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
+ }
+
+ xopenGbl.oper = OPER_NONE;
+ XOPENRETURN(BSAHandle, "BSAEndData",bsaRC,__FILE__,__LINE__);
+}
+
+BSA_Int16 BSACreateObject(
+ long BSAHandle,
+ ObjectDescriptor *BSAobjDescP,
+ DataBlock *BSAdataBlockP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ regFSData regFilespace ;
+ dsmObjName objName ;
+ ObjAttr objAttrArea;
+ sndArchiveData archData;
+ DataBlk dataBlkArea;
+ dsmSendType sendType;
+ dsUint8_t dsmObjType;
+ XAPIObjInfo xapiObjInfo;
+ mcBindKey mcBindKey;
+ BSAObjectOwner upperNode; /* upper cased node name */
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ dsmHandle = BSAHandle;
+
+ if (BSAobjDescP != NULL && BSAdataBlockP != NULL)
+ {
+ sprintf(traceStr2, "BSACreateObject ENTRY: BSAHandle:%d ObjOwner:'%s' appOwner:'%s' \n ObjName:'%.*s%.*s' \n objType:%d size:'%d %d' resourceType:'%s' \n bufferLen:%d numBytes:%d ",
+
+ BSAHandle,
+ BSAobjDescP->Owner.bsaObjectOwner[0] != '\0' ? BSAobjDescP->Owner.bsaObjectOwner : "",
+ BSAobjDescP->Owner.appObjectOwner[0] != '\0' ? BSAobjDescP->Owner.appObjectOwner : "",
+ 100,BSAobjDescP->objName.objectSpaceName[0] != '\0' ? BSAobjDescP->objName.objectSpaceName
+ : "",
+ 100,BSAobjDescP->objName.pathName[0] != '\0' ? BSAobjDescP->objName.pathName : "",
+ BSAobjDescP->objectType,
+ BSAobjDescP->size.left,
+ BSAobjDescP->size.right,
+ BSAobjDescP->resourceType[0] != '\0' ? BSAobjDescP->resourceType : "" ,
+ BSAdataBlockP->bufferLen,
+ BSAdataBlockP->numBytes);
+ }
+ else
+ {
+ if (BSAobjDescP == NULL)
+ {
+ bsaRC = BSA_RC_NULL_POINTER;
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+ sprintf(traceStr2, "BSACreateObject ENTRY: BSAHandle:%d", BSAHandle);
+ }
+
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ xopenGbl.oper = OPER_SEND_START; /* save state for EndData later */
+ /*=================================================================
+ if (BSAobjDescP->version != ObjectDescriptorVersion)
+ BSA spec doesn't require this currently..
+ =================================================================*/
+
+ /*===============================================================
+ if the node name is different - we won't create it compare both
+ the value passed on the BSAInit and the final value used for the
+ session (which may be different for Generate)
+ ===============================================================*/
+ strcpy(upperNode, BSAobjDescP->Owner.bsaObjectOwner);
+ StrUpper(upperNode);
+ if ((strcmp(upperNode, xopenGbl.dsmSessInfo.id)) &&
+ (strcmp(BSAobjDescP->Owner.bsaObjectOwner, xopenGbl.bsaObjectOwner)))
+ {
+ sprintf(traceStr2,
+ "BSACreateObject: BSAObjectOwner(%s) doesn't match value for session(%s).",
+ upperNode, xopenGbl.dsmSessInfo.id);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_NODE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle,logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*=== check string lengths - if this too long, it won't fit in our objInfo ===*/
+ if (strlen(BSAobjDescP->desc) > ADSM_MAX_DESC)
+ {
+ sprintf(traceStr2,"BSACreateObject: description longer than TSM max (%d). ",
+ strlen(BSAobjDescP->desc));
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ bsaRC = BSA_RC_DESC_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+ if (strlen(BSAobjDescP->objectInfo) > ADSM_MAX_OBJINFO)
+ {
+ sprintf(traceStr2,"BSACreateObject: objInfo longer than TSM max (%d).",
+ strlen(BSAobjDescP->objectInfo));
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_OBJINFO_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
+ {
+ sprintf(traceStr2, "BSACreateObject issued without BSABeginTxn");
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if (strlen(BSAobjDescP->objName.objectSpaceName) > BSA_MAX_OSNAME)
+ {
+ sprintf(traceStr2, "BSACreateObject: objectSpaceName too long (%d)",
+ strlen(BSAobjDescP->objName.objectSpaceName));
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ bsaRC = BSA_RC_OBJNAME_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSACreateObject:",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if (!(xopenGbl.sessFlags & FL_IN_DSM_TXN)) /* first CreateObj */
+ { /* can't issue RegisterFS if already in Txn */
+ /*=== Register the file space ===*/
+ regFilespace.stVersion = regFSDataVersion ;
+ regFilespace.fsName = BSAobjDescP->objName.objectSpaceName ;
+
+ /*=== use resource type for fsType (as it was intended) ===*/
+
+ regFilespace.fsType = BSAobjDescP->resourceType ;
+ regFilespace.capacity.lo = 0;
+ regFilespace.capacity.hi = 0;
+ regFilespace.occupancy.lo = 0;
+ regFilespace.occupancy.hi = 0;
+ #if _OPSYS_TYPE == DS_AIX
+ regFilespace.fsAttr.unixFSAttr.fsInfoLength = strlen(XAPI_FSINFO) ;
+ strcpy(regFilespace.fsAttr.unixFSAttr.fsInfo, XAPI_FSINFO);
+ #else
+ regFilespace.fsAttr.dosFSAttr.fsInfoLength = strlen(XAPI_FSINFO) ;
+ strcpy(regFilespace.fsAttr.dosFSAttr.fsInfo, XAPI_FSINFO);
+ regFilespace.fsAttr.dosFSAttr.driveLetter = 'X';
+ #endif
+ rc = AFSdsmRegisterFS(dsmHandle, ®Filespace) ;
+ if ((rc != 0) && (rc != DSM_RC_FS_ALREADY_REGED))
+ {
+ sprintf(traceStr2, "BSACreateObject(AFSdsmRegisterFS) error rc = %d",rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSACreateObject(AFSdsmRegisterFS)",
+ bsaRC,__FILE__,__LINE__);
+ }
+ }
+
+ /*========================================================
+ Check for invalid copyType before sending data. Log error
+ to dsirror.log file.
+ ========================================================*/
+ if (BSAobjDescP->copyType == BSACopyType_ARCHIVE)
+ sendType = stArchiveMountWait;
+ else
+ if (BSAobjDescP->copyType == BSACopyType_BACKUP)
+ sendType = stBackupMountWait;
+ else
+ {
+ sprintf(traceStr2,
+ "BSACreateObject: invalid copyType (%d)",
+ BSAobjDescP->copyType);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_COPYTYPE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle,logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if ((BSAobjDescP->objectType == BSAObjectType_FILE) ||
+ (BSAobjDescP->objectType == BSAObjectType_DATABASE) ||
+ (BSAobjDescP->objectType == BSAObjectType_ANY))
+
+ dsmObjType = DSM_OBJ_FILE;
+ else
+ if (BSAobjDescP->objectType == BSAObjectType_DIRECTORY)
+ dsmObjType = DSM_OBJ_DIRECTORY;
+ else
+ {
+ sprintf(traceStr2,
+ "BSACreateObject: invalid objectType (%d)",
+ BSAobjDescP->objectType);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_OBJTYPE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle,logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*==================================================================
+ put in a check here - count the number of objects per txn
+ and compare with xopenGbl.sessInfo.maxObjPerTxn
+ If reach the limit, EndTxn and start a new one
+ OK to do this without telling the BSA caller?
+ Or should we exit with an error to tell them the limit is reached ?
+ ==================================================================*/
+
+ if (!(xopenGbl.sessFlags & FL_IN_DSM_TXN))
+ {
+ rc = AFSdsmBeginTxn(dsmHandle);
+
+ if (rc)
+ {
+ sprintf(traceStr2, "BSACreateObject(AFSdsmBeginTxn) error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSACreateObject(AFSdsmBeginTxn)",
+ bsaRC,__FILE__,__LINE__);
+ }
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_DSM_TXN); /* set on */
+ }
+
+ /*=== Backup the data ===*/
+
+ /*================================================================
+ the entire pathname gets copied into hl during parsing, so
+ check for that max len as well. For now these are the same value.
+ =================================================================*/
+ if (strlen(BSAobjDescP->objName.pathName) >
+ min(DSM_MAX_HL_LENGTH, BSA_MAX_PATHNAME))
+ {
+ sprintf(traceStr2, "BSACreateObject: pathName too long (%d)",
+ strlen(BSAobjDescP->objName.pathName));
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_OBJNAME_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ strcpy(objName.fs,BSAobjDescP->objName.objectSpaceName) ;
+ /*=== previous code to use only ll field ===*/
+ /*objName.hl[0] = '\0';
+ strcpy(objName.ll,BSAobjDescP->objName.pathName) ;
+ */
+ xparsePath(BSAHandle, BSAobjDescP->objName.pathName, objName.hl, objName.ll);
+ objName.objType = dsmObjType ;
+
+ objAttrArea.stVersion = ObjAttrVersion ;
+ strcpy(objAttrArea.owner,BSAobjDescP->Owner.appObjectOwner);
+ objAttrArea.sizeEstimate.hi = BSAobjDescP->size.left;
+ objAttrArea.sizeEstimate.lo = BSAobjDescP->size.right;
+ objAttrArea.objCompressed = bFalse ; /* let COMPRESSION option decide */
+ /*=== whether there's actually compression ===*/
+ objAttrArea.objInfoLength = sizeof(XAPIObjInfo);
+ objAttrArea.objInfo = (char *)&xapiObjInfo ;
+
+ memset(&xapiObjInfo,0x00,sizeof(XAPIObjInfo));
+ strcpy(xapiObjInfo.resourceType, BSAobjDescP->resourceType);
+ xapiObjInfo.size.left = BSAobjDescP->size.left;
+ xapiObjInfo.size.right = BSAobjDescP->size.right;
+ strcpy(xapiObjInfo.partDesc, BSAobjDescP->desc);
+ strcpy(xapiObjInfo.partObjInfo, BSAobjDescP->objectInfo);
+
+ /*=== check if a lifecycle group name was passed to us ===*/
+ if (strlen(BSAobjDescP->lGName))
+ objAttrArea.mcNameP = (char *)BSAobjDescP->lGName ;
+ else
+ objAttrArea.mcNameP = NULL;
+
+ dataBlkArea.stVersion = DataBlkVersion ;
+ if (BSAdataBlockP == NULL)
+ {
+ dataBlkArea.bufferPtr = NULL;
+ dataBlkArea.bufferLen = 0;
+ }
+ else
+ {
+ dataBlkArea.bufferPtr = BSAdataBlockP->bufferPtr ;
+ dataBlkArea.bufferLen = BSAdataBlockP->bufferLen;
+ }
+
+ /*=======================================================
+ always issue BindMC because we don't expect applications
+ to call ResolveLifecycleGroup since it isn't in the
+ Data Movement subset
+ =======================================================*/
+ mcBindKey.stVersion = mcBindKeyVersion ;
+ rc = AFSdsmBindMC(dsmHandle, &objName, sendType, &mcBindKey);
+ if (rc)
+ {
+ sprintf(traceStr2, "BSACreateObject(AFSdsmBindMC): error rc = %d", rc);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSACreateObject(dsnBindMC)",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*=== now update state since we'll issue the base Send call ===*/
+
+ xopenGbl.oper = OPER_SEND_ISSUED; /* save state for EndData later */
+
+ switch (sendType)
+ {
+ case (stBackupMountWait) :
+ rc = AFSdsmSendObj(dsmHandle,
+ sendType,
+ NULL,
+ &objName,
+ &objAttrArea,
+ &dataBlkArea);
+ break;
+
+ case (stArchiveMountWait) :
+ archData.stVersion = sndArchiveDataVersion;
+ archData.descr = (char *)(BSAobjDescP->desc);
+ rc = AFSdsmSendObj(dsmHandle,
+ sendType,
+ &archData,
+ &objName,
+ &objAttrArea,
+ &dataBlkArea);
+ break;
+ default : ;
+ }
+
+ if (rc != DSM_RC_OK)
+ {
+ sprintf(traceStr2, "BSACreateObject(AFSdsmSendObj) error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ if (rc == DSM_RC_WILL_ABORT) /* save flag */
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_RC_WILL_ABORT);
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle, "BSACreateObject(AFSdsmSendObj)",
+ bsaRC,__FILE__,__LINE__);
+ }
+ XOPENRETURN(BSAHandle, "BSACreateObject",
+ BSA_RC_SUCCESS, __FILE__,__LINE__);
+}
+
+
+BSA_Int16 BSADeleteObject(
+ long BSAHandle,
+ CopyType copyType,
+ ObjectName *BSAobjNameP,
+ CopyId *copyidP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+ dsUint16_t reason ; /* for AFSdsmEndTxn */
+ dsmObjName dsmobjName;
+
+ dsmDelType delType;
+ dsmDelInfo delInfo;
+
+ delList *llHeadP = NULL;
+ delList *llTailP = NULL;
+ delList *ll = NULL;
+
+ char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
+ char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ memset(errPrefix, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+ memset(ourMessage, '\0', DSM_MAX_RC_MSG_LENGTH + 1);
+
+ dsmHandle = BSAHandle;
+
+ sprintf(traceStr2, "BSADeleteObject ENTRY: BSAHandle:%d CopyType:%d \n ObjName:'%.*s%.*s' copyidP:'%d %d'.",
+ BSAHandle,
+ copyType,
+ 100,BSAobjNameP->objectSpaceName,
+ 100,BSAobjNameP->pathName,
+ copyidP->left,
+ copyidP->right);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ if (copyType != BSACopyType_ARCHIVE)
+ {
+ sprintf(traceStr2,
+ "BSADeleteObject: invalid copyType %d",
+ copyType);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = ADSM_RC_INVALID_COPYTYPE;
+ strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
+ ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
+ XOPENRETURN(BSAHandle, "BSADeleteObject",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
+ {
+ sprintf(traceStr2, "BSADeleteObject issued without BSABeginTxn");
+ ourTrace(BSAHandle, TrFL, traceStr2);
+
+ bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
+ XOPENRETURN(BSAHandle, "BSADeleteObject:",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ strcpy(dsmobjName.fs, BSAobjNameP->objectSpaceName);
+ xparsePath(BSAHandle, BSAobjNameP->pathName, dsmobjName.hl, dsmobjName.ll);
+ dsmobjName.objType = DSM_OBJ_FILE;
+
+ if (!copyidP) /* NULL, so query and delete all with same name */
+ {
+ if (xopenGbl.sessFlags & FL_IN_DSM_TXN)
+ /*=== if a trxn had been started, end it before doing Query ===*/
+ {
+ rc = AFSdsmEndTxn(dsmHandle, DSM_VOTE_COMMIT, &reason);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_DSM_TXN); /* set off */
+ }
+ rc = buildList(dsmHandle, &dsmobjName, &llHeadP, &llTailP);
+ if (rc)
+ {
+ bsaRC = BSA_RC_OBJECT_NOT_FOUND;
+ XOPENRETURN(BSAHandle, "BSADeleteObject(buildList)",
+ bsaRC,__FILE__,__LINE__);
+ }
+ }
+
+ if (!(xopenGbl.sessFlags & FL_IN_DSM_TXN)) /* first call */
+ {
+ rc = AFSdsmBeginTxn(dsmHandle);
+ if (rc)
+ {
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(dsmHandle,"BSADeleteObject(AFSdsmBeginTxn)",
+ bsaRC,__FILE__,__LINE__);
+ }
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_DSM_TXN); /* set on */
+ }
+
+ delType = dtArchive;
+ delInfo.archInfo.stVersion = delArchVersion;
+
+ if (copyidP) /* single ID to delete */
+ {
+ delInfo.archInfo.objId.hi = copyidP->left;
+ delInfo.archInfo.objId.lo = copyidP->right;
+
+ if ((rc = AFSdsmDeleteObj(dsmHandle,delType,delInfo)) != DSM_RC_OK)
+ {
+ sprintf(traceStr2, "BSADeleteObject: AFSdsmDeleteObj error rc = %d", rc);
+ ourTrace(dsmHandle,TrFL, traceStr2);
+ }
+ }
+ else /* multiple IDs to delete */
+ {
+ ll = llHeadP;
+ while (ll)
+ {
+ delInfo.archInfo.objId.hi = ll->objId.hi;
+ delInfo.archInfo.objId.lo = ll->objId.lo;
+ if ((rc = AFSdsmDeleteObj(dsmHandle, delType, delInfo)) != DSM_RC_OK)
+ {
+ sprintf(traceStr2, "BSADeleteObject: AFSdsmDeleteObj error rc = %d", rc);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+ /*=== break and get out of loop, or keep going? ===*/
+ }
+ /*=== incr to next list entry ===*/
+ ll = ll->next;
+ }
+ /*=== free list now that done ===*/
+ rc = freeList(&llHeadP, &llTailP);
+ }
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle,"BSADeleteObject",
+ bsaRC,__FILE__,__LINE__)
+}
+
+BSA_Int16 BSAMarkObjectInactive(
+ long BSAHandle,
+ ObjectName *BSAobjNameP
+)
+{
+ dsInt16_t rc = 0;
+ BSA_Int16 bsaRC = 0;
+ dsUint32_t dsmHandle;
+
+ dsmObjName dsmobjName;
+
+ qryBackupData queryBuffer; /* for query Backup */
+ qryRespBackupData qbDataArea;
+ DataBlk qDataBlkArea;
+
+ dsmDelType delType;
+ dsmDelInfo delInfo;
+
+ dsUint16_t reason ; /* for AFSdsmEndTxn */
+ /*=== build list of all objTypes we find for this name ===*/
+ dsInt16_t i;
+ dsInt16_t numTypes;
+ dsUint8_t listObjType[5]; /* only 2 objTypes defined today */
+ dsUint32_t listCopyGroup[5];
+
+ if(!dsm_init)
+ {
+#ifdef DEBUG_BUTC
+ printf("TSM library not mounted. \n");
+#endif
+ if (dsm_MountLibrary())
+ {
+ printf("TSM Library initialisation failed. \n");
+ return 1 ;
+ }
+#ifdef DEBUG_BUTC
+ printf("TSM Library initialisation SUCCESS. \n");
+#endif
+ }
+
+ dsmHandle = BSAHandle;
+ memset(&delInfo, 0x00, sizeof(dsmDelInfo));
+ memset(&queryBuffer, 0x00, sizeof(qryBackupData));
+
+ sprintf(traceStr2, "BSAMarkObjectInactive ENTRY: BSAHandle:%d \n ObjName:'%.*s%.*s'.",
+ BSAHandle,
+ 100, BSAobjNameP->objectSpaceName,
+ 100, BSAobjNameP->pathName);
+ ourTrace(dsmHandle, TrFL, traceStr2);
+
+ if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
+ {
+ sprintf(traceStr2, "BSAMarkObjectInactive: issued without BSABeginTxn.");
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
+ XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ if (strlen(BSAobjNameP->objectSpaceName) > DSM_MAX_FSNAME_LENGTH)
+ {
+ sprintf(traceStr2, "BSAMarkObjectInactive: objectSpaceName too long (%d)", strlen(BSAobjNameP->objectSpaceName));
+ ourTrace(BSAHandle,TrFL, traceStr2);
+
+ bsaRC = BSA_RC_OBJNAME_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
+ bsaRC,__FILE__,__LINE__);
+ }
+ /*===============================================================
+ The entire pathname gets copied into hl during parsing, so
+ check for that max len as well. For now these are the same value.
+ =============================================================== */
+ if (strlen(BSAobjNameP->pathName) >
+ min(DSM_MAX_HL_LENGTH, BSA_MAX_PATHNAME))
+ {
+ sprintf(traceStr2, "BSAMarkObjectInactive: pathName too long (%d)",
+ strlen(BSAobjNameP->pathName));
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ bsaRC = BSA_RC_OBJNAME_TOO_LONG;
+ XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ /*==============================================================
+ we don't allow any wildcard in name because that could retrieve
+ LOTS of objects and make list processing more complicated.
+ XBSA spec implies a single object.
+ ==============================================================*/
+ if ( strchr(BSAobjNameP->objectSpaceName, '*') ||
+ strchr(BSAobjNameP->objectSpaceName, '?') ||
+ strchr(BSAobjNameP->pathName, '*') ||
+ strchr(BSAobjNameP->pathName, '?'))
+ {
+
+ sprintf(traceStr2, "BSAMarkObjectInactive: objName contains a wildcard.")
+;
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ /*=== could have a more specific rc, use this for now ===*/
+ bsaRC = BSA_RC_ABORT_ACTIVE_NOT_FOUND;
+ XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ strcpy(dsmobjName.fs, BSAobjNameP->objectSpaceName);
+ xparsePath(BSAHandle, BSAobjNameP->pathName, dsmobjName.hl, dsmobjName.ll);
+ dsmobjName.objType = DSM_OBJ_ANY_TYPE;
+
+ /*============================================================
+ A Backup Delete must include the copy Group and objType this
+ wasn't passed in, so we have to do a query.
+ ============================================================*/
+
+ queryBuffer.stVersion = qryBackupDataVersion ;
+ queryBuffer.objName = &dsmobjName;
+ queryBuffer.owner = xopenGbl.dsmSessInfo.owner;
+ queryBuffer.objState = DSM_ACTIVE; /* only get active one */
+
+ if ((rc=AFSdsmBeginQuery(dsmHandle, qtBackup,
+ (void *)&queryBuffer )) != DSM_RC_OK)
+ {
+ sprintf(traceStr2, "BSAMarkObjectInactive: Call to AFSdsmBeginQuery for Backup error rc = %d", rc);
+ ourTrace(BSAHandle,TrFL, traceStr2);
+ xlateRC(BSAHandle, rc, &bsaRC);
+ if ((rc == DSM_RC_ABORT_NO_MATCH) || /* special rc for MarkInact */
+ (rc == DSM_RC_FILE_SPACE_NOT_FOUND))
+ bsaRC = BSA_RC_ABORT_ACTIVE_NOT_FOUND;
+
+ rc = AFSdsmEndQuery(dsmHandle);
+ XOPENRETURN(BSAHandle, "BSAMarkObjectInactive: AFSdsmBeginQuery",
+ bsaRC,__FILE__,__LINE__);
+ }
+
+ qbDataArea.stVersion = qryRespBackupDataVersion;
+ qDataBlkArea.stVersion = DataBlkVersion ;
+ qDataBlkArea.bufferPtr = (char *)&qbDataArea;
+ qDataBlkArea.bufferLen = sizeof(qryRespBackupData);
+
+ numTypes = 0;
+ rc = AFSdsmGetNextQObj(dsmHandle, &qDataBlkArea);
+ while (((rc == DSM_RC_MORE_DATA) ||
+ (rc == DSM_RC_FINISHED)) &&
+ qDataBlkArea.numBytes)
+ { /* save copy Group we got */
+ listCopyGroup[numTypes] = qbDataArea.copyGroup;
+ listObjType[numTypes] = qbDataArea.objName.objType;
+ numTypes++;
+ rc = AFSdsmGetNextQObj(dsmHandle, &qDataBlkArea);
+ }
+
+ if (rc != DSM_RC_FINISHED)
+ {
+ xlateRC(BSAHandle, rc, &bsaRC);
+ if ((rc == DSM_RC_ABORT_NO_MATCH) || /* special rc for MarkInact */
+ (rc == DSM_RC_FILE_SPACE_NOT_FOUND))
+ bsaRC = BSA_RC_ABORT_ACTIVE_NOT_FOUND;
+ rc = AFSdsmEndQuery(dsmHandle);
+ XOPENRETURN(BSAHandle,"BSAMarkObjectInactive: AFSdsmGetNextQObj",
+ bsaRC,__FILE__,__LINE__);
+ }
+ rc = AFSdsmEndQuery(dsmHandle);
+
+ /*=== now we can do the delete ===*/
+ rc = AFSdsmBeginTxn(dsmHandle);
+
+ if (rc)
+ {
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle,"BSAMarkObjectInactive: AFSdsmBeginTxn",
+ bsaRC,__FILE__,__LINE__);
+ }
+ xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_DSM_TXN); /* set on */
+
+ delType = dtBackup; /* this only applies to Backup */
+
+ delInfo.backInfo.stVersion = delBackVersion;
+ delInfo.backInfo.objNameP = &dsmobjName;
+
+ for (i=0; i<numTypes; i++)
+ {
+ delInfo.backInfo.copyGroup = listCopyGroup[i];
+ dsmobjName.objType = listObjType[i];
+
+ if ((rc = AFSdsmDeleteObj(dsmHandle, delType, delInfo)) != DSM_RC_OK)
+ {
+
+ sprintf(traceStr2, "BSAMarkObjectInactive: call to AFSdsmDeleteObj error rc = %d", rc);
+ ourTrace(BSAHandle, TrFL, traceStr2);
+ }
+ }
+
+ /*=== issue EndTxn since these can't be nested because of Query sequence ===*/
+ AFSdsmEndTxn(dsmHandle, DSM_VOTE_COMMIT, &reason);
+ xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_DSM_TXN); /* set off */
+
+ xlateRC(BSAHandle, rc, &bsaRC);
+ XOPENRETURN(BSAHandle,"BSAMarkObjectInactive",
+ bsaRC,__FILE__,__LINE__);
+}
+
+#endif /*xbsa*/
--- /dev/null
+/*
+ * 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
+ */
+
+#ifndef _BSA_XBSA_H_
+#define _BSA_XBSA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if (SYS_V > 3) || defined(BERK4_2) || defined(SUN4)
+#include <sys/time.h>
+#else
+#include <time.h>
+#endif
+
+#ifdef bool_t
+#undef bool_t
+#endif
+
+/* include TSM Header Files. */
+#include <dsmapitd.h>
+#include <dsmapifp.h>
+#include <dsmrc.h>
+
+/* BSA_Boolean */
+typedef char BSA_Boolean;
+
+/* BSA_Int16 */
+typedef short BSA_Int16;
+
+/* BSA_Int32 */
+typedef long BSA_Int32;
+
+/* BSA_Int64 */
+typedef struct { /* defined as two 32-bit integers */
+ BSA_Int32 left;
+ BSA_Int32 right;
+} BSA_Int64;
+
+/* BSA_UInt16 */
+typedef unsigned short BSA_UInt16;
+
+/* BSA_UInt32 */
+typedef unsigned long BSA_UInt32;
+
+/* BSA_UInt64 */
+typedef struct { /* defined as two unsigned 32-bit integers*/
+ BSA_UInt32 left;
+ BSA_UInt32 right;
+} BSA_UInt64;
+
+/*-------------------------------------------------------------------------+
+| ADSM specific constants and return codes |
++-------------------------------------------------------------------------*/
+/* TSM library version, release, level
+ */
+#define BSA_API_VERSION 5
+#define BSA_API_RELEASE 2
+#define BSA_API_LEVEL 0
+
+/* Constants used */
+#define ADSM_MAX_DESC 100 /* ADSM max Desc size */
+#define ADSM_MAX_OBJINFO 100 /* ADSM max object info size */
+#define ADSM_LOWEST_BOUND 0x0000 /* value for LowerBound min */
+#define ADSM_HIGHEST_BOUND 0xFFFF /* value for UpperBound max */
+#define ADSM_ENV_STRS 3 /* number of env strings */
+#define ObjectDescriptorVersion 1 /* ver for ObjectDescriptor */
+#define UserDescriptorVersion 1 /* ver for UserDescriptor */
+#define BSAObjectType_DATABASE 4 /* ObjectType for Databases */
+
+/* Return Codes Used
+ */
+#define BSA_RC_OK 0x00
+#define BSA_RC_SUCCESS 0x00
+
+#define ADSM_RC_ERROR 0x60 /* see ADSM error log */
+#define ADSM_RC_INVALID_NODE 0x61 /* BSAObjOwner not match Init*/
+#define ADSM_RC_INVALID_COPYTYPE 0x62 /* invalid copyType */
+#define ADSM_RC_INVALID_OBJTYPE 0x63 /* invalid objectType */
+#define ADSM_RC_INVALID_STATUS 0x64 /* invalid object status */
+#define ADSM_RC_INVALID_ST_VER 0x65 /* invalid structure version */
+#define ADSM_RC_OWNER_TOO_LONG 0x66 /* owner too long */
+#define ADSM_RC_PSWD_TOO_LONG 0x67 /* pswd too long */
+#define ADSM_RC_PSWD_GEN 0x68 /* pswd access = generate */
+
+/* Constants used
+ *
+ * Maximum string lengths (lower bound), including trailing null
+ */
+#define BSA_LIST_ELEMENT_DELIMITER null /* Element delimiter in list */
+#define BSA_MAX_ADMIN_NAME 64 /* Administrator name */
+#define BSA_MAX_APPOBJECT_OWNER 64 /* Max end-object owner length */
+#define BSA_MAX_BSAOBJECT_OWNER 64 /* Max BSA object owner length */
+#define BSA_MAX_CG_DEST 31 /* Copy group destination */
+#define BSA_MAX_CG_NAME 31 /* Max copy group name length */
+#define BSA_MAX_COPYGROUPS 16 /* Max number of copy groups */
+ /* which can be specified in a */
+ /* lifecycle group */
+#define BSA_MAX_DESC 256 /* Description field */
+#define BSA_MAX_ENCODINGMETHOD 31 /* Max encoding method length */
+#define BSA_MAX_EVENTINFO 256 /* Max event info size */
+#define BSA_MAX_FILTERRULESET 8192 /* Max filter rule set size */
+#define BSA_MAX_OSNAME 1024 /* Max Objectspace name length */
+#define BSA_MAX_LG_NAME 31 /* Life cycle group name */
+#define BSA_MAX_LIFECYCLEGROUPS 64 /* Max number of life cycle */
+ /* groups in a policy set */
+#define BSA_MAX_OBJINFO 512 /* Max object info size */
+#define BSA_MAX_PATHNAME 1024 /* Max path name length */
+#define BSA_MAX_POLICYDOMAINS 256 /* Max number of specific policy */
+ /* domains an administrator may */
+ /* be responsible for */
+#define BSA_MAX_POLICYDOMAIN_NAME 31 /* Policy domain name */
+#define BSA_MAX_POLICYSETS 16 /* Max number of policy sets */
+ /* in a domain */
+#define BSA_MAX_POLICYSET_NAME 31 /* Policy set name */
+#define BSA_MAX_RESOURCETYPE 31 /* Max resource mgr name length */
+#define BSA_MAX_TOKEN_SIZE 64 /* Max size of a security token */
+#define BSA_PUBLIC "BSA_ANY" /* Default string */
+
+/* Return Codes Used
+ *
+ * Return Code descriptions are given in Section 4.3.
+ */
+#define BSA_RC_ABORT_ACTIVE_NOT_FOUND 0x02
+#define BSA_RC_ABORT_SYSTEM_ERROR 0x03
+#define BSA_RC_AUTHENTICATION_FAILURE 0x04
+#define BSA_RC_BAD_CALL_SEQUENCE 0x05
+#define BSA_RC_BAD_HANDLE 0x06
+#define BSA_RC_BUFFER_TOO_SMALL 0x07
+#define BSA_RC_DESC_TOO_LONG 0x08
+#define BSA_RC_OBJECTSPACE_TOO_LONG 0x09
+#define BSA_RC_INVALID_TOKEN 0x0a
+#define BSA_RC_INVALID_VOTE 0x0b
+#define BSA_RC_INVALID_KEYWORD 0x0c
+#define BSA_RC_MATCH_EXISTS 0x0d
+#define BSA_RC_MORE_DATA 0x0e
+#define BSA_RC_MORE_RULES 0x0f
+#define BSA_RC_NEWTOKEN_REQD 0x10
+#define BSA_RC_NO_MATCH 0x11
+#define BSA_RC_NO_MORE_DATA 0x12
+#define BSA_RC_NO_RESOURCES 0x13
+#define BSA_RC_NULL_DATABLKPTR 0x14
+#define BSA_RC_NULL_OBJNAME 0x15
+#define BSA_RC_NULL_POINTER 0x16
+#define BSA_RC_NULL_RULEID 0x17
+#define BSA_RC_OBJECT_NAME_TOO_LONG 0x18
+#define BSA_RC_OBJECT_NOT_EMPTY 0x19
+#define BSA_RC_OBJECT_NOT_FOUND 0x1a
+#define BSA_RC_OBJINFO_TOO_LONG 0x1b
+#define BSA_RC_OBJNAME_TOO_LONG 0x1c
+#define BSA_RC_OPERATION_NOT_AUTHORIZED 0x1d
+#define BSA_RC_OLDTOKEN_REQD 0x1e
+#define BSA_RC_TOKEN_EXPIRED 0x1f
+#define BSA_RC_TXN_ABORTED 0x20
+#define BSA_RC_UNMATCHED_QUOTE 0x21
+#define BSA_RC_USER_OWNS_OBJECTS 0x22
+
+/* AppObjectOwner
+ */
+typedef char AppObjectOwner[BSA_MAX_APPOBJECT_OWNER];
+
+/* BSAObjectOwner
+ */
+typedef char BSAObjectOwner[BSA_MAX_BSAOBJECT_OWNER];
+
+/* CopyGpDest
+ */
+typedef char CopyGpDest[BSA_MAX_CG_DEST];
+
+/* CopyGpName
+ */
+typedef char CopyGpName[BSA_MAX_CG_NAME];
+
+/* CopyMode
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * INCREMENTAL 1 Specifies that the Backup Services should make a
+ * copy only if the application object has been
+ * modified since the last time this copy group was
+ * used to create the object's copy.
+ * ABSOLUTE 2 Specifies that the Backup Services should make a
+ * copy even if the application object has not been
+ * modified since the last time this copy group was
+ * used to create the object's copy.
+ */
+typedef enum {
+ BSACopyMode_INCREMENTAL = 1,
+ BSACopyMode_ABSOLUTE = 2
+} CopyMode;
+
+/* CopySerialization
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * STATIC 1 Specifies that the Backup Services must create a
+ * consistent (unmodified during the operation) copy of
+ * the object. If the application is unable to create a
+ * consistent copy then it should skip the operation
+ * (creating backup or archive copy) for the object.
+ * SHAREDSTATIC 2 Specifies that the Backup Services must create a
+ * consistent copy of the object. It can retry the
+ * operation a number of times (application dependent).
+ * If the Backup Services is unable to create a
+ * consistent copy even after retries, then it should
+ * skip creating a backup or archive copy of the
+ * object.
+ * SHAREDDYNAMIC 3 Specifies that the Backup Services must create a
+ * copy of the object. It can retry the operation a
+ * number of times in an attempt to create a consistent
+ * copy; however, if it fails to make a consistent
+ * copy, a copy must still be made, ignoring the fact
+ * that the copy may have been modified during the
+ * operation. Such copies are useful for log file
+ * objects which are being continuously modified.
+ * DYNAMIC 4 Specifies that the Backup Services must create a
+ * copy of the obbject even if the source object is
+ * modified during the operation. No retries should be
+ * attempted to create a consistent copy.
+ */
+typedef enum {
+ BSACopySerialization_STATIC = 1,
+ BSACopySerialization_SHAREDSTATIC = 2,
+ BSACopySerialization_SHAREDDYNAMIC = 3,
+ BSACopySerialization_DYNAMIC = 4
+} CopySerialization;
+
+/* CopyType
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * ANY 1 Used for matching any copy type (e.g. "backup" or
+ * "archive" in the copy type field of structures for
+ * selecting query results).
+ * ARCHIVE 2 Specifies that the copy type should be "archive".
+ * When used in the copy type field of the CopyGroup,
+ * it identifies the copy data as of type
+ * ArchiveCopyData, which is used to create archive
+ * copies.
+ * BACKUP 3 Specifies that the copy type should be "backup".
+ * When used in the copy type field of the CopyGroup,
+ * it identifies the copy data as of type
+ * BackupCopyData, which is used to create backup
+ * copies.
+ */
+typedef enum {
+ BSACopyType_ANY = 1,
+ BSACopyType_ARCHIVE = 2,
+ BSACopyType_BACKUP = 3
+} CopyType;
+
+/* Description
+ */
+typedef char Description[BSA_MAX_DESC];
+
+/* DomainName
+ */
+typedef char * DomainName[BSA_MAX_POLICYDOMAIN_NAME];
+
+/* EventInfo
+ */
+typedef char EventInfo[BSA_MAX_EVENTINFO];
+
+/* LGName
+ */
+typedef char LGName[BSA_MAX_LG_NAME];
+
+/* ObjectInfo
+ */
+typedef char ObjectInfo[BSA_MAX_OBJINFO];
+
+/* ObjectName
+ */
+typedef struct {
+ char objectSpaceName[BSA_MAX_OSNAME]; /* Highest-level name qualifier */
+ char pathName[BSA_MAX_PATHNAME]; /* Object name within */
+ /* objectspace */
+} ObjectName;
+
+/* ObjectOwner
+ */
+typedef struct {
+ BSAObjectOwner bsaObjectOwner; /* BSA Owner name - this is the name */
+ /* that Backup Services authenticates */
+ AppObjectOwner appObjectOwner; /* End-owner name, this is the name */
+ /* defined by the application */
+} ObjectOwner;
+
+/* ObjectSize
+ */
+typedef BSA_UInt64 ObjectSize; /* Unsigned 64-bit integer */
+
+/* ObjectStatus
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * ANY 1 Provides a wild card function. Can only be used in
+ * queries.
+ * ACTIVE 2 Indicates that this is the most recent backup copy
+ * of an object.
+ * INACTIVE 3 Indicates that this is not the most recent backup
+ * copy, or that the object itself no longer exists.
+ */
+typedef enum {
+ BSAObjectStatus_ANY = 1,
+ BSAObjectStatus_ACTIVE = 2,
+ BSAObjectStatus_INACTIVE = 3
+} ObjectStatus;
+
+/* ObjectType
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * any 1 Used for matching any object type (e.g. "file" or
+ * "directory") value in the object type field of
+ * structures for selecting query results.
+ * file 2 Used by the application to indicate that the type of
+ * application object is a "file" or single object.
+ * directory 3 Used by the application to indicate that the type of
+ * application object is a "directory" or container of
+ * objects.
+ */
+
+typedef enum {
+ BSAObjectType_ANY = 1,
+ BSAObjectType_FILE = 2,
+ BSAObjectType_DIRECTORY = 3
+ } ObjectType;
+
+/* Operation
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * archive 1 Used to indicate that a scheduled operation is of
+ * type "archive".
+ * backup 2 Used to indicate that a scheduled operation is of
+ * type "backup".
+ */
+typedef enum {
+ BSAOperation_ARCHIVE = 1,
+ BSAOperation_BACKUP = 2
+} Operation;
+
+/* Period
+ *
+ * Use of the Period structure in a Schedule for an event:
+ * 1. The Schedule structure specifies 3 timing elements:
+ * a. "firstStartTime" - a timestamp showing the "earliest"
+ * possible time the event could take place
+ * b. "day" - the day of the week the event should occur
+ * c. "frequency" - the period between successive events
+ * 2. To determine the day the event should occur (this does
+ * not change the time of the event in the day):
+ * a. Determine the requested day from "firstStartTime".
+ * b. If "day" does not equal XBSA_DAYOFWEEK_ANY
+ * i. Compare "day" to the day of the week corresponding
+ * to "firstStartTime" determined in 2a above.
+ * ii.If the days match, then use "firstStartTime" else
+ * use the first "day" *following* the day shown
+ * in "firstStartTime" as the day of the event.
+ * 3. If the PeriodWhich field in the Period structure is other
+ * than XBSA_PERIOD_UNDEFINED, then successive events are
+ * determined using the value of "periodData".
+ * a. For seconds and days, the appropriate seconds or days
+ * are added to the "firstStartTime" and step 2 to correct
+ * for the day of the week (if needed) is applied again.
+ * b. If a monthly period is specified, then the appropriate
+ * number of months are added by incrementing the month index is
+ * made (for example, a one month increment from February to
+ * March). If the monthly date is not valid (for example, January
+ * 30 --> February 30) then the last day of the desired month is
+ * used (example January 30 --> February 28). Then step 2 is
+ * followed to adjust for the requested day (which might move the
+ * event time into the following month).
+ */
+typedef enum {
+ BSAPeriod_SECONDS = 1,
+ BSAPeriod_DAYS = 2,
+ BSAPeriod_MONTHS = 3,
+ BSAPeriod_UNDEFINED = -9,
+ BSAPeriod_DAILY = 4, BSAPeriod_WEEKLY = 5, BSAPeriod_MONTHLY = 6,
+ BSAPeriod_QUARTERLY = 7, BSAPeriod_ANNUALLY = 8
+} PeriodWhich;
+
+typedef struct {
+ PeriodWhich which;
+ union {
+ time_t nSeconds;
+ BSA_Int16 nDays;
+ BSA_Int16 nMonths;
+ } periodData;
+} Period;
+
+/* ResourceType
+ */
+typedef char ResourceType[BSA_MAX_RESOURCETYPE];
+
+/* RuleId
+ */
+typedef BSA_UInt64 RuleId;
+
+/* Scheduleid
+ */
+typedef BSA_UInt64 ScheduleId;
+
+/* AccessRight
+ *
+ * Constant Value Explanation
+ * -------- ----- -----------
+ * GET 1 Access right for getting an object from Backup
+ * Services, also includes access right for querying
+ * (getting attributes) an object from Backup Services.
+ * QUERY 2 Access right for querying (getting attributes) an
+ * object from Backup Services.
+ */
+typedef enum {
+ BSAAccessRight_GET = 1,
+ BSAAcessRight_QUERY = 2
+} AccessRight;
+
+/* AccessRule
+ */
+typedef struct {
+ RuleId ruleId; /* Provided by Backup Services */
+ ObjectName objName; /* Object name to be given access */
+ ObjectOwner objectOwner; /* BSA object owner and Applicaton object */
+ /* owner to be given access */
+ AccessRight rights; /* The access rights to be given */
+} AccessRule;
+
+/* ApiVersion
+ */
+typedef struct {
+ BSA_UInt16 version; /* Version of this API */
+ BSA_UInt16 release; /* Release of this API */
+ BSA_UInt16 level; /* Level of this API */
+} ApiVersion;
+
+/* ArchiveCopyData
+ */
+typedef struct {
+ CopyGpName cGName; /* Copy group name */
+ BSA_UInt16 freq; /* Archive frequency */
+ CopySerialization copySer; /* Copy serialization code */
+ CopyMode copyMode; /* Copy mode */
+ CopyGpDest destName; /* Copy destination name */
+ BSA_UInt16 retVersion; /* Retention time for the version */
+} ArchiveCopyData;
+
+/* BackupCopyData
+ */
+typedef struct {
+ CopyGpName cGName; /* Copy group name */
+ BSA_UInt16 freq; /* Backup frequency */
+ CopySerialization copySer; /* Copy serialization code */
+ CopyMode copyMode; /* Copy mode: 1=modified, 2=absolute */
+ CopyGpDest destName; /* Copy destination name */
+ BSA_UInt16 verDataEx; /* Versions (number of versions */
+ /* retained) */
+ BSA_UInt16 verDataDel; /* Versions (data deleted) */
+ Period retXtraVer; /* Retain extra versions */
+ Period retOnlyVer; /* Retain only versions */
+} BackupCopyData;
+
+/* CopyGroup
+ */
+typedef struct {
+ CopyType copyType; /* Type of copy group: archive, backup, etc */
+ union {
+ ArchiveCopyData archive;
+ BackupCopyData backup;
+ } copyData;
+} CopyGroup;
+
+/* CopyId
+ */
+typedef BSA_UInt64 CopyId;
+
+/* DataBlock
+ */
+typedef struct {
+ BSA_UInt16 bufferLen;
+ BSA_UInt16 numBytes; /* Actual number of bytes read from */
+ /* or written to the buffer, or the */
+ /* minimum number of bytes needed */
+ char * bufferPtr;
+} DataBlock;
+
+/* DayOfWeek
+ */
+typedef enum {
+ BSADayOfWeek_Monday = 1, BSADayOfWeek_Tuesday = 2,
+ BSADayOfWeek_Wednesday = 3, BSADayOfWeek_Thursday = 4,
+ BSADayOfWeek_Friday = 5, BSADayOfWeek_Saturday = 6,
+ BSADayOfWeek_Sunday = 7
+} DayOfWeek;
+
+/* Environment
+ */
+typedef struct {
+ char * envVariables; /* Identifies the Backup Services instance and other */
+ /* implementation-dependent variables such as */
+ /* communication ports, etc. Each variable is a */
+ /* (keyword, value) pair separated by a space. */
+ /* If a value contains spaces, it must be */
+ /* enclosed in single or double quotes. */
+} BSAEnvironment;
+
+/* Event
+ */
+typedef struct {
+ BSA_UInt32 eventId; /* This is an internal (to Backup Services) id*/
+ ObjectOwner objectOwner;/* Identifies the owner of the event */
+ struct tm time; /* Identifies the time the action is to start */
+ Operation action; /* Identifies the action (backup, archive) */
+ ObjectName objName; /* Identifies objects to be acted on */
+ ResourceType resourceType;/* Identifies the resource manager for the */
+ /* event */
+ EventInfo eventInfo; /* User- and resource-manager-specific info */
+} BSAEvent;
+
+/* MethodName
+ */
+typedef char EncodingMethod[BSA_MAX_ENCODINGMETHOD];
+
+/* ObjectDescriptor
+ */
+typedef struct {
+ BSA_UInt32 version; /* Version number for this structure */
+ ObjectOwner Owner; /* Owner of the object */
+ ObjectName objName; /* Object name */
+ struct tm createTime; /* Supplied by Backup Services */
+ CopyType copyType; /* Copy type: archive or backup */
+ CopyId copyId; /* Supplied by Backup Services */
+ BSA_UInt64 restoreOrder; /* Supplied by Backup Services */
+ LGName lGName; /* Associated Lifecycle Group name */
+ CopyGpName cGName; /* Copy group within the lifecycle group */
+ ObjectSize size; /* Object size may be up to 63 bits */
+ ResourceType resourceType; /* e.g. UNIX file system */
+ ObjectType objectType; /* e.g. file, directory, etc. */
+ ObjectStatus status; /* Active/inactive, supplied by */
+ /* Backup Services */
+ EncodingMethod * encodingList; /* List of encoding Methods used, in */
+ /* application-defined order, */
+ /* terminated with a null entry */
+ Description desc; /* Descriptive label for the object */
+ ObjectInfo objectInfo; /* Application information */
+} ObjectDescriptor;
+
+/* QueryDescriptor
+ */
+typedef struct {
+ ObjectOwner owner; /* Owner of the object */
+ ObjectName objName; /* Object name */
+ struct tm createTimeLB; /* Lower bound on create time */
+ struct tm createTimeUB; /* Upper bound on create time */
+ struct tm expireTimeLB; /* Lower bound on expiration time */
+ struct tm expireTimeUB; /* Upper bound on expiration time */
+ CopyType copyType; /* Copy type: archive or backup */
+ LGName lGName; /* Associated Lifecycle Group name */
+ CopyGpName cGName; /* Copy group within the lifecycle group */
+ ResourceType resourceType; /* e.g. UNIX file system */
+ ObjectType objectType; /* e.g. file, directory, etc. */
+ ObjectStatus status; /* Active/inactive, supplied by Backup */
+ /* Services */
+ Description desc; /* Descriptive label for the object */
+} QueryDescriptor; /* "*" is interpreted as a meta character */
+ /* wild card. */
+ /* Any undefined value is interpreted as */
+ /* an error. */
+
+/* Schedule
+ */
+typedef struct {
+ ScheduleId schedId; /* Provided by Backup Services */
+ ObjectOwner objectOwner; /* Specifies the owner of the schedule */
+ Operation operation; /* Specifies the action to be taken */
+ struct tm firstStartTime; /* Specifies the first time the action */
+ /* is to take place */
+ DayOfWeek day; /* Specifies the day of week for the event*/
+ Period frequency; /* Specifies the frequency, e.g. daily */
+ ObjectName objectName; /* Identifies objects to be acted on */
+ ResourceType resourceType; /* Identifies the resource manager for the*/
+ /* schedule */
+ EventInfo scheduleInfo; /* Resource manager specific information */
+} Schedule;
+
+/* Security Token
+ */
+typedef char SecurityToken[BSA_MAX_TOKEN_SIZE];
+
+/* StreamHandle
+ */
+typedef int StreamHandle;
+
+/* UserDescriptor
+ */
+typedef struct t_UserDescriptor {
+ BSA_UInt16 version; /* Version num of this structure */
+ BSAObjectOwner bsaObjectOwner; /* BSA Object owner name */
+ DomainName domainName; /* Policy domain for the user */
+ Description desc; /* User information */
+} UserDescriptor;
+
+/* Vote
+ */
+typedef enum {
+ BSAVote_COMMIT = 1,
+ BSAVote_ABORT = 2
+} Vote;
+
+/* Function Prototypes for Data Movement API Subset
+ * Note that int and long have been replaced with typedefs
+ * from custom.h.
+ */
+
+extern BSA_Int16
+BSABeginTxn
+( long bsaHandle
+);
+
+extern BSA_Int16
+BSAChangeToken
+( long bsaHandle,
+ SecurityToken *oldTokenPtr,
+ SecurityToken *newTokenPtr
+);
+
+extern BSA_Int16
+BSACreateObject
+( long bsaHandle,
+ ObjectDescriptor *objectDescriptorPtr,
+ DataBlock *dataBlockPtr
+);
+
+extern BSA_Int16
+BSACreateObjectF
+( long bsaHandle,
+ ObjectDescriptor *objectDescriptorPtr,
+ StreamHandle *streamPtr
+);
+
+extern BSA_Int16
+BSADeleteObject
+( long bsaHandle,
+ CopyType copyType,
+ ObjectName *objectName,
+ CopyId *copyId
+);
+
+extern BSA_Int16
+BSAEndData
+( long bsaHandle
+);
+
+extern BSA_Int16
+BSAEndTxn
+( long bsaHandle,
+ Vote vote
+);
+
+extern BSA_Int16
+BSAGetData
+( long bsaHandle,
+ DataBlock *dataBlockPtr
+);
+
+extern BSA_Int16
+BSAGetEnvironment
+( long bsaHandle,
+ ObjectOwner *objectOwnerPtr,
+ char **environmentPtr
+);
+
+extern BSA_Int16
+BSAGetNextQueryObject
+( long bsaHandle,
+ ObjectDescriptor *objectDescriptorPtr
+);
+
+extern BSA_Int16
+BSAGetObject
+( long bsaHandle,
+ ObjectDescriptor *objectDescriptorPtr,
+ DataBlock *dataBlockPtr
+);
+
+extern BSA_Int16
+BSAGetObjectF
+( long bsaHandle,
+ ObjectDescriptor *objectDescriptorPtr,
+ StreamHandle *streamPtr
+);
+
+extern BSA_Int16
+BSAInit
+( long *bsaHandleP,
+ SecurityToken *tokenPtr,
+ ObjectOwner *objectOwnerPtr,
+ char **environmentPtr
+);
+
+extern BSA_Int16
+BSAMarkObjectInactive
+( long bsaHandle,
+ ObjectName *objectNamePtr
+);
+
+extern void
+BSAQueryApiVersion
+( ApiVersion *apiVersionPtr
+);
+
+extern BSA_Int16
+BSAQueryObject
+( long bsaHandle,
+ QueryDescriptor *queryDescriptorPtr,
+ ObjectDescriptor *objectDescriptorPtr
+);
+
+extern BSA_Int16
+BSASendData
+( long bsaHandle,
+ DataBlock *dataBlockPtr
+);
+
+extern BSA_Int16
+BSASetEnvironment
+( long bsaHandle,
+ char **environmentPtr
+);
+
+extern BSA_Int16
+BSATerminate
+( long bsaHandle
+);
+
+extern BSA_Int16
+BSAResolveLifecycleGroup(
+ long BSAHandle,
+ ObjectDescriptor *BSAobjDescP
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+typedef struct
+{
+ ApiSessInfo dsmSessInfo;
+ BSAObjectOwner bsaObjectOwner; /* node value on BSAInit */
+ dsUint16_t sessFlags; /* misc flags */
+ dsUint8_t oper; /* send or recv operation */
+ CopyType copyType; /* Backup or Archive type */
+ char *nextQryP; /* ptr to respArchive or respBackup */
+} xGlobal;
+
+/* flag masks for sessFlags */
+/* to set on use sessFlags = (sessFlags | FL_IN_BSA_TXN) */
+/* to set off use sessFlags = (sessFlags ^ FL_IN_BSA_TXN) */
+/* to test on use if (sessFlags & FL_IN_BSA_TXN) */
+#define FL_IN_BSA_TXN 0x0001 /* within a BSA type txn */
+#define FL_IN_DSM_TXN 0x0002 /* within a actual ADSM txn */
+#define FL_IN_BSA_QRY 0x0004 /* within a query txn */
+#define FL_PSWD_EXPIRE 0x0008 /* pswd has expired */
+#define FL_RC_WILL_ABORT 0x0010 /* recvd 157 on SendObj or SendData */
+#define FL_END_DATA_DONE 0x0020 /* Get error already did EndData */
+
+#define OPER_NONE 0 /* values for oper field */
+#define OPER_SEND_START 1
+#define OPER_SEND_ISSUED 2
+#define OPER_RECV_START 3
+#define OPER_RECV_ISSUED 4
+
+/* structure def for objInfo - max len = 255 */
+typedef struct
+{
+ ResourceType resourceType; /* 31 bytes */
+ ObjectSize size; /* 8 bytes */
+ char partDesc[ADSM_MAX_DESC]; /* 100 bytes */
+ char partObjInfo[ADSM_MAX_OBJINFO]; /* 100 bytes */
+} XAPIObjInfo;
+
+/* ******* G l o b a l s ******** */
+
+/* xGlobal xopenGbl; */
+
+extern BSA_Int16 xlateRC(
+ long BSAHandle,
+ BSA_Int16 dsmRC,
+ BSA_Int16 *bsaRCP);
+
+extern BSA_Int16 xparsePath(
+ long BSAHandle,
+ char *pathname,
+ char *hl,
+ char *ll);
+
+extern xGlobal xopenGbl;
+extern char traceStr[];
+extern char traceStr1[];
+extern char traceStr2[];
+
+#define dsMalloc(a) malloc(a)
+#define dsFree(a) free(a)
+
+extern void StrUpper(char *s);
+/* Min() and Max() macros */
+#ifndef min
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef max
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+
+/* Combined file name w/ line number */
+#define TrFL __FILE__, __LINE__
+
+/*=== MACRO for exit tracing ===*/
+#define XOPENRETURN(BSAHandle,functionName,bsaRC,fileName,lineNumber) {sprintf(traceStr2,"%s EXIT: rc = >%d<.",functionName, bsaRC); ourTrace(BSAHandle,fileName,lineNumber,traceStr2); return(bsaRC);}
+
+/* Define license error log file name */
+#define TSMLicLog "tsmlic.log"
+
+#define custMin_retcode 96
+#define custMax_retcode 104
+
+/*=======================================================
+ Function to places a trace message in the API tracefile,
+ the message includes the xopen file name and line number.
+ ======================================================*/
+void ourTrace(long BSAHandle,
+ char *fileName,
+ int lineNumber,
+ char *traceStr2);
+
+/*================================================
+ Function to log events with call to dsmLogEventEx
+ ===============================================*/
+void ourLogEvent_Ex(dsUint32_t handle, dsmLogType type, char* msg,
+ char *appMsg, dsmLogSeverity severity);
+
+/*=================================================================
+ Function to retrieve a message by routing to dsmRCMsg or stdXOpenMsgMap.
+ ===============================================================*/
+char* ourRCMsg(dsInt16_t dsmRC, char *msg);
+
+/*====================================================
+ Function to build fully qualified license file name.
+ void build_lfname(char *lfname
+ ========================================================*/
+extern void build_lfname(char *lfname);
+
+/*=== Function to deliver standard XOpen API message above API range. */
+void stdXOpenMsgMap(dsInt16_t, char*);
+
+
+#endif /* xbsa */
git://git.openafs.org / openafs.git / commitdiff