src/butc/afsxbsa.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #ifdef xbsa
  11
  12 #include <afsconfig.h>
  13 #include <afs/param.h>
  14 #include <afs/stds.h>
  15
  16 #include <roken.h>
  17
  18 #include <ctype.h>
  19
  20 #if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV)
  21 #include <dlfcn.h>
  22 #endif
  23
  24 #include <afs/tcdata.h>
  25 #include "butc_xbsa.h"
  26 #include <afs/butx.h>
  27 #include "butc_internal.h"
  28
  29 /* Global Definations */
  30 #define APPLTYPE "afs-butc"
  31 #define TDP_LIBNAME "libApiDS.a"
  32 #define FIRST_HANDLE 1
  33 #define NOHANDLE 0
  34 #define XAPI_FSINFO "FS for XOpen API"
  35 #define DIR_DELIMITER '/'
  36 #define STR_DIR_DELIMITER "/"
  37
  38 xGlobal xopenGbl;
  39 char traceStr[DSM_MAX_RC_MSG_LENGTH+1];
  40 char traceStr2[(DSM_MAX_RC_MSG_LENGTH+1) - 30];
  41 char ourMsg[DSM_MAX_RC_MSG_LENGTH + 1];
  42 static int dsm_init = 0 ;
  43
  44 /* >>>  TSM function pointers. */
  45 dsInt16_t (* AFSdsmBeginQuery)( dsUint32_t dsmHandle, dsmQueryType queryType, dsmQueryBuff *queryBuffer);
  46 dsInt16_t (* AFSdsmGetNextQObj)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr) ;
  47 dsInt16_t (* AFSdsmEndQuery)( dsUint32_t dsmHandle);
  48 dsInt16_t (* AFSdsmRCMsg)( dsUint32_t dsmHandle, dsInt16_t dsmRC, char *msg);
  49 dsInt16_t (* AFSdsmLogEventEx)( dsUint32_t dsmHandle, dsmLogExIn_t *dsmLogExInP, dsmLogExOut_t *dsmLogExOutP);
  50 dsInt16_t (* AFSdsmTrace)( dsUint32_t dsmHandle, char * string );
  51 dsInt16_t (* AFSdsmTerminate)( dsUint32_t dsmHandle);
  52 dsInt16_t (* AFSdsmSendData)( dsUint32_t dsmHandle, DataBlk *dataBlkPtri);
  53 dsInt16_t (* AFSdsmBeginTxn)( dsUint32_t dsmHandle);
  54 dsInt16_t (* AFSdsmDeleteObj)( dsUint32_t dsmHandle, dsmDelType delType, dsmDelInfo delInfo);
  55 dsInt16_t (* AFSdsmEndTxn)( dsUint32_t dsmHandle, dsUint8_t vote, dsUint16_t *reason);
  56 void (* AFSdsmQueryApiVersion)( dsmApiVersion *apiVersionP);
  57 dsInt16_t (* AFSdsmInit)( dsUint32_t *dsmHandle, dsmApiVersion *dsmApiVersionP, char *clientNodeNameP, char *clientOwnerNameP, char *clientPasswordP, char *applicationType, char *configfile, char *options);
  58 dsInt16_t (* AFSdsmQuerySessInfo)( dsUint32_t dsmHandle, ApiSessInfo *SessInfoP);
  59 dsInt16_t (* AFSdsmBeginGetData)(dsUint32_t dsmHandle, dsBool_t mountWait, dsmGetType getType, dsmGetList *dsmGetObjListP);
  60 dsInt16_t (* AFSdsmGetObj)( dsUint32_t dsmHandle, ObjID *objIdP, DataBlk *dataBlkPtr);
  61 dsInt16_t (* AFSdsmEndGetObj)( dsUint32_t dsmHandle);
  62 dsInt16_t (* AFSdsmEndGetData)( dsUint32_t dsmHandle);
  63 dsInt16_t (* AFSdsmGetData)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr);
  64 dsInt16_t (* AFSdsmEndSendObj)( dsUint32_t dsmHandle);
  65 dsInt16_t (* AFSdsmRegisterFS)( dsUint32_t dsmHandle, regFSData *regFilespaceP);
  66 dsInt16_t (* AFSdsmBindMC)( dsUint32_t dsmHandle, dsmObjName *objNameP, dsmSendType sendType, mcBindKey *mcBindKeyP);
  67 dsInt16_t (* AFSdsmSendObj)( dsUint32_t dsmHandle, dsmSendType sendType, void *sendBuff, dsmObjName *objNameP, ObjAttr *objAttrPtr, DataBlk *dataBlkPtr);
  68 dsInt16_t (* AFSdsmChangePW)( dsUint32_t dsmHandle, char *oldPW, char *newPW);
  69 #if 0
  70 dsInt16_t (* AFSdsmCleanUp)( dsBool_t mtFlag);
  71 dsInt16_t (* AFSdsmDeleteAccess)( dsUint32_t dsmHandle, dsUint32_t ruleNum);
  72 dsInt16_t (* AFSdsmDeleteFS)( dsUint32_t dsmHandle, char *fsName, dsUint8_t repository);
  73 dsInt16_t (* AFSdsmEndGetDataEx)( dsmEndGetDataExIn_t *dsmEndGetDataExInP, dsmEndGetDataExOut_t *dsmEndGetDataExOutP);
  74 dsInt16_t (* AFSdsmEndSendObjEx)( dsmEndSendObjExIn_t *dsmEndSendObjExInP, dsmEndSendObjExOut_t *dsmEndSendObjExOutP);
  75 dsInt16_t (* AFSdsmEndTxnEx)( dsmEndTxnExIn_t *dsmEndTxnExInP, dsmEndTxnExOut_t *dsmEndTxnExOutP);
  76 dsInt16_t (* AFSdsmGroupHandler)( dsmGroupHandlerIn_t *dsmGroupHandlerInP, dsmGroupHandlerOut_t  *dsmGroupHandlerOutP);
  77 dsInt16_t (* AFSdsmInitEx)( dsUint32_t *dsmHandleP, dsmInitExIn_t *dsmInitExInP, dsmInitExOut_t *dsmInitExOutP);
  78 dsInt16_t (* AFSdsmLogEvent)( dsUint32_t dsmHandle, logInfo *lopInfoP);
  79 dsInt16_t (* AFSdsmQueryAccess)( dsUint32_t dsmHandle, qryRespAccessData **accessListP, dsUint16_t *numberOfRules);
  80 void      (* AFSdsmQueryApiVersionEx)( dsmApiVersionEx *apiVersionP);
  81 dsInt16_t (* AFSdsmQueryCliOptions)( optStruct *optstructP);
  82 dsInt16_t (* AFSdsmQuerySessOptions)( dsUint32_t dsmHandle, optStruct *optstructP);
  83 dsInt16_t (* AFSdsmRenameObj)( dsmRenameIn_t *dsmRenameInP, dsmRenameOut_t *dsmRenameOutP);
  84 dsInt16_t (* AFSdsmSetAccess)( dsUint32_t dsmHandle, dsmAccessType accessType, dsmObjName *objNameP, char *node, char *owner);
  85 dsInt16_t (* AFSdsmSetUp)( dsBool_t mtFlag, envSetUp *envSetUpPi);
  86 dsInt16_t (* AFSdsmUpdateFS)( dsUint32_t dsmHandle, char *fs, dsmFSUpd *fsUpdP, dsUint32_t fsUpdAct);
  87 dsInt16_t (* AFSdsmUpdateObj)( dsUint32_t dsmHandle, dsmSendType sendType, void *sendBuff, dsmObjName *objNameP, ObjAttr *objAttrPtr, dsUint32_t objUpdAct);
  88 #endif
  89 /* <<< TSM function pointers. */
  90
  91 typedef struct s_delList {
  92   struct s_delList *next;
  93   ObjID           objId;
  94 } delList;
  95
  96 static dsInt16_t buildList(
  97     dsUint32_t     dsmHandle,
  98     dsmObjName     *objNameP,
  99     delList        **llHeadPP,
 100     delList        **llTailPP)
 101 {
 102    dsInt16_t            rc;
 103    qryArchiveData       queryBuffer;       /* for query Archive*/
 104    qryRespArchiveData   qaDataArea;
 105    DataBlk              qDataBlkArea;
 106    char                 descrStar[] = "*";
 107    delList              *lnew = NULL, *ll = NULL;
 108
 109    queryBuffer.stVersion = qryArchiveDataVersion ;
 110    queryBuffer.objName = objNameP;
 111    queryBuffer.owner = xopenGbl.dsmSessInfo.owner;
 112    queryBuffer.insDateLowerBound.year = DATE_MINUS_INFINITE;
 113    queryBuffer.insDateUpperBound.year = DATE_PLUS_INFINITE;
 114    queryBuffer.expDateLowerBound.year = DATE_MINUS_INFINITE;
 115    queryBuffer.expDateUpperBound.year = DATE_PLUS_INFINITE;
 116    queryBuffer.descr = descrStar;
 117
 118    if ((rc=AFSdsmBeginQuery(dsmHandle, qtArchive,
 119                         (void *)&queryBuffer )) != DSM_RC_OK)
 120    {
 121       XOPENRETURN(dsmHandle,"buildList(AFSdsmBeginQuery)",rc,__FILE__,__LINE__);
 122    }
 123    qaDataArea.stVersion = qryRespArchiveDataVersion;
 124    qDataBlkArea.stVersion = DataBlkVersion ;
 125    qDataBlkArea.bufferPtr = (char *)&qaDataArea;
 126    qDataBlkArea.bufferLen = sizeof(qryRespArchiveData);
 127    while ((rc = AFSdsmGetNextQObj(dsmHandle, &qDataBlkArea)) == DSM_RC_MORE_DATA)
 128    {
 129      if (!(lnew = (delList *)dsMalloc(sizeof(delList))))
 130         XOPENRETURN(dsmHandle,"buildList(AFSdsmGetNextQObj)",
 131                     DSM_RC_NO_MEMORY,__FILE__,__LINE__);
 132
 133      if (!*llHeadPP)
 134      {
 135         *llHeadPP = lnew;
 136         *llTailPP = lnew;
 137      }
 138      else
 139      {
 140         ll = *llTailPP;
 141         ll->next = lnew;
 142         *llTailPP = lnew;
 143      }
 144
 145      lnew->next = NULL;
 146      lnew->objId.hi = qaDataArea.objId.hi;
 147      lnew->objId.lo = qaDataArea.objId.lo;
 148    }
 149
 150    if (rc != DSM_RC_FINISHED)
 151    {
 152       AFSdsmEndQuery(dsmHandle);
 153       XOPENRETURN(dsmHandle,"buildList(AFSdsmGetNextQObj)",
 154                   rc,__FILE__,__LINE__);
 155    }
 156
 157    if ((rc = AFSdsmEndQuery(dsmHandle)) != DSM_RC_OK)
 158    {
 159       sprintf(traceStr2, "buildList: AFSdsmEndQuery rc = %d", rc);
 160       ourTrace(dsmHandle,TrFL,traceStr2);
 161    }
 162    XOPENRETURN(dsmHandle,"buildList",rc,__FILE__,__LINE__);
 163 }
 164
 165 static dsInt16_t  freeList(
 166     delList    **llHeadPP,
 167     delList    **llTailPP)
 168 {
 169
 170    delList *ll;
 171    ll = *llHeadPP;
 172    while (ll)
 173    {
 174       *llHeadPP = ll->next;
 175       dsFree(ll);
 176       ll = *llHeadPP;
 177    }
 178    *llHeadPP = NULL;
 179    *llTailPP = NULL;
 180    XOPENRETURN(0,"freeList",0,__FILE__,__LINE__);
 181 }
 182
 183 void ourTrace(long           BSAHandle,
 184               char          *fileName,
 185               int            lineNumber,
 186               char          *traceStr2)
 187 {
 188
 189    sprintf(traceStr,"%s (%d) ",fileName, lineNumber);
 190
 191    if (traceStr2 != NULL && *traceStr2 != '\0')
 192       strcat(traceStr, traceStr2);
 193
 194    AFSdsmTrace(BSAHandle, traceStr);
 195    return;
 196 }
 197
 198 void ourLogEvent_Ex(dsUint32_t dsmHandle, dsmLogType type, char *message,
 199                     char *appMsg, dsmLogSeverity severity)
 200 {
 201    dsmLogExIn_t dsmLogIn;
 202    dsmLogExOut_t dsmLogOut;
 203    memset(&dsmLogOut, '\0', sizeof(dsmLogExOut_t));
 204
 205    if (dsmHandle)
 206    {
 207       dsmLogIn.stVersion = dsmLogExInVersion;
 208       dsmLogIn.severity = severity;
 209       dsmLogIn.logType = type;
 210
 211       strcpy(dsmLogIn.appMsgID, appMsg);
 212       dsmLogIn.message = message;
 213       AFSdsmLogEventEx(dsmHandle, &dsmLogIn, &dsmLogOut);
 214    }
 215 }
 216
 217 char* ourRCMsg(dsInt16_t ourRC, char *msgPrefix)
 218 {
 219    char         appStr[BSA_MAX_DESC];
 220    char         *chP;
 221    int          bytesToCp;
 222
 223    memset(&ourMsg, 0x00, DSM_MAX_RC_MSG_LENGTH + 1);
 224    if(msgPrefix != NULL)
 225    {
 226        /*================================================================
 227         call stdXOpenMsgMap if return code values are within the TSM
 228         return code range (96 - 104). Reformat the message prefix
 229         (ANS0660 - ANS0668).
 230         ================================================================*/
 231         if ((ourRC >= custMin_retcode) && (ourRC <= custMax_retcode))
 232         {
 233              stdXOpenMsgMap(ourRC, ourMsg);
 234              /* set standard XOpen message prefix range: 660 - 668 */
 235              ourRC = ((ourRC * 10) / 16) + (ourRC % 16) + 600;
 236              sprintf(msgPrefix, "ANSO%d", ourRC);
 237         }
 238         else
 239           /*===============================================================
 240            call dsmRCMsg if return code values other then the above ranges.
 241            Get message prefix from the return message of dsmRCMsg.
 242            ===============================================================*/
 243         {
 244               AFSdsmRCMsg(NOHANDLE, ourRC, ourMsg);
 245              /*=========================================================
 246               search for the first ' ' and copy from beginning of string
 247               until before the two charecter before ' '.
 248               e.g. To get the code value from the messages of
 249                    "ANS1038S Invalid option specified", we only want to
 250                    get strings "ANS1038".
 251               ========================================================*/
 252               chP = (char *) strchr(ourMsg, ' ');
 253               bytesToCp = strlen(ourMsg) - (strlen(chP) + 1);
 254               strncpy(appStr, ourMsg, bytesToCp);
 255               sprintf(msgPrefix, "%s", appStr);
 256         }
 257    }
 258 return ourMsg;
 259 } /* ourRCMsg() */
 260
 261 void StrUpper(char *s)
 262 {
 263    while (*s != '\0')
 264    {
 265       if (isalpha((int)(unsigned char)*s))
 266          *s = (char)toupper((int)(unsigned char)*s);
 267       s++;
 268
 269    } /* end while */
 270 } /* StrUpper() */
 271
 272 BSA_Int16 xparsePath(
 273     long           BSAHandle,
 274     char          *pathname,
 275     char          *hl,
 276     char          *ll)
 277 {
 278    /*=== code taken from dscparse.c ParseDestOperand function ===*/
 279
 280    dsInt16_t    opLen;
 281    dsInt16_t    x;
 282
 283    *hl = *ll = '\0';
 284
 285    strcpy(hl, pathname);   /* use hl as working area */
 286    if ((opLen = strlen(hl)) > 0)
 287    {
 288       /*=== Find the ll portion of the name ===*/
 289       #ifdef MBCS
 290       {
 291          char *llstart;
 292          llstart = strrchr(hl,DIR_DELIMITER);
 293          if (llstart == NULL)
 294             x = 0;
 295          else
 296             x = llstart - hl;
 297       }
 298       #else
 299          for (x = opLen-1; x>0 && hl[x]!=DIR_DELIMITER; x--);
 300       #endif
 301
 302          /*=== If there is no leading delimiter then add one ===*/
 303          if (hl[x] != DIR_DELIMITER)
 304             strcpy(ll, STR_DIR_DELIMITER);
 305
 306          strncat(ll, hl+x, opLen-x);
 307
 308          hl[x] = '\0';          /* Shorten hl by length of ll */
 309    }
 310    return 0;
 311 }
 312
 313 BSA_Int16 xlateRC(
 314     long           BSAHandle,
 315     BSA_Int16      dsmRC,
 316     BSA_Int16      *bsaRCP)
 317
 318 {
 319    switch (dsmRC)
 320    {
 321       case DSM_RC_OK:
 322          *bsaRCP=BSA_RC_OK;                              break;
 323
 324       case DSM_RC_ABORT_ACTIVE_NOT_FOUND:
 325          *bsaRCP=BSA_RC_ABORT_ACTIVE_NOT_FOUND;          break;
 326
 327       case DSM_RC_ABORT_SYSTEM_ERROR:
 328          *bsaRCP=BSA_RC_ABORT_SYSTEM_ERROR;              break;
 329
 330       case DSM_RC_ABORT_BAD_VERIFIER:
 331       case DSM_RC_AUTH_FAILURE:
 332       case DSM_RC_REJECT_ID_UNKNOWN:
 333       case DSM_RC_REJECT_DUPLICATE_ID:
 334          *bsaRCP=BSA_RC_AUTHENTICATION_FAILURE;          break;
 335
 336       case DSM_RC_BAD_CALL_SEQUENCE:
 337          *bsaRCP=BSA_RC_BAD_CALL_SEQUENCE;               break;
 338
 339       case DSM_RC_INVALID_DS_HANDLE:
 340          *bsaRCP=BSA_RC_BAD_HANDLE;                      break;
 341
 342       case DSM_RC_BUFF_TOO_SMALL:
 343          *bsaRCP=BSA_RC_BUFFER_TOO_SMALL;                break;
 344
 345       case DSM_RC_DESC_TOOLONG:
 346          *bsaRCP=BSA_RC_DESC_TOO_LONG;                   break;
 347
 348       case DSM_RC_FILESPACE_TOOLONG:
 349          *bsaRCP=BSA_RC_OBJECTSPACE_TOO_LONG;            break;
 350
 351       /* some other condition here ? */
 352       case DSM_RC_PASSWD_TOOLONG:
 353          *bsaRCP=BSA_RC_INVALID_TOKEN;                   break;
 354
 355       case DSM_RC_INVALID_VOTE:
 356          *bsaRCP=BSA_RC_INVALID_VOTE;                    break;
 357
 358       case DSM_RC_INVALID_OPT:
 359          *bsaRCP=BSA_RC_INVALID_KEYWORD;                 break;
 360
 361       /*  ? what conditions cause this - object already exists ?
 362       case DSM_RC_?:
 363          *bsaRCP=BSA_RC_MATCH_EXISTS;                    break;
 364       */
 365
 366       case DSM_RC_MORE_DATA:
 367          *bsaRCP=BSA_RC_MORE_DATA;                       break;
 368
 369       /* not supported - for QueryAccessRule
 370       case :
 371          *bsaRCP=BSA_RC_MORE_RULES;                      break;
 372       */
 373
 374       case DSM_RC_NEWPW_REQD:
 375          *bsaRCP=BSA_RC_NEWTOKEN_REQD;                   break;
 376
 377       case DSM_RC_ABORT_NO_MATCH:
 378       case DSM_RC_FILE_SPACE_NOT_FOUND:
 379       /*=== rc for query ===*/
 380          *bsaRCP=BSA_RC_NO_MATCH;                        break;
 381       /*=== if this return code comes on Delete, use OBJECT_NOT_FOUND
 382             - see xopndel.c ===*/
 383
 384       case DSM_RC_FINISHED:
 385          *bsaRCP=BSA_RC_NO_MORE_DATA;                    break;
 386
 387       case DSM_RC_ABORT_NO_LOG_SPACE:
 388       case DSM_RC_ABORT_NO_DB_SPACE:
 389       case DSM_RC_ABORT_NO_MEMORY:
 390       case DSM_RC_ABORT_NO_REPOSIT_SPACE:
 391       case DSM_RC_REJECT_NO_RESOURCES:
 392       case DSM_RC_REJECT_NO_MEMORY:
 393       case DSM_RC_REJECT_NO_DB_SPACE:
 394       case DSM_RC_REJECT_NO_LOG_SPACE:
 395          *bsaRCP=BSA_RC_NO_RESOURCES;                    break;
 396
 397       case DSM_RC_NULL_DATABLKPTR:
 398          *bsaRCP=BSA_RC_NULL_DATABLKPTR;                 break;
 399
 400       case DSM_RC_NULL_OBJNAME:
 401          *bsaRCP=BSA_RC_NULL_OBJNAME;                    break;
 402
 403       case DSM_RC_NULL_BUFPTR:
 404          *bsaRCP=BSA_RC_NULL_POINTER;                    break;
 405
 406       /* not supported - for DeleteAccessRule
 407       case :
 408          *bsaRCP=BSA_RC_NULL_RULEID;                     break;
 409       */
 410
 411       case DSM_RC_HL_TOOLONG:
 412       case DSM_RC_LL_TOOLONG:
 413          *bsaRCP=BSA_RC_OBJECT_NAME_TOO_LONG;            break;
 414
 415       /* not supported - for DeletePolicyDomain
 416       case :
 417          *bsaRCP=BSA_RC_OBJECT_NOT_EMPTY;                break;
 418       */
 419
 420       /* same as NO_MATCH for DeleteObject
 421       case :
 422          *bsaRCP=BSA_RC_OBJECT_NOT_FOUND;                break;
 423       */
 424
 425       case DSM_RC_OBJINFO_TOOLONG:
 426          *bsaRCP=BSA_RC_OBJINFO_TOO_LONG;                break;
 427
 428       /* same as BSA_RC_OBJECT_NAME_TOO_LONG
 429       case :
 430          *bsaRCP=BSA_RC_OBJNAME_TOO_LONG;                break;
 431       */
 432
 433       /* not supported - for CreatePolicySet, etc
 434       case :
 435          *bsaRCP=BSA_RC_OPERATION_NOT_AUTHORIZED;        break;
 436       */
 437
 438       case DSM_RC_OLDPW_REQD:
 439          *bsaRCP=BSA_RC_OLDTOKEN_REQD;                   break;
 440
 441       case DSM_RC_REJECT_VERIFIER_EXPIRED:
 442          *bsaRCP=BSA_RC_TOKEN_EXPIRED;                   break;
 443
 444       case DSM_RC_WILL_ABORT:
 445       case DSM_RC_CHECK_REASON_CODE:
 446          *bsaRCP=BSA_RC_TXN_ABORTED;                     break;
 447
 448       case DSM_RC_UNMATCHED_QUOTE:
 449          *bsaRCP=BSA_RC_UNMATCHED_QUOTE;                 break;
 450
 451       /* not supported - for DeleteUser
 452       case :
 453          *bsaRCP=BSA_RC_USER_OWNS_OBJECT;                break;
 454       */
 455
 456       default:
 457       {
 458          /*=========================================================
 459           No suitable match, so print message in log, if we still
 460           have a handle.  AFSdsmInit calls ApiCleanUp in certain error
 461           situations.  We lose the handle in those cases so check
 462           for it.
 463           =========================================================*/
 464
 465          char         rcMsg[DSM_MAX_RC_MSG_LENGTH] ;
 466          char         errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
 467          char         ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
 468          dsUint32_t   dsmHandle;
 469
 470          memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
 471          memset(ourMessage,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
 472
 473          if (BSAHandle)
 474          {
 475             dsmHandle = BSAHandle;
 476             AFSdsmRCMsg(dsmHandle,dsmRC,rcMsg) ;
 477             strcat(rcMsg, "\n");
 478             sprintf(traceStr2,
 479                    "xlateRC - %s", rcMsg);
 480             ourTrace(BSAHandle,TrFL, traceStr2);
 481             strcpy(ourMessage, ourRCMsg(dsmRC, errPrefix));
 482             ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
 483          }
 484
 485          *bsaRCP = ADSM_RC_ERROR;
 486       }
 487    }
 488
 489    /*=== trace only if we have a valid handle ===*/
 490    if (dsmRC && BSAHandle)
 491    {
 492       sprintf(traceStr2, "xlateRC: TSM rc >%d< , BSA rc >%d<", dsmRC, *bsaRCP);
 493       ourTrace(BSAHandle, TrFL, traceStr2);
 494    }
 495    return DSM_RC_OK ;
 496 }
 497
 498 void stdXOpenMsgMap(dsInt16_t  rc,  char *msg)
 499 {
 500    switch(rc)
 501    {
 502       case ADSM_RC_ERROR:
 503            strcpy(msg, "TSM rc error, see ADSM error log.");
 504       case ADSM_RC_INVALID_NODE:
 505            strcpy(msg, "BSAObjectOwner doesn't match value session Init.");
 506            break;
 507
 508       case ADSM_RC_INVALID_COPYTYPE:
 509            strcpy(msg, "Invalid copy type.");
 510            break;
 511
 512       case ADSM_RC_INVALID_OBJTYPE:
 513            strcpy(msg, "Invalid object type.");
 514            break;
 515
 516       case ADSM_RC_INVALID_STATUS:
 517            strcpy(msg, "Invalid Object Status.");
 518            break;
 519
 520       case ADSM_RC_INVALID_ST_VER:
 521            strcpy(msg, "Invalid object descriptor structure version.");
 522            break;
 523
 524       case ADSM_RC_OWNER_TOO_LONG:
 525            strcpy(msg, "Object owner name too long.");
 526            break;
 527
 528       case ADSM_RC_PSWD_TOO_LONG:
 529            strcpy(msg, "Client password too long.");
 530            break;
 531
 532      case ADSM_RC_PSWD_GEN:
 533           strcpy(msg, "Password input required .");
 534           break;
 535
 536      default:
 537            strcpy(msg, "No message available");
 538            break;
 539    }
 540 }
 541
 542 BSA_Int16 fillArchiveResp(
 543 long                BSAHandle,
 544 ObjectDescriptor   *BSAobjDescP,
 545 qryRespArchiveData *respArchiveP
 546 )
 547 {
 548    XAPIObjInfo   *xapiObjInfoP;
 549
 550    strcpy(BSAobjDescP->Owner.appObjectOwner, respArchiveP->owner);
 551    strcpy(BSAobjDescP->objName.objectSpaceName, respArchiveP->objName.fs);
 552
 553    /*=== concatenate hl and ll for pathName ===*/
 554    strcpy(BSAobjDescP->objName.pathName, respArchiveP->objName.hl);
 555    strcat(BSAobjDescP->objName.pathName, respArchiveP->objName.ll);
 556
 557    BSAobjDescP->createTime.tm_year = respArchiveP->insDate.year-1900;
 558    BSAobjDescP->createTime.tm_mon  = respArchiveP->insDate.month-1;
 559    BSAobjDescP->createTime.tm_mday = respArchiveP->insDate.day  ;
 560    BSAobjDescP->createTime.tm_hour = respArchiveP->insDate.hour ;
 561    BSAobjDescP->createTime.tm_min  = respArchiveP->insDate.minute ;
 562    BSAobjDescP->createTime.tm_sec  = respArchiveP->insDate.second ;
 563
 564    BSAobjDescP->copyId.left  = respArchiveP->objId.hi;
 565    BSAobjDescP->copyId.right = respArchiveP->objId.lo;
 566
 567    BSAobjDescP->restoreOrder.left  = respArchiveP->restoreOrderExt.lo_hi;
 568    BSAobjDescP->restoreOrder.right = respArchiveP->restoreOrderExt.lo_lo;
 569
 570    strcpy(BSAobjDescP->lGName, respArchiveP->mcName) ;
 571
 572    xapiObjInfoP = (XAPIObjInfo *)&(respArchiveP->objInfo);
 573    BSAobjDescP->size.left = xapiObjInfoP->size.left;
 574    BSAobjDescP->size.right= xapiObjInfoP->size.right;
 575    strcpy(BSAobjDescP->resourceType, xapiObjInfoP->resourceType);
 576    strcpy(BSAobjDescP->desc, xapiObjInfoP->partDesc);
 577    strcpy(BSAobjDescP->objectInfo, xapiObjInfoP->partObjInfo);
 578
 579    if (respArchiveP->objName.objType == DSM_OBJ_DIRECTORY)
 580       BSAobjDescP->objectType = BSAObjectType_DIRECTORY;
 581    else
 582       BSAobjDescP->objectType = BSAObjectType_FILE;
 583       /*=== future - type DATABASE ?? ===*/
 584
 585       BSAobjDescP->status = BSAObjectStatus_ACTIVE;
 586       XOPENRETURN(BSAHandle, "fillArchiveResp",
 587                   BSA_RC_SUCCESS,__FILE__,__LINE__);
 588 }
 589
 590 BSA_Int16 fillBackupResp(
 591 long               BSAHandle,
 592 ObjectDescriptor  *BSAobjDescP,
 593 qryRespBackupData *respBackupP
 594 )
 595 {
 596    XAPIObjInfo   *xapiObjInfoP;
 597
 598    strcpy(BSAobjDescP->Owner.appObjectOwner, respBackupP->owner);
 599    strcpy(BSAobjDescP->objName.objectSpaceName, respBackupP->objName.fs);
 600
 601    /*=== concatenate hl and ll for pathName ===*/
 602    strcpy(BSAobjDescP->objName.pathName, respBackupP->objName.hl);
 603    strcat(BSAobjDescP->objName.pathName, respBackupP->objName.ll);
 604
 605    BSAobjDescP->createTime.tm_year = respBackupP->insDate.year-1900;
 606    BSAobjDescP->createTime.tm_mon  = respBackupP->insDate.month-1;
 607    BSAobjDescP->createTime.tm_mday = respBackupP->insDate.day  ;
 608    BSAobjDescP->createTime.tm_hour = respBackupP->insDate.hour ;
 609    BSAobjDescP->createTime.tm_min  = respBackupP->insDate.minute ;
 610    BSAobjDescP->createTime.tm_sec  = respBackupP->insDate.second ;
 611
 612    BSAobjDescP->copyId.left  = respBackupP->objId.hi;
 613    BSAobjDescP->copyId.right = respBackupP->objId.lo;
 614
 615    BSAobjDescP->restoreOrder.left  = respBackupP->restoreOrderExt.lo_hi;
 616    BSAobjDescP->restoreOrder.right = respBackupP->restoreOrderExt.lo_lo;
 617
 618    strcpy(BSAobjDescP->lGName, respBackupP->mcName) ;
 619
 620    xapiObjInfoP = (XAPIObjInfo *)&(respBackupP->objInfo);
 621    BSAobjDescP->size.left = xapiObjInfoP->size.left;
 622    BSAobjDescP->size.right= xapiObjInfoP->size.right;
 623    strcpy(BSAobjDescP->resourceType, xapiObjInfoP->resourceType);
 624    strcpy(BSAobjDescP->desc, xapiObjInfoP->partDesc);
 625    strcpy(BSAobjDescP->objectInfo, xapiObjInfoP->partObjInfo);
 626
 627    if (respBackupP->objName.objType == DSM_OBJ_DIRECTORY)
 628       BSAobjDescP->objectType = BSAObjectType_DIRECTORY;
 629    else
 630       BSAobjDescP->objectType = BSAObjectType_FILE;
 631       /*=== future - type DATABASE ?? ===*/
 632
 633    if (respBackupP->objState == DSM_ACTIVE)
 634       BSAobjDescP->status = BSAObjectStatus_ACTIVE;
 635    else
 636       BSAobjDescP->status = BSAObjectStatus_INACTIVE;
 637       /*=== ?? check for any other ===*/
 638
 639    XOPENRETURN(BSAHandle, "fillRBackupResp",
 640                BSA_RC_SUCCESS,__FILE__,__LINE__);
 641 }
 642
 643
 644 afs_int32 dsm_MountLibrary(void)
 645 {
 646 void * dynlib = NULL ;
 647
 648 #ifdef DEBUG_BUTC
 649     printf("dsm_MountLibrary : inside function.  \n");
 650 #endif
 651 #if defined(AFS_AIX_ENV)
 652         dynlib = dlopen("/usr/lib/libApiDS.a(dsmapish.o)", RTLD_NOW | RTLD_LOCAL | RTLD_MEMBER);
 653 #elif defined (AFS_AMD64_LINUX26_ENV)
 654         dynlib = dlopen("/usr/lib64/libApiTSM64.so", RTLD_NOW | RTLD_LOCAL);
 655 #elif defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV)
 656         dynlib = dlopen("/usr/lib/libApiDS.so", RTLD_NOW | RTLD_LOCAL);
 657 #else
 658         dynlib = NULL;
 659 #endif
 660
 661         if (dynlib == NULL) {
 662                 ELog(0,"dsm_MountLibrary: The dlopen call to load the libApiDS shared library failed\n");
 663                 return(BUTX_NOLIBRARY);
 664         }
 665
 666 #ifdef DEBUG_BUTC
 667         printf("dsm_MountLibrary : SUCCESS to Open the libApiDS shared library. \n");
 668 #endif
 669 #if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV)
 670         AFSdsmBeginQuery = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmQueryType queryType, dsmQueryBuff *queryBuffer)) dlsym((void *)dynlib, "dsmBeginQuery");
 671         AFSdsmGetNextQObj = (dsInt16_t (*)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmGetNextQObj") ;
 672         AFSdsmEndQuery = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndQuery");
 673         AFSdsmRCMsg = (dsInt16_t (*)( dsUint32_t dsmHandle, dsInt16_t dsmRC, char *msg))dlsym((void *)dynlib, "dsmRCMsg");
 674         AFSdsmLogEventEx = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmLogExIn_t *dsmLogExInP, dsmLogExOut_t *dsmLogExOutP))dlsym((void *)dynlib, "dsmLogEventEx");
 675         AFSdsmTrace = (dsInt16_t (*)( dsUint32_t dsmHandle, char * string ))dlsym((void *)dynlib, "dsmTrace");
 676         AFSdsmTerminate = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmTerminate");
 677         AFSdsmSendData = (dsInt16_t (*)( dsUint32_t dsmHandle, DataBlk *dataBlkPtri))dlsym((void *)dynlib, "dsmSendData");
 678         AFSdsmBeginTxn = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmBeginTxn");
 679         AFSdsmDeleteObj = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmDelType delType, dsmDelInfo delInfo))dlsym((void *)dynlib, "dsmDeleteObj");
 680         AFSdsmEndTxn = (dsInt16_t (*)( dsUint32_t dsmHandle, dsUint8_t vote, dsUint16_t *reason))dlsym((void *)dynlib, "dsmEndTxn");
 681         AFSdsmQueryApiVersion = (void (*)( dsmApiVersion *apiVersionP))dlsym((void *)dynlib, "dsmQueryApiVersion");
 682         AFSdsmInit = (dsInt16_t (*)( dsUint32_t *dsmHandle, dsmApiVersion *dsmApiVersionP, char *clientNodeNameP, char *clientOwnerNameP, char *clientPasswordP, char *applicationType, char *configfile, char *options))dlsym((void *)dynlib, "dsmInit");
 683         AFSdsmQuerySessInfo = (dsInt16_t (*)( dsUint32_t dsmHandle, ApiSessInfo *SessInfoP))dlsym((void *)dynlib, "dsmQuerySessInfo");
 684         AFSdsmBeginGetData = (dsInt16_t (*)(dsUint32_t dsmHandle, dsBool_t mountWait, dsmGetType getType, dsmGetList *dsmGetObjListP))dlsym((void *)dynlib, "dsmBeginGetData");
 685         AFSdsmGetObj = (dsInt16_t (*)( dsUint32_t dsmHandle, ObjID *objIdP, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmGetObj");
 686         AFSdsmEndGetObj = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndGetObj");
 687         AFSdsmEndGetData = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndGetData");
 688         AFSdsmGetData = (dsInt16_t (*)( dsUint32_t dsmHandle, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmGetData");
 689         AFSdsmEndSendObj = (dsInt16_t (*)( dsUint32_t dsmHandle))dlsym((void *)dynlib, "dsmEndSendObj");
 690         AFSdsmRegisterFS = (dsInt16_t (*)( dsUint32_t dsmHandle, regFSData *regFilespaceP))dlsym((void *)dynlib, "dsmRegisterFS");
 691         AFSdsmBindMC = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmObjName *objNameP, dsmSendType sendType, mcBindKey *mcBindKeyP))dlsym((void *)dynlib, "dsmBindMC");
 692         AFSdsmSendObj = (dsInt16_t (*)( dsUint32_t dsmHandle, dsmSendType sendType, void *sendBuff, dsmObjName *objNameP, ObjAttr *objAttrPtr, DataBlk *dataBlkPtr))dlsym((void *)dynlib, "dsmSendObj");
 693         AFSdsmChangePW = (dsInt16_t (*)( dsUint32_t dsmHandle, char *oldPW, char *newPW))dlsym((void *)dynlib, "dsmChangePW");
 694
 695
 696         if (    !AFSdsmBeginQuery || !AFSdsmGetNextQObj || !AFSdsmEndQuery ||
 697                 !AFSdsmRCMsg || !AFSdsmLogEventEx || !AFSdsmTrace ||
 698                 !AFSdsmTerminate || !AFSdsmEndGetObj || !AFSdsmSendData ||
 699                 !AFSdsmBeginTxn || !AFSdsmDeleteObj || !AFSdsmEndGetData ||
 700                 !AFSdsmEndTxn || !AFSdsmQueryApiVersion || !AFSdsmInit ||
 701                 !AFSdsmGetData || !AFSdsmQuerySessInfo || !AFSdsmBeginGetData ||
 702                 !AFSdsmGetObj || !AFSdsmEndSendObj || !AFSdsmRegisterFS ||
 703                 !AFSdsmBindMC || !AFSdsmSendObj || !AFSdsmChangePW )
 704         {
 705                 ELog(0,"dsm_MountLibrary: The dlopen call to load the TSM shared library failed\n");
 706                 return(BUTX_NOLIBRARY);
 707         }
 708 #ifdef DEBUG_BUTC
 709                 printf("dsm_MountLibrary : All TSM function pointers initialized. \n");
 710 #endif
 711
 712 #endif
 713         dsm_init = 1 ;
 714 #ifdef DEBUG_BUTC
 715     printf("dsm_MountLibrary : leaving function. \n");
 716 #endif
 717         return 0 ;
 718
 719 }
 720
 721 BSA_Int16 BSAInit( long     *BSAHandleP,
 722                    SecurityToken  *clientPasswordP,
 723                    ObjectOwner    *objectOwnerP,
 724                    char          **envP )
 725 {
 726    dsInt16_t        rc = 0;
 727    dsInt16_t        saverc = 0;
 728    BSA_Int16        bsaRC = 0;
 729    dsUint32_t       dsmHandle;   /* use diff field when talking to base
 730                                    code in case either format changes */
 731    dsmApiVersion    xapiHdrVer;  /* Xopen API build version           */
 732    dsmApiVersion    apiLibVer;  /* Xopen API Libary version          */
 733
 734    dsUint32_t       xapiVersion, apiVersion;
 735    envSetUp         dsmEnvSetUp;
 736
 737    /*==================================================================
 738      Today the BSA constants have the same values as the DSM constants.
 739      If this changes, use strncpy.
 740      =================================================================*/
 741
 742    char            rcmsg[DSM_MAX_RC_MSG_LENGTH + 1];
 743    char            dsmNode[DSM_MAX_NODE_LENGTH];
 744    char            dsmOwner[DSM_MAX_OWNER_LENGTH];
 745    char            dsmPswd[DSM_MAX_VERIFIER_LENGTH];
 746    char           *dsmNodeP;
 747    char           *dsmOwnerP;
 748    char           *dsmPswdP;
 749    char            options[DSM_MAX_RC_MSG_LENGTH];
 750    char           *optionP = NULL;
 751    char            TDPLibName[BSA_MAX_DESC];
 752    char            TDPILibName[BSA_MAX_DESC];
 753    int             i=0;
 754    char            errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
 755    char            ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
 756    char            rcMsg[DSM_MAX_RC_MSG_LENGTH + 1];
 757
 758    dsmHandle = 0;
 759   *BSAHandleP = 0;
 760
 761 #ifdef DEBUG_BUTC
 762    printf("BSAInit : inside function. \n");
 763 #endif
 764    memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
 765    memset(ourMessage,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
 766    memset(rcMsg,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
 767
 768    if(!dsm_init)
 769    {
 770 #ifdef DEBUG_BUTC
 771         printf("TSM library not mounted. \n");
 772 #endif
 773         if (dsm_MountLibrary())
 774         {
 775                 printf("TSM Library initialisation failed. \n");
 776                 return 1 ;
 777         }
 778 #ifdef DEBUG_BUTC
 779         printf("TSM Library initialisation SUCCESS. \n");
 780 #endif
 781    }
 782
 783    /*==================================================================
 784     Trace won't work before AFSdsmInit, moved to after call to AFSdsmInit
 785     The XOpen library is built by statically linking with the API and
 786     client common modules.  So, the version checking is unnecessary.
 787     We'll fill in the value anyway for consistency.
 788     ==================================================================*/
 789    memset(&xapiHdrVer,0x00,sizeof(dsmApiVersion));
 790    memset(&apiLibVer,0x00,sizeof(dsmApiVersion));
 791    memset(&dsmEnvSetUp,0x00,sizeof(envSetUp));
 792
 793    AFSdsmQueryApiVersion(&apiLibVer);
 794
 795    xapiHdrVer.version = DSM_API_VERSION;  /* Set the applications    */
 796    xapiHdrVer.release = DSM_API_RELEASE;  /* compile time version.   */
 797    xapiHdrVer.level   = DSM_API_LEVEL;    /* version                 */
 798
 799    xapiVersion = (1000 * DSM_API_VERSION) + (100 * DSM_API_RELEASE)
 800                   + DSM_API_LEVEL;
 801
 802    apiVersion  = (1000 * apiLibVer.version) + (100 * apiLibVer.release)
 803                   + apiLibVer.level;
 804
 805    /* check for compatibility problems */
 806    if (apiVersion < xapiVersion)
 807         return ADSM_RC_ERROR;
 808
 809    /*==== Init global area ===*/
 810
 811    memset(&xopenGbl,0x00, sizeof(xGlobal));  /* Zero out block.        */
 812
 813    memset(dsmNode,0x00,DSM_MAX_NODE_LENGTH);
 814    memset(dsmOwner,0x00,DSM_MAX_OWNER_LENGTH);
 815    memset(dsmPswd,0x00,DSM_MAX_VERIFIER_LENGTH);
 816    memset(options,0x00,DSM_MAX_RC_MSG_LENGTH);
 817    memset(TDPLibName,0x00,BSA_MAX_DESC);
 818    memset(TDPILibName,0x00,BSA_MAX_DESC);
 819
 820    memset(rcmsg,         '\0', DSM_MAX_RC_MSG_LENGTH + 1);
 821
 822
 823    /*=== Validate the inputs ===*/
 824
 825    if (objectOwnerP)
 826    {
 827       if (strlen(objectOwnerP->bsaObjectOwner) > BSA_MAX_BSAOBJECT_OWNER)
 828       {
 829          bsaRC = ADSM_RC_OWNER_TOO_LONG;
 830          return(bsaRC);
 831       }
 832
 833       if (strlen(objectOwnerP->appObjectOwner) > BSA_MAX_APPOBJECT_OWNER)
 834       {
 835          bsaRC = ADSM_RC_OWNER_TOO_LONG;
 836          return(bsaRC);
 837       }
 838
 839       if (objectOwnerP->bsaObjectOwner[0] == '\0') /* empty string */
 840          dsmNodeP = NULL;
 841       else
 842       {
 843          strcpy(dsmNode, objectOwnerP->bsaObjectOwner);
 844          dsmNodeP = dsmNode;
 845       }
 846
 847       if (objectOwnerP->appObjectOwner[0] == '\0') /* empty string  */
 848          dsmOwnerP = NULL;
 849       else
 850       {
 851          strcpy(dsmOwner, objectOwnerP->appObjectOwner);
 852          dsmOwnerP = dsmOwner;
 853       }
 854    }
 855    else
 856    {
 857       dsmNodeP = NULL;
 858       dsmOwnerP = NULL;
 859    }
 860
 861    if (clientPasswordP != NULL)
 862    {
 863       if (strlen((const char *)clientPasswordP) > BSA_MAX_TOKEN_SIZE)
 864       {
 865          bsaRC = ADSM_RC_PSWD_TOO_LONG;
 866          return(bsaRC);
 867       }
 868
 869       strcpy(dsmPswd, (const char *)clientPasswordP);
 870       dsmPswdP = dsmPswd;
 871    }
 872    else
 873       dsmPswdP = NULL;
 874       {
 875           while ((envP[i] != NULL) && (envP[i] != '\0'))
 876           {
 877              strcat(options, "-");
 878              strcat(options, envP[i]);
 879              if ((envP[i+1] != NULL) && (envP[i+1] != '\0'))
 880                 strcat(options, " ");
 881                 i++;
 882           }
 883
 884           if (options[0] == '\0')   /* empty string */
 885              optionP = NULL;
 886           else
 887              optionP = options;
 888
 889           rc = AFSdsmInit(&dsmHandle,   /* On return contains session handle.   */
 890                        &xapiHdrVer,   /* Version of the API we are using.     */
 891                        dsmNodeP,      /* node name                            */
 892                        dsmOwnerP,     /* owner name                           */
 893                        dsmPswdP,      /* password                             */
 894                        APPLTYPE,      /* Name of our node type.               */
 895                        NULL,          /* no API config file name              */
 896                        optionP);      /* option string                        */
 897      }
 898
 899      if (rc == DSM_RC_OK)
 900      {
 901         /*=== now that AFSdsmInit issued, we can trace ===*/
 902         sprintf(traceStr2,
 903                 "BSAInit: original bsaOwner=%s, appOwner=%s, token=%s, Appl Type=%s, options=%s.",
 904                  dsmNode, dsmOwner, dsmPswd, APPLTYPE, options);
 905         ourTrace(dsmHandle, TrFL, traceStr2);
 906         {
 907               strcpy(TDPLibName, TDP_LIBNAME);
 908               sprintf(traceStr2,
 909                      "BSAInit: Using TSM Native API library : %s", TDPLibName);
 910               ourTrace(dsmHandle, TrFL, traceStr2);
 911         }
 912      }
 913
 914
 915      /*=================================================================
 916      If the password expired, continue initialization so the session
 917      can continue.
 918
 919      Save the 'password expired' rc away, so we can return it to the
 920      caller.
 921
 922      The application will be responsible for issuing a BSAChangeToken()
 923      to update the password.
 924      =================================================================*/
 925      if (rc == DSM_RC_REJECT_VERIFIER_EXPIRED)
 926      {
 927         /*=== don't return yet - init global so session can continue ===*/
 928
 929          saverc = rc;
 930          rc = DSM_RC_OK;
 931      }
 932      else
 933         if ((rc == DSM_RC_NO_OWNER_REQD) ||
 934             (rc == DSM_RC_NO_NODE_REQD))       /* pswd=generate */
 935         {
 936             AFSdsmTerminate(dsmHandle);
 937             bsaRC = ADSM_RC_PSWD_GEN;
 938             return (bsaRC);
 939         }
 940
 941
 942    /*==================================================================
 943      If we ran into any problems so far, rc will be non-zero or 'true'.
 944
 945      This is not true for password expired, since we reset rc to zero
 946      in that case.  We'll have to check for that later so we return
 947      the 'password expired' indication to the caller.
 948      ==================================================================*/
 949
 950    if (rc)
 951    {
 952       AFSdsmRCMsg(dsmHandle, rc, rcmsg);
 953       sprintf(traceStr2, "BSAInit(AFSdsmInit): Messages - %s ", rcmsg);
 954       ourTrace(dsmHandle, TrFL, traceStr2);
 955       strcpy(ourMessage, ourRCMsg(rc, errPrefix));
 956       ourLogEvent_Ex(dsmHandle, logLocal, ourMessage, errPrefix, logSevError);
 957       xlateRC(*BSAHandleP, rc, &bsaRC); /* BSAHandle still 0, but not used */
 958       AFSdsmTerminate(dsmHandle);          /* clean up memory blocks          */
 959       return (bsaRC);
 960    }
 961
 962
 963    {
 964       char msg[256];                    /* format string and watch for NULLs */
 965
 966       strcpy(msg, "BSAInit for node=");
 967
 968       if (objectOwnerP)
 969       {
 970          if (dsmNodeP)
 971             strcat(msg, dsmNodeP);
 972          else
 973             strcat(msg, "<empty>");
 974       }
 975       else
 976          strcat(msg, "<NULL>");
 977
 978       strcat(msg, ", owner=");
 979
 980       if (objectOwnerP)
 981       {
 982          if (dsmOwnerP)
 983             strcat(msg, dsmOwnerP);
 984          else
 985             strcat(msg, "<empty>");
 986       }
 987       else
 988          strcat(msg, "<NULL>");
 989
 990       strcat(msg, ".\n");
 991
 992       strcpy(traceStr, msg);
 993    }
 994
 995    *BSAHandleP = (long)dsmHandle;
 996
 997
 998    /*=================================================================
 999     For password expired processing the application is responsible for
1000     issuing BSAChangeToken() to update the password, when they see the
1001     'expired password' return code.
1002
1003     The BSAChangeToken() command will issue the AFSdsmQuerySessInfo()
1004     call, so don't issue it here.
1005     =================================================================*/
1006
1007    if (!saverc)               /* don't call this if we got pswd expire */
1008    {
1009       /*=== now query session info to populate the global structure ===*/
1010
1011       xopenGbl.dsmSessInfo.stVersion = ApiSessInfoVersion;
1012       rc = AFSdsmQuerySessInfo(dsmHandle,                /* Session handle */
1013                             &xopenGbl.dsmSessInfo);   /* Output struct  */
1014
1015       if (rc)
1016       {
1017          sprintf(traceStr2, "BSAInit(AFSdsmQuerySessInfo): error rc = %d", rc);
1018          ourTrace(dsmHandle, TrFL, traceStr2);
1019          AFSdsmTerminate(dsmHandle);
1020          *BSAHandleP = 0;
1021       }
1022       else
1023       {
1024          sprintf(traceStr2, "BSAInit: Actual node=%s, actual DSM owner=%s, servername=%s.",
1025                  xopenGbl.dsmSessInfo.id, xopenGbl.dsmSessInfo.owner,
1026                  xopenGbl.dsmSessInfo.adsmServerName);
1027          ourTrace(dsmHandle, TrFL, traceStr2);
1028       }
1029    }
1030    else
1031    {
1032       /*============================================================
1033         Indicate in the session flags that we encountered a password
1034         expiration condition.  The application will know that this
1035         happened via the return code.
1036         ===========================================================*/
1037
1038       xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_PSWD_EXPIRE);
1039    }
1040
1041    /*=== Save bsaObjectOwner (node name) value passed on Init ===*/
1042
1043    if (dsmNodeP)
1044       strcpy(xopenGbl.bsaObjectOwner, dsmNodeP);
1045
1046      /*================================================================
1047       Check to see if we saved away the 'expired password' return code.
1048       if so, return it to the caller.
1049       ================================================================*/
1050
1051    if (saverc)
1052       rc = saverc;
1053
1054    xlateRC(*BSAHandleP, rc, &bsaRC);
1055 #ifdef DEBUG_BUTC
1056         printf("BSAInit : Leaving Function. \n");
1057 #endif
1058    return (bsaRC);
1059 }
1060
1061 BSA_Int16 BSATerminate(
1062     long              BSAHandle
1063 )
1064 {
1065    dsInt16_t      rc = 0;
1066    BSA_Int16      bsaRC = 0;
1067    dsUint32_t     dsmHandle;
1068
1069    if(!dsm_init)
1070    {
1071 #ifdef DEBUG_BUTC
1072         printf("TSM library not mounted. \n");
1073 #endif
1074         if (dsm_MountLibrary())
1075         {
1076                 printf("TSM Library initialisation failed. \n");
1077                 return 1 ;
1078         }
1079 #ifdef DEBUG_BUTC
1080         printf("TSM Library initialisation SUCCESS. \n");
1081 #endif
1082    }
1083
1084    dsmHandle = BSAHandle;
1085    sprintf(traceStr2, "BSATerminate ENTRY: BSAHandle is %ld.",
1086                       BSAHandle);
1087    ourTrace(dsmHandle, TrFL, traceStr2);
1088
1089    rc = AFSdsmTerminate(dsmHandle);
1090    dsmHandle = 0;
1091    xlateRC(dsmHandle, rc, &bsaRC);
1092
1093    return (bsaRC);
1094
1095 }
1096
1097 BSA_Int16 BSAChangeToken(
1098    long           BSAHandle,
1099    SecurityToken *oldTokenP,
1100    SecurityToken *newTokenP
1101 )
1102 {
1103    dsInt16_t      rc = 0;
1104    BSA_Int16      bsaRC = 0;
1105    dsUint32_t     dsmHandle;
1106
1107    if(!dsm_init)
1108    {
1109 #ifdef DEBUG_BUTC
1110         printf("TSM library not mounted. \n");
1111 #endif
1112         if (dsm_MountLibrary())
1113         {
1114                 printf("TSM Library initialisation failed. \n");
1115                 return 1 ;
1116         }
1117 #ifdef DEBUG_BUTC
1118         printf("TSM Library initialisation SUCCESS. \n");
1119 #endif
1120    }
1121
1122    dsmHandle = BSAHandle;
1123
1124    sprintf(traceStr2, "BSAChangeToken ENTRY: BSAHandle:%ld old:>%s< new:>%s<",
1125            BSAHandle,*oldTokenP,*newTokenP);
1126    ourTrace(dsmHandle, TrFL, traceStr2);
1127
1128    rc = AFSdsmChangePW(dsmHandle, (char *)oldTokenP, (char *)newTokenP);
1129
1130    if (rc)
1131    {
1132       xlateRC(BSAHandle, rc, &bsaRC);
1133       XOPENRETURN(BSAHandle,"BSAChangeToken(AFSdsmChangePW)",
1134                   bsaRC,__FILE__,__LINE__);
1135    }
1136
1137    xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_PSWD_EXPIRE); /* set off */
1138
1139     /*=== now query session info to populate the global structure ===*/
1140
1141    xopenGbl.dsmSessInfo.stVersion = ApiSessInfoVersion;
1142    rc = AFSdsmQuerySessInfo(dsmHandle,                /* Our session handle  */
1143                          &xopenGbl.dsmSessInfo);   /* Output structure.   */
1144    if (rc)
1145    {
1146       /*=== appl should call Terminate ===*/
1147       sprintf(traceStr2, "BSAChangeToken(AFSdsmQuerySessInfo): error rc = %d", rc);
1148       ourTrace(BSAHandle, TrFL, traceStr2);
1149    }
1150    xlateRC(BSAHandle, rc, &bsaRC);
1151    XOPENRETURN(BSAHandle,"BSAChangeToken",
1152                bsaRC,__FILE__,__LINE__);
1153 }
1154
1155 BSA_Int16 BSASetEnvironment(
1156     long     BSAHandle,
1157     char           **envP
1158 )
1159 {
1160    if(!dsm_init)
1161    {
1162 #ifdef DEBUG_BUTC
1163         printf("TSM library not mounted. \n");
1164 #endif
1165         if (dsm_MountLibrary())
1166         {
1167                 printf("TSM Library initialisation failed. \n");
1168                 return 1 ;
1169         }
1170 #ifdef DEBUG_BUTC
1171         printf("TSM Library initialisation SUCCESS. \n");
1172 #endif
1173    }
1174
1175    sprintf(traceStr2, "BSASetEnvironment ENTRY: BSAHandle:%ld envP:>%p< ",
1176            BSAHandle,envP);
1177    ourTrace(BSAHandle, TrFL, traceStr2);
1178    XOPENRETURN(BSAHandle,"BSASetEnvironment",
1179                BSA_RC_BAD_CALL_SEQUENCE,__FILE__,__LINE__);
1180 }
1181
1182 BSA_Int16 BSAGetEnvironment(
1183    long           BSAHandle,
1184    ObjectOwner   *objOwnerP,
1185    char         **envP
1186 )
1187 {
1188    dsInt16_t   rc = 0;
1189    BSA_Int16   bsaRC = 0;
1190    dsUint32_t  dsmHandle;
1191    char        envString[ADSM_ENV_STRS][BSA_MAX_DESC];
1192    char        maxObjStr[6];  /* conversion field. value range is 16-256 */
1193    dsUint32_t  maxObjNum;
1194    dsInt16_t   i;
1195
1196    if(!dsm_init)
1197    {
1198 #ifdef DEBUG_BUTC
1199         printf("TSM library not mounted. \n");
1200 #endif
1201         if (dsm_MountLibrary())
1202         {
1203                 printf("TSM Library initialisation failed. \n");
1204                 return 1 ;
1205         }
1206 #ifdef DEBUG_BUTC
1207         printf("TSM Library initialisation SUCCESS. \n");
1208 #endif
1209    }
1210
1211    for (i=0; i<ADSM_ENV_STRS; i++)
1212    {
1213       memset(envString[i], 0x00, BSA_MAX_DESC);
1214    }
1215    sprintf(traceStr2, "BSAGetEnvironment ENTRY: BSAHandle:%ld ObjOwner:'%s' appOwner:'%s' envP:>%p<.",
1216            BSAHandle,
1217            objOwnerP->bsaObjectOwner,
1218            objOwnerP->appObjectOwner,
1219            envP);
1220    ourTrace(BSAHandle, TrFL, traceStr2);
1221
1222    dsmHandle = BSAHandle;
1223
1224    /*===============================================================
1225     check if BSAInit has been done for now we have only one possible
1226     handle value - change in future
1227     ==============================================================*/
1228    if ((dsmHandle != FIRST_HANDLE) ||
1229       (xopenGbl.dsmSessInfo.stVersion != ApiSessInfoVersion))
1230        XOPENRETURN(BSAHandle,"BSAGetEnvironment",
1231                    BSA_RC_BAD_CALL_SEQUENCE, __FILE__,__LINE__);
1232
1233    if (objOwnerP)
1234    {
1235       strcpy(objOwnerP->bsaObjectOwner, xopenGbl.dsmSessInfo.id);
1236       strcpy(objOwnerP->appObjectOwner, xopenGbl.dsmSessInfo.owner);
1237    }
1238    else
1239       XOPENRETURN(BSAHandle,"BSAGetEnvironment",
1240                   BSA_RC_NULL_POINTER, __FILE__,__LINE__);
1241
1242    rc = AFSdsmQuerySessInfo(dsmHandle,                   /* Session Handle */
1243                          &xopenGbl.dsmSessInfo);       /* Output struct  */
1244
1245    if (rc)
1246       {
1247          sprintf(traceStr2, "BSAGetEnvironment(AFSdsmQuerySessInfo): error rc = %d", rc);
1248          ourTrace(dsmHandle, TrFL, traceStr2);
1249          AFSdsmTerminate(dsmHandle);
1250         /* *BSAHandleP = 0; */
1251       }
1252       else
1253       {
1254          sprintf(traceStr2, "BSAGetEnvironment: Actual node=%s, actual DSM owner=%s, ServerName=%s.",
1255                  xopenGbl.dsmSessInfo.id, xopenGbl.dsmSessInfo.owner, xopenGbl.dsmSessInfo.adsmServerName);
1256          ourTrace(dsmHandle, TrFL, traceStr2);
1257       }
1258
1259    strcpy(envString[0],"TSMSRVR=");
1260    strcat(envString[0],xopenGbl.dsmSessInfo.serverHost);
1261
1262    strcpy(envString[1],"TSMMAXOBJ=");
1263    maxObjNum = xopenGbl.dsmSessInfo.maxObjPerTxn;  /* convert to 32 bit */
1264    sprintf(maxObjStr,"%u", maxObjNum );
1265    strcat(envString[1], maxObjStr);
1266
1267    strcpy(envString[2], "TSMSRVRSTANZA=");
1268    strcat(envString[2], xopenGbl.dsmSessInfo.adsmServerName);
1269
1270    sprintf(traceStr2, "BSAGetEnvironment Value : TSM Server '%s', TSM Max Object '%s',TSM Server STANZA '%s'",
1271          envString[0], envString[1], envString[2]);
1272    ourTrace(BSAHandle, TrFL, traceStr2);
1273
1274    for (i=0; i< ADSM_ENV_STRS; i++) {
1275      if ( *envP == NULL ) {  /* watch for NULL pointers */
1276        /* Allocating memory for *envP.*/
1277        *envP = malloc(sizeof(char) * BSA_MAX_DESC +1);
1278
1279        /* copy the content of envString[i] to *envP. */
1280         strcpy(*envP,envString[i]);
1281         envP++;
1282      }
1283    }
1284
1285    xlateRC(BSAHandle, rc, &bsaRC);
1286    XOPENRETURN(BSAHandle,"BSAGetEnvironment",
1287                bsaRC,__FILE__,__LINE__)
1288 }
1289
1290 BSA_Int16 BSABeginTxn(
1291     long             BSAHandle
1292 )
1293 {
1294    if(!dsm_init)
1295    {
1296 #ifdef DEBUG_BUTC
1297         printf("TSM library not mounted. \n");
1298 #endif
1299         if (dsm_MountLibrary())
1300         {
1301                 printf("TSM Library initialisation failed. \n");
1302                 return 1 ;
1303         }
1304 #ifdef DEBUG_BUTC
1305         printf("TSM Library initialisation SUCCESS. \n");
1306 #endif
1307    }
1308
1309    sprintf(traceStr2, "BSABeginTxn ENTRY: BSAHandle:%ld", BSAHandle);
1310    ourTrace(BSAHandle, TrFL, traceStr2);
1311   /*========================================================
1312    don't actually issue BeginTxn yet, because we will do our
1313    own for Get and Query
1314    ========================================================*/
1315
1316    xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_BSA_TXN); /* set on */
1317    XOPENRETURN(BSAHandle, "BSABeginTxn",
1318                BSA_RC_SUCCESS,__FILE__,__LINE__);
1319 }
1320
1321 BSA_Int16 BSAEndTxn(
1322     long           BSAHandle,
1323     Vote           vote
1324 )
1325 {
1326    dsInt16_t      rc = 0;
1327    BSA_Int16      bsaRC = 0;
1328    dsUint32_t     dsmHandle;
1329    dsUint8_t      dsmVote;
1330    dsUint16_t     reason ;
1331    char           rsMsg[DSM_MAX_RC_MSG_LENGTH + 1];
1332    char           errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
1333    char           ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
1334
1335    if(!dsm_init)
1336    {
1337 #ifdef DEBUG_BUTC
1338         printf("TSM library not mounted. \n");
1339 #endif
1340         if (dsm_MountLibrary())
1341         {
1342                 printf("TSM Library initialisation failed. \n");
1343                 return 1 ;
1344         }
1345 #ifdef DEBUG_BUTC
1346         printf("TSM Library initialisation SUCCESS. \n");
1347 #endif
1348    }
1349
1350    memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1351    memset(rsMsg,        '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1352    memset(ourMessage,    '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1353
1354    sprintf(traceStr2, "BSAEndTxn ENTRY: BSAHandle:%ld Vote:>%d<", BSAHandle, vote);
1355    ourTrace(BSAHandle, TrFL, traceStr2);
1356
1357    dsmHandle = BSAHandle;
1358
1359    if (xopenGbl.sessFlags & FL_IN_DSM_TXN)
1360    {
1361       if (vote == BSAVote_COMMIT)
1362          dsmVote = DSM_VOTE_COMMIT;
1363       else
1364          if (vote == BSAVote_ABORT)
1365             dsmVote = DSM_VOTE_ABORT;
1366          else
1367          {
1368             sprintf(traceStr2, "BSAEndTxn: invalid vote (%d)", vote);
1369             ourTrace(BSAHandle,TrFL, traceStr2);
1370             bsaRC = BSA_RC_INVALID_VOTE;
1371             XOPENRETURN(BSAHandle, "BSAEndTxn",bsaRC,__FILE__,__LINE__);
1372          }
1373
1374
1375       sprintf(traceStr2, "BSAEndTxn: issue AFSdsmEndTxn, vote=%s",
1376                   dsmVote == DSM_VOTE_COMMIT ? "COMMIT" : "ABORT");
1377       ourTrace(BSAHandle,TrFL, traceStr2);
1378       /*===========================================================
1379         check if this EndTxn call was proceeded by a Send call which
1380         returned WILL_ABORT. If so, make sure the vote is COMMIT
1381         so we will get the server's reason code.
1382         ===========================================================*/
1383       if (xopenGbl.sessFlags & FL_RC_WILL_ABORT)
1384       {
1385          dsmVote = DSM_VOTE_COMMIT;
1386
1387          sprintf(traceStr2, "BSAEndTxn: sproceeded by RC_WILL_ABORT, so use vote=COMMIT");
1388          ourTrace(BSAHandle,TrFL, traceStr2);
1389          xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_RC_WILL_ABORT); /* set off*/
1390       }
1391
1392       rc = AFSdsmEndTxn(dsmHandle, dsmVote, &reason);
1393       xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_DSM_TXN); /* set off */
1394
1395       /*====================================================
1396        if the caller wanted to Abort, then return rc=OK, not
1397        our usual 2302 and reason 3
1398        =====================================================*/
1399       if ((dsmVote ==  DSM_VOTE_ABORT)     &&
1400           (rc == DSM_RC_CHECK_REASON_CODE) &&
1401           (reason == DSM_RC_ABORT_BY_CLIENT))
1402
1403          rc = DSM_RC_OK;
1404
1405       if (rc)
1406       {
1407          sprintf(traceStr2, "BSAEndTxn(AFSdsmEndTxn) error rc = %d", rc);
1408          ourTrace(BSAHandle,TrFL, traceStr2);
1409
1410          AFSdsmRCMsg(BSAHandle, reason, rsMsg);
1411          sprintf(traceStr2, "BSAEndTxn: reason code = %d, Message='%s'", reason, rsMsg);
1412          ourTrace(BSAHandle,TrFL, traceStr2);
1413
1414          strcpy(ourMessage, ourRCMsg(reason, errPrefix));
1415          ourLogEvent_Ex(BSAHandle,logBoth, ourMessage, errPrefix, logSevError);
1416       }
1417       xlateRC(BSAHandle, rc, &bsaRC);
1418
1419       if (rc == DSM_RC_CHECK_REASON_CODE) /* return reason code instead */
1420       {
1421          xlateRC(BSAHandle, reason, &bsaRC);
1422       }
1423    }
1424
1425    /*=== check if Query was terminated ===*/
1426    if (xopenGbl.sessFlags & FL_IN_BSA_QRY)
1427    {
1428       AFSdsmEndQuery(dsmHandle);
1429       xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
1430    }
1431
1432    xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_TXN); /* set off */
1433    XOPENRETURN(BSAHandle, "BSAEndTxn",
1434                bsaRC,__FILE__,__LINE__);
1435 }
1436
1437 void  BSAQueryApiVersion(
1438 ApiVersion       *BSAapiVerP
1439 )
1440
1441 {
1442    /*===============================================================
1443     Don't actually call the base QueryApiVersion call.
1444     Use the defines from custom.h since this is what the application
1445     sees in the header file. The constants should be the same,
1446     but may get out of sync occasionally.
1447     ===============================================================*/
1448    BSAapiVerP->version = BSA_API_VERSION;
1449    BSAapiVerP->release = BSA_API_RELEASE;
1450    BSAapiVerP->level   = BSA_API_LEVEL;
1451    return;
1452 }
1453
1454 BSA_Int16 BSAQueryObject(
1455 long              BSAHandle,
1456 QueryDescriptor  *BSAqryDescP,
1457 ObjectDescriptor *BSAobjDescP
1458 )
1459 {
1460    dsInt16_t      rc = 0;
1461    BSA_Int16      bsaRC = 0;
1462    dsUint32_t     dsmHandle;
1463    dsmObjName     objName;
1464    dsUint8_t      dsmObjType;
1465    dsmQueryType   query_type;
1466    dsmQueryBuff   *query_buff;
1467    DataBlk        qData;
1468    qryArchiveData archiveData;
1469    qryRespArchiveData respArchive;
1470    qryBackupData  backupData;
1471    qryRespBackupData  respBackup;
1472    BSAObjectOwner upperNode;  /* upper cased node name */
1473
1474    char           errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
1475    char           ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
1476
1477    if(!dsm_init)
1478    {
1479 #ifdef DEBUG_BUTC
1480         printf("TSM library not mounted. \n");
1481 #endif
1482         if (dsm_MountLibrary())
1483         {
1484                 printf("TSM Library initialisation failed. \n");
1485                 return 1 ;
1486         }
1487 #ifdef DEBUG_BUTC
1488         printf("TSM Library initialisation SUCCESS. \n");
1489 #endif
1490    }
1491
1492    memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1493    memset(ourMessage,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1494
1495    dsmHandle = BSAHandle;
1496
1497    memset(&backupData, 0x00, sizeof(qryBackupData));
1498
1499    sprintf(traceStr2, "BSAQueryObject ENTRY: BSAHandle:%ld ObjOwner(qryDesc):'%s' appOwner(qryDesc):'%s' \n ObjName(qryDesc):'%.*s%.*s' \n copyType:%d ObjectType:%d status:%d ",
1500           BSAHandle,
1501           BSAqryDescP->owner.bsaObjectOwner,
1502           BSAqryDescP->owner.appObjectOwner,
1503           100,BSAqryDescP->objName.objectSpaceName,
1504           100,BSAqryDescP->objName.pathName,
1505           BSAqryDescP->copyType,
1506           BSAqryDescP->objectType,
1507           BSAqryDescP->status);
1508    ourTrace(BSAHandle, TrFL, traceStr2);
1509
1510    /*=====================================================
1511     init objDesc area to 0's before we start to erase any
1512     garbage that might be there.
1513     =====================================================*/
1514    memset(BSAobjDescP, 0x00, sizeof(ObjectDescriptor));
1515
1516    /*=== init global look ahead pointer to NULL ===*/
1517    if (xopenGbl.nextQryP != NULL)
1518    {
1519       dsFree(xopenGbl.nextQryP);
1520       xopenGbl.nextQryP = NULL;
1521    }
1522
1523    /*=========================================================
1524     if the node name is different - we won't query it compare
1525     both the value passed on the BSAInit and the final value
1526     used for the session (which may be different for Generate).
1527     =========================================================*/
1528    strcpy(upperNode, BSAqryDescP->owner.bsaObjectOwner);
1529    StrUpper(upperNode);
1530    if ((strcmp(upperNode, xopenGbl.dsmSessInfo.id)) &&
1531       (strcmp(BSAqryDescP->owner.bsaObjectOwner, xopenGbl.bsaObjectOwner)))
1532    {
1533       sprintf(traceStr2,
1534       "BSAQueryObject: BSAObjectOwner(%s) doesn't match value for session(%s).", upperNode, xopenGbl.dsmSessInfo.id);
1535       ourTrace(BSAHandle,TrFL, traceStr2);
1536       bsaRC = ADSM_RC_INVALID_NODE;
1537       strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
1538       ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
1539       XOPENRETURN(BSAHandle, "BSAQueryObject",
1540                   bsaRC,__FILE__,__LINE__);
1541    }
1542
1543    /*=====================================================
1544      currently BSA_MAX_OSNAME = DSM_MAX_FSNAME_LENGTH
1545      if this changes, use strncpy
1546      ====================================================*/
1547    if (strlen(BSAqryDescP->objName.objectSpaceName) > BSA_MAX_OSNAME)
1548    {
1549       sprintf(traceStr2, "BSAQueryObject: objectSpaceName too long (%" AFS_SIZET_FMT ").",
1550               strlen(BSAqryDescP->objName.objectSpaceName));
1551       ourTrace(BSAHandle,TrFL, traceStr2);
1552       bsaRC = BSA_RC_OBJNAME_TOO_LONG;
1553       XOPENRETURN(BSAHandle, "BSAQueryObject",
1554                   bsaRC,__FILE__,__LINE__);
1555    }
1556    /*=================================================================
1557      the entire pathname gets copied into hl during parsing, so check
1558      for that max len as well. For now these are the same value.
1559      ================================================================*/
1560    if (strlen(BSAqryDescP->objName.pathName) >
1561        min(DSM_MAX_HL_LENGTH, BSA_MAX_PATHNAME))
1562    {
1563       sprintf(traceStr2, "BSAQueryObject: pathName too long (%" AFS_SIZET_FMT ")",
1564               strlen(BSAqryDescP->objName.pathName));
1565       ourTrace(BSAHandle, TrFL, traceStr2);
1566       bsaRC = BSA_RC_OBJNAME_TOO_LONG;
1567       XOPENRETURN(BSAHandle, "BSAQueryObject",
1568                   bsaRC,__FILE__,__LINE__);
1569    }
1570    if ((BSAqryDescP->objectType == BSAObjectType_FILE) ||
1571        (BSAqryDescP->objectType == BSAObjectType_DATABASE))
1572       dsmObjType = DSM_OBJ_FILE;
1573    else
1574       if (BSAqryDescP->objectType == BSAObjectType_DIRECTORY)
1575          dsmObjType = DSM_OBJ_DIRECTORY;
1576       else
1577          if (BSAqryDescP->objectType == BSAObjectType_ANY)
1578             dsmObjType = DSM_OBJ_ANY_TYPE;
1579          else
1580          {
1581              sprintf(traceStr2,
1582                      "BSAQueryObject: invalid objectType (%d)", BSAqryDescP->objectType);
1583              ourTrace(BSAHandle,TrFL, traceStr2);
1584              bsaRC = ADSM_RC_INVALID_OBJTYPE;
1585              strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
1586              ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
1587              XOPENRETURN(BSAHandle, "BSAQueryObject",
1588                          bsaRC,__FILE__,__LINE__);
1589          }
1590
1591    if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
1592    {
1593       sprintf(traceStr2, "BSAQueryObject: issued without BSABeginTxn");
1594       ourTrace(BSAHandle,TrFL, traceStr2);
1595       bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
1596       XOPENRETURN(BSAHandle, "BSAQueryObject",
1597                   bsaRC,__FILE__,__LINE__);
1598    }
1599
1600    /* store object name in ADSM structure */
1601    strcpy(objName.fs,BSAqryDescP->objName.objectSpaceName) ;
1602
1603    if (!strcmp(BSAqryDescP->objName.pathName, "/*")) /* if they use a wildcard */
1604    {  /* we need to use a wild card on both hl and ll since the path gets split */
1605       strcpy(objName.hl, "*");  /* don't include delimiter in case there is
1606                              no hl */
1607       strcpy(objName.ll, "/*");
1608    }
1609    else
1610       xparsePath(BSAHandle, BSAqryDescP->objName.pathName, objName.hl, objName.ll);
1611
1612       objName.objType = dsmObjType ;
1613
1614       /*=== save copy type for GetNextQuery call later ===*/
1615       xopenGbl.copyType = BSAqryDescP->copyType;
1616
1617       if (BSAqryDescP->copyType == BSACopyType_ARCHIVE)
1618       {
1619          if (strlen(BSAqryDescP->desc) > ADSM_MAX_DESC)
1620          {
1621
1622             sprintf(traceStr2, "BSAQueryObject: description longer than ADSM max (%" AFS_SIZET_FMT "). ", strlen(BSAqryDescP->desc));
1623             ourTrace(BSAHandle,TrFL, traceStr2);
1624             bsaRC = BSA_RC_DESC_TOO_LONG;
1625             XOPENRETURN(BSAHandle, "BSAQueryObject",
1626                         bsaRC,__FILE__,__LINE__);
1627          }
1628
1629          archiveData.stVersion = qryArchiveDataVersion;
1630          archiveData.objName   = &objName;
1631          archiveData.owner     = (char *)&BSAqryDescP->owner.appObjectOwner;
1632
1633          /*=================================================================
1634            in the tm structure the month count starts with 0 and year is
1635            the value since 1900.
1636            Adjust the year value only if it isn't one of the boundary values
1637            =================================================================*/
1638
1639          archiveData.insDateLowerBound.year   = BSAqryDescP->createTimeLB.tm_year;
1640          if (archiveData.insDateLowerBound.year != ADSM_LOWEST_BOUND)
1641             archiveData.insDateLowerBound.year  += 1900;
1642          archiveData.insDateLowerBound.month  = BSAqryDescP->createTimeLB.tm_mon+1;
1643          archiveData.insDateLowerBound.day    = BSAqryDescP->createTimeLB.tm_mday;
1644          archiveData.insDateLowerBound.hour   = BSAqryDescP->createTimeLB.tm_hour;
1645          archiveData.insDateLowerBound.minute = BSAqryDescP->createTimeLB.tm_min;
1646          archiveData.insDateLowerBound.second = BSAqryDescP->createTimeLB.tm_sec;
1647
1648          archiveData.insDateUpperBound.year   = BSAqryDescP->createTimeUB.tm_year;
1649          if (archiveData.insDateUpperBound.year != ADSM_HIGHEST_BOUND)
1650              archiveData.insDateUpperBound.year  += 1900;
1651          archiveData.insDateUpperBound.month  = BSAqryDescP->createTimeUB.tm_mon+1;
1652          archiveData.insDateUpperBound.day    = BSAqryDescP->createTimeUB.tm_mday;
1653          archiveData.insDateUpperBound.hour   = BSAqryDescP->createTimeUB.tm_hour;
1654          archiveData.insDateUpperBound.minute = BSAqryDescP->createTimeUB.tm_min;
1655          archiveData.insDateUpperBound.second = BSAqryDescP->createTimeUB.tm_sec;
1656
1657          archiveData.expDateLowerBound.year   = BSAqryDescP->expireTimeLB.tm_year;
1658          if (archiveData.expDateLowerBound.year != ADSM_LOWEST_BOUND)
1659              archiveData.expDateLowerBound.year  += 1900;
1660          archiveData.expDateLowerBound.month  = BSAqryDescP->expireTimeLB.tm_mon+1;
1661          archiveData.expDateLowerBound.day    = BSAqryDescP->expireTimeLB.tm_mday;
1662          archiveData.expDateLowerBound.hour   = BSAqryDescP->expireTimeLB.tm_hour;
1663          archiveData.expDateLowerBound.minute = BSAqryDescP->expireTimeLB.tm_min;
1664          archiveData.expDateLowerBound.second = BSAqryDescP->expireTimeLB.tm_sec;
1665
1666          archiveData.expDateUpperBound.year   = BSAqryDescP->expireTimeUB.tm_year;
1667          if (archiveData.expDateUpperBound.year != ADSM_HIGHEST_BOUND)
1668             archiveData.expDateUpperBound.year  += 1900;
1669          archiveData.expDateUpperBound.month  = BSAqryDescP->expireTimeUB.tm_mon+1;
1670          archiveData.expDateUpperBound.day    = BSAqryDescP->expireTimeUB.tm_mday;
1671          archiveData.expDateUpperBound.hour   = BSAqryDescP->expireTimeUB.tm_hour;
1672          archiveData.expDateUpperBound.minute = BSAqryDescP->expireTimeUB.tm_min;
1673          archiveData.expDateUpperBound.second = BSAqryDescP->expireTimeUB.tm_sec;
1674
1675          archiveData.descr = (char *)&BSAqryDescP->desc;
1676          query_type = qtArchive;
1677          query_buff = (dsmQueryBuff *)&archiveData;
1678
1679          qData.stVersion = DataBlkVersion;
1680          qData.bufferLen = sizeof(qryRespArchiveData);
1681          qData.bufferPtr = (char *)&respArchive;
1682          respArchive.stVersion = qryRespArchiveDataVersion;
1683    }
1684    else
1685       if (BSAqryDescP->copyType == BSACopyType_BACKUP)
1686       {
1687          if (BSAqryDescP->status == BSAObjectStatus_ACTIVE)
1688             backupData.objState  = DSM_ACTIVE;
1689          else
1690             if (BSAqryDescP->status == BSAObjectStatus_INACTIVE)
1691                backupData.objState  = DSM_INACTIVE;
1692             else
1693                if (BSAqryDescP->status == BSAObjectStatus_ANY)
1694                   backupData.objState  = DSM_ANY_MATCH;
1695                else
1696                {
1697                    sprintf(traceStr2,
1698                            "BSAQueryObject: invalid status (%d)",
1699                             BSAqryDescP->status);
1700                    ourTrace(BSAHandle,TrFL, traceStr2);
1701                    bsaRC = ADSM_RC_INVALID_STATUS;
1702                    strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
1703                    ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
1704                    XOPENRETURN(BSAHandle, "BSAQueryObject",
1705                                bsaRC,__FILE__,__LINE__);
1706                }
1707
1708             backupData.stVersion = qryBackupDataVersion;
1709             backupData.objName   = &objName;
1710             backupData.owner     = (char *)&BSAqryDescP->owner.appObjectOwner;
1711
1712             query_type = qtBackup;
1713             query_buff = (dsmQueryBuff *)&backupData;
1714
1715             qData.stVersion = DataBlkVersion;
1716             qData.bufferLen = sizeof(qryRespBackupData);
1717             qData.bufferPtr = (char *)&respBackup;
1718             respBackup.stVersion = qryRespBackupDataVersion;;
1719       }
1720       else
1721       {
1722          sprintf(traceStr2,
1723                            "BSAQueryObject: invalid copyType (%d)",
1724                             BSAqryDescP->copyType);
1725          ourTrace(BSAHandle,TrFL, traceStr2);
1726          bsaRC = ADSM_RC_INVALID_COPYTYPE;
1727          strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
1728          ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
1729          XOPENRETURN(BSAHandle, "BSAQueryObject",
1730                      bsaRC,__FILE__,__LINE__);
1731       }
1732
1733       /*=== now set flag for query ===*/
1734       xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_BSA_QRY); /* set on */
1735
1736       if ((rc = AFSdsmBeginQuery(dsmHandle,query_type,query_buff)))
1737       {
1738
1739          sprintf(traceStr2, "BSAQueryObject(AFSdsmBeginQuery) error rc = %d", rc);
1740          ourTrace(BSAHandle,TrFL, traceStr2);
1741          xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
1742          xlateRC(BSAHandle, rc, &bsaRC);
1743          XOPENRETURN(BSAHandle, "BSAQueryObject(AFSdsmBeginQuery)",
1744                                  bsaRC,__FILE__,__LINE__);
1745       }
1746
1747       rc = AFSdsmGetNextQObj(dsmHandle,&qData);
1748       if (((rc == DSM_RC_OK) || (rc == DSM_RC_MORE_DATA)) && qData.numBytes)
1749       {
1750          BSAobjDescP->version = ObjectDescriptorVersion;
1751          strcpy(BSAobjDescP->Owner.bsaObjectOwner, xopenGbl.dsmSessInfo.id);
1752          BSAobjDescP->copyType = BSAqryDescP->copyType;
1753          strcpy(BSAobjDescP->cGName, "\0");   /* no copy group name returned */
1754
1755          if (BSAqryDescP->copyType == BSACopyType_ARCHIVE)
1756          {
1757             fillArchiveResp(dsmHandle, BSAobjDescP, &respArchive);
1758          }
1759          else /* backup */
1760          {
1761             fillBackupResp(dsmHandle, BSAobjDescP, &respBackup);
1762          }
1763          /*=== look ahead and see if there is more or if this is really done ===*/
1764          rc = AFSdsmGetNextQObj(dsmHandle,&qData);
1765          if (( (rc == DSM_RC_OK) || (rc == DSM_RC_MORE_DATA)) && qData.numBytes)
1766          { /*=== save the response we just got for later call ===*/
1767             if (BSAqryDescP->copyType == BSACopyType_ARCHIVE)
1768             {
1769                if (!(xopenGbl.nextQryP = (char *)dsMalloc(sizeof(qryRespArchiveData))))
1770                {
1771
1772                   sprintf(traceStr2, "BSAQueryObject: no memory for look ahead buffer");
1773                   ourTrace(BSAHandle,TrFL, traceStr2);
1774                   xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
1775                   bsaRC = BSA_RC_NO_RESOURCES;
1776                   XOPENRETURN(BSAHandle, "BSAQueryObject(AFSdsmGetNextQObj)",
1777                               bsaRC,__FILE__,__LINE__);
1778                }
1779                memcpy(xopenGbl.nextQryP, &respArchive, sizeof(qryRespArchiveData));
1780             }
1781             else
1782             {
1783                if (!(xopenGbl.nextQryP = (char *)dsMalloc(sizeof(qryRespBackupData))))
1784                {
1785
1786                   sprintf(traceStr2, "BSAQueryObject: no memory for look ahead buffer");
1787                   ourTrace(BSAHandle,TrFL, traceStr2);
1788                   xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
1789                   bsaRC = BSA_RC_NO_RESOURCES;
1790                   XOPENRETURN(BSAHandle, "BSAQueryObject(AFSdsmGetNextQObj)",
1791                               bsaRC,__FILE__,__LINE__);
1792
1793                }
1794                memcpy(xopenGbl.nextQryP, &respBackup, sizeof(qryRespBackupData));
1795             }
1796          }
1797       else
1798       {
1799
1800          sprintf(traceStr2, "BSAQueryObject(AFSdsmGetNextQObj) rc = %d", rc);
1801          ourTrace(BSAHandle,TrFL, traceStr2);
1802          AFSdsmEndQuery(dsmHandle);
1803          xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
1804       }
1805
1806    }
1807    else /* could be FINISHED or an error */
1808    {
1809
1810       sprintf(traceStr2, "BSAQueryObject(AFSdsmGetNextQObj) rc = %d", rc);
1811       ourTrace(BSAHandle,TrFL, traceStr2);
1812       AFSdsmEndQuery(dsmHandle);
1813       xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_BSA_QRY); /* set off */
1814    }
1815
1816    if (rc == DSM_RC_OK)
1817    {
1818       sprintf(traceStr2, "BSAQueryObject(AFSdsmGetNextQObj) rc = %d, ObjOwner(objDesc):'%s' appOwner(objDesc):'%s' \n ObjName(objDesc):'%.*s%.*s' \n copyType:%d copyId:'%lu %lu' cGName:'%s'",
1819        rc,
1820        BSAobjDescP->Owner.bsaObjectOwner,
1821        BSAobjDescP->Owner.appObjectOwner,
1822        100,BSAobjDescP->objName.objectSpaceName,
1823        100,BSAobjDescP->objName.pathName,
1824        BSAobjDescP->copyType,
1825        BSAobjDescP->copyId.left,
1826        BSAobjDescP->copyId.right,
1827        BSAobjDescP->cGName);
1828        ourTrace(BSAHandle,TrFL, traceStr2);
1829    }
1830
1831    xlateRC(BSAHandle, rc, &bsaRC);
1832    XOPENRETURN(BSAHandle, "BSAQueryObject",
1833                bsaRC, __FILE__,__LINE__);
1834 }
1835
1836 BSA_Int16 BSAGetObject(
1837     long              BSAHandle,
1838     ObjectDescriptor *BSAobjDescP,
1839     DataBlock        *BSAdataBlockP
1840 )
1841 {
1842    dsInt16_t      rc = 0;
1843    BSA_Int16      bsaRC = 0;
1844    dsUint32_t     dsmHandle;
1845    DataBlk        getBlk;
1846    dsmGetType     getType;
1847    dsmGetList     dsmObjList ;
1848    char           rcMsg[DSM_MAX_RC_MSG_LENGTH + 1];
1849    char           errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
1850    char           ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
1851
1852    if(!dsm_init)
1853    {
1854 #ifdef DEBUG_BUTC
1855         printf("TSM library not mounted. \n");
1856 #endif
1857         if (dsm_MountLibrary())
1858         {
1859                 printf("TSM Library initialisation failed. \n");
1860                 return 1 ;
1861         }
1862 #ifdef DEBUG_BUTC
1863         printf("TSM Library initialisation SUCCESS. \n");
1864 #endif
1865    }
1866
1867    dsmHandle = BSAHandle;
1868
1869    memset(rcMsg,         '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1870    memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1871    memset(ourMessage,    '\0', DSM_MAX_RC_MSG_LENGTH + 1);
1872
1873    sprintf(traceStr2, "BSAGetObject ENTRY: BSAHandle:%ld version:%lu copyType:%d copyId:'%lu %lu' \n bufferLen:%d numBytes:%d ",
1874            BSAHandle,
1875            BSAobjDescP->version,
1876            BSAobjDescP->copyType,
1877            BSAobjDescP->copyId.left,
1878            BSAobjDescP->copyId.right,
1879            BSAdataBlockP->bufferLen,
1880            BSAdataBlockP->numBytes);
1881    ourTrace(BSAHandle, TrFL, traceStr2);
1882
1883    xopenGbl.oper = OPER_RECV_START;    /* save state for EndData later */
1884
1885    if (BSAobjDescP->version != ObjectDescriptorVersion)
1886    {
1887       sprintf(traceStr2,"Warning: BSAGetObject: objectDesc.version unexpected %lu.", BSAobjDescP->version);
1888       ourTrace(BSAHandle,TrFL, traceStr2);
1889       /*==================================================================
1890        don't treat this as an error now since it isn't defined in the spec
1891        bsaRC = ADSM_RC_INVALID_ST_VER;
1892        return(bsaRC);
1893        =================================================================*/
1894    }
1895
1896    if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
1897    {
1898       sprintf(traceStr2, "BSAGetObject: issued without BSABeginTxn");
1899       ourTrace(BSAHandle,TrFL, traceStr2);
1900       bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
1901       XOPENRETURN(BSAHandle, "BSAGetObject",
1902                   bsaRC,__FILE__,__LINE__);
1903    }
1904
1905    /*=== Get the data ===*/
1906    if (BSAobjDescP->copyType == BSACopyType_ARCHIVE)
1907       getType = gtArchive;
1908    else
1909       if (BSAobjDescP->copyType == BSACopyType_BACKUP)
1910          getType = gtBackup;
1911       else
1912       {
1913          sprintf(traceStr2,
1914                            "BSAGetObject: invalid copyType (%d)",
1915                             BSAobjDescP->copyType);
1916          ourTrace(BSAHandle,TrFL, traceStr2);
1917          bsaRC = ADSM_RC_INVALID_COPYTYPE;
1918          strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
1919          ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
1920          XOPENRETURN(BSAHandle, "BSAGetObject",
1921                      bsaRC,__FILE__,__LINE__);
1922       }
1923
1924    /*=== now update state since we'll issue a base API call ===*/
1925    xopenGbl.oper = OPER_RECV_ISSUED;    /* save state for EndData later */
1926    /*=== setup for a single object get ===*/
1927
1928    dsmObjList.stVersion = dsmGetListVersion ;
1929    dsmObjList.numObjId = 1 ;
1930    dsmObjList.objId = (ObjID *)dsMalloc(sizeof(ObjID) * dsmObjList.numObjId) ;
1931
1932    dsmObjList.objId[0].hi = BSAobjDescP->copyId.left ;
1933    dsmObjList.objId[0].lo = BSAobjDescP->copyId.right ;
1934
1935    if ((rc = AFSdsmBeginGetData(dsmHandle,bTrue,   /* always say MountWait */
1936                              getType,
1937                              &dsmObjList)) != DSM_RC_OK)
1938    {
1939       sprintf(traceStr2, "BSAGetObject: Call to AFSdsmBeginGetData error rc = %d", rc);
1940       ourTrace(BSAHandle,TrFL, traceStr2);
1941       xlateRC(BSAHandle, rc, &bsaRC);
1942       XOPENRETURN(BSAHandle, "BSAGetObject(AFSdsmBeginGetData)",
1943                   bsaRC,__FILE__,__LINE__);
1944    }
1945
1946    /*********************************************************************/
1947    getBlk.stVersion = DataBlkVersion ;
1948    getBlk.bufferPtr = BSAdataBlockP->bufferPtr ;
1949    getBlk.bufferLen = BSAdataBlockP->bufferLen;
1950    getBlk.numBytes  = 0;
1951
1952    rc = AFSdsmGetObj(dsmHandle, &(dsmObjList.objId[0]), &getBlk) ;
1953
1954    if ((rc == DSM_RC_FINISHED) &&
1955        (getBlk.numBytes != 0))    /* actually is data received */
1956       rc = DSM_RC_MORE_DATA;      /* use different rc for consistency */
1957                                   /* with Query. No data returned */
1958                                   /* if rc = FINISHED.     */
1959    if ((rc == DSM_RC_FINISHED) ||
1960        (rc == DSM_RC_MORE_DATA))
1961    {
1962       /*=== data is already in the buffer ===*/
1963       BSAdataBlockP->numBytes = (BSA_UInt16)getBlk.numBytes;
1964    }
1965    else
1966    {
1967       /*=== appl may call BSAEndData to clean up trxn but don't count on it... ===*/
1968       AFSdsmEndGetObj(dsmHandle);
1969       AFSdsmEndGetData(dsmHandle);
1970       xopenGbl.sessFlags =
1971                (xopenGbl.sessFlags | FL_END_DATA_DONE);  /* turn flag on */
1972     }
1973
1974    xlateRC(BSAHandle, rc, &bsaRC);
1975    XOPENRETURN(BSAHandle, "BSAGetObject",
1976                bsaRC,__FILE__,__LINE__);
1977 }
1978
1979 BSA_Int16 BSAGetData(
1980     long              BSAHandle,
1981     DataBlock        *BSAdataBlockP
1982 )
1983 {
1984    dsInt16_t      rc = 0;
1985    BSA_Int16      bsaRC = 0;
1986    dsUint32_t     dsmHandle;
1987    DataBlk        getBlk;
1988
1989    if(!dsm_init)
1990    {
1991 #ifdef DEBUG_BUTC
1992         printf("TSM library not mounted. \n");
1993 #endif
1994         if (dsm_MountLibrary())
1995         {
1996                 printf("TSM Library initialisation failed. \n");
1997                 return 1 ;
1998         }
1999 #ifdef DEBUG_BUTC
2000         printf("TSM Library initialisation SUCCESS. \n");
2001 #endif
2002    }
2003
2004    dsmHandle = BSAHandle;
2005
2006
2007    sprintf(traceStr2, "BSAGetData ENTRY: BSAHandle:%ld, bufferLen:%d, numBytes:%d",
2008            BSAHandle,
2009            BSAdataBlockP->bufferLen,
2010            BSAdataBlockP->numBytes);
2011    ourTrace(BSAHandle,TrFL, traceStr2);
2012
2013    getBlk.stVersion = DataBlkVersion ;
2014    getBlk.bufferPtr = BSAdataBlockP->bufferPtr ;
2015    getBlk.bufferLen = BSAdataBlockP->bufferLen;
2016    getBlk.numBytes  = 0;
2017
2018    rc = AFSdsmGetData(dsmHandle, &getBlk) ;
2019
2020    if ((rc == DSM_RC_FINISHED) &&
2021        (getBlk.numBytes != 0))      /* actually is data received */
2022       rc = DSM_RC_MORE_DATA;        /* use different rc for consistency */
2023                                     /* with Query. No data returned */
2024                                     /* if rc = FINISHED.     */
2025
2026    if ((rc == DSM_RC_FINISHED) ||
2027        (rc == DSM_RC_MORE_DATA))
2028    {
2029       /*=== data is already in the buffer ===*/
2030       BSAdataBlockP->numBytes = (BSA_UInt16)getBlk.numBytes;
2031    }
2032    else
2033    {
2034       sprintf(traceStr2, "BSAGetData: Call to AFSdsmGetData error rc = %d", rc);
2035       ourTrace(BSAHandle, TrFL,traceStr2);
2036
2037       /*=== appl may call BSAEndData to clean up trxn but don't count on it... ===*/
2038       AFSdsmEndGetObj(dsmHandle);
2039       AFSdsmEndGetData(dsmHandle);
2040       xopenGbl.sessFlags =
2041                (xopenGbl.sessFlags | FL_END_DATA_DONE);  /* turn flag on */
2042    }
2043    xlateRC(BSAHandle, rc, &bsaRC);
2044    XOPENRETURN(BSAHandle, "BSAGetData(AFSdsmGetData)",
2045                bsaRC,__FILE__,__LINE__);
2046 }
2047
2048 BSA_Int16 BSASendData(
2049     long           BSAHandle,
2050     DataBlock     *BSAdataBlockP
2051 )
2052 {
2053    dsInt16_t      rc = 0;
2054    BSA_Int16      bsaRC = 0;
2055    dsUint32_t     dsmHandle;
2056    DataBlk        dataBlkArea;
2057
2058    if(!dsm_init)
2059    {
2060 #ifdef DEBUG_BUTC
2061         printf("TSM library not mounted. \n");
2062 #endif
2063         if (dsm_MountLibrary())
2064         {
2065                 printf("TSM Library initialisation failed. \n");
2066                 return 1 ;
2067         }
2068 #ifdef DEBUG_BUTC
2069         printf("TSM Library initialisation SUCCESS. \n");
2070 #endif
2071    }
2072
2073    dsmHandle = BSAHandle;
2074
2075
2076    sprintf(traceStr2, "BSASendData ENTRY: BSAHandle:%ld bufferLen: %d numBytes: %d ",
2077            BSAHandle,
2078            BSAdataBlockP->bufferLen,
2079            BSAdataBlockP->numBytes);
2080    ourTrace(BSAHandle, TrFL, traceStr2);
2081
2082    /*=== check for NULL dataBlock pointer ===*/
2083    if (BSAdataBlockP == NULL)
2084       XOPENRETURN(BSAHandle, "BSASendData",
2085                   BSA_RC_NULL_POINTER,__FILE__,__LINE__);
2086       dataBlkArea.stVersion = DataBlkVersion ;
2087       dataBlkArea.bufferPtr = BSAdataBlockP->bufferPtr ;
2088       dataBlkArea.bufferLen = BSAdataBlockP->bufferLen;
2089
2090       rc = AFSdsmSendData(dsmHandle, &dataBlkArea);
2091
2092       if (rc)
2093       {
2094
2095          sprintf(traceStr2, "BSASendData(AFSdsmSendData) error rc = %d", rc);
2096          ourTrace(BSAHandle,TrFL, traceStr2);
2097
2098          if (rc == DSM_RC_WILL_ABORT)  /* save flag */
2099             xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_RC_WILL_ABORT);
2100       }
2101       BSAdataBlockP->numBytes = (BSA_UInt16)dataBlkArea.numBytes;
2102       sprintf(traceStr2, "BSASendData(AFSdsmSendData): BSAHandle:%ld bufferLen: %d numBytes sent: %d ",
2103            BSAHandle,
2104            BSAdataBlockP->bufferLen,
2105            BSAdataBlockP->numBytes);
2106       ourTrace(BSAHandle, TrFL, traceStr2);
2107
2108       xlateRC(BSAHandle, rc, &bsaRC);
2109       XOPENRETURN(BSAHandle, "BSASendData",
2110                   BSA_RC_SUCCESS,__FILE__,__LINE__);
2111 }
2112
2113 BSA_Int16 BSAEndData(
2114     long          BSAHandle
2115 )
2116 {
2117    dsInt16_t      rc = 0;
2118    BSA_Int16      bsaRC = 0;
2119    dsUint32_t     dsmHandle;
2120
2121    if(!dsm_init)
2122    {
2123 #ifdef DEBUG_BUTC
2124         printf("TSM library not mounted. \n");
2125 #endif
2126         if (dsm_MountLibrary())
2127         {
2128                 printf("TSM Library initialisation failed. \n");
2129                 return 1 ;
2130         }
2131 #ifdef DEBUG_BUTC
2132         printf("TSM Library initialisation SUCCESS. \n");
2133 #endif
2134    }
2135
2136    dsmHandle = BSAHandle;
2137
2138
2139    sprintf(traceStr2, "BSAEndData ENTRY: BSAHandle:%ld", BSAHandle);
2140    ourTrace(BSAHandle,TrFL, traceStr2);
2141
2142    /*=======================================================
2143      check the state - don't issue base API call unless one
2144      was called previously, or else we get a sequence error.
2145      ======================================================*/
2146
2147    if (xopenGbl.oper == OPER_SEND_ISSUED)
2148    {
2149       rc = AFSdsmEndSendObj(dsmHandle);
2150       if (rc)
2151       {
2152
2153          sprintf(traceStr2, "BSAEndData(AFSdsmEndSendObj) error rc = %d", rc);
2154          ourTrace(BSAHandle,TrFL, traceStr2);
2155          xlateRC(BSAHandle, rc, &bsaRC);
2156       }
2157    }
2158    else
2159       if (xopenGbl.oper == OPER_RECV_ISSUED)
2160       {
2161           if (xopenGbl.sessFlags & FL_END_DATA_DONE)   /* EndData processing */
2162              xopenGbl.sessFlags =                     /*  already done */
2163                    (xopenGbl.sessFlags ^ FL_END_DATA_DONE);  /* turn flag off */
2164          else
2165          {
2166             rc = AFSdsmEndGetObj(dsmHandle);
2167             if (rc)
2168             {
2169                sprintf(traceStr2, "BSAEndData(AFSdsmEndGetObj) error rc = %d", rc);
2170                ourTrace(BSAHandle, TrFL, traceStr2);
2171
2172                /*==============================================================
2173                 this may get 'Out of sequence error' if previous GetObject
2174                 had rc=2 (no match). Don't return this to caller - too confusing
2175                 ===============================================================*/
2176                if (rc != DSM_RC_BAD_CALL_SEQUENCE)
2177                xlateRC(BSAHandle, rc, &bsaRC);
2178             }
2179
2180             rc = AFSdsmEndGetData(dsmHandle);
2181             if (rc)
2182             {
2183                sprintf(traceStr2, "BSAEndData(AFSdsmEndGetData) error rc = %d", rc);
2184                ourTrace(BSAHandle, TrFL, traceStr2);
2185                xlateRC(BSAHandle, rc, &bsaRC);
2186             }
2187          }
2188       }
2189    else  /* invalid state */
2190       if ((xopenGbl.oper != OPER_RECV_START) &&
2191           (xopenGbl.oper != OPER_SEND_START))
2192       {
2193          sprintf(traceStr2, "BSAEndData: BSAEndData but not Send or Recv");
2194          ourTrace(BSAHandle,TrFL, traceStr2);
2195          bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
2196       }
2197
2198    xopenGbl.oper = OPER_NONE;
2199    XOPENRETURN(BSAHandle, "BSAEndData",bsaRC,__FILE__,__LINE__);
2200 }
2201
2202 BSA_Int16 BSACreateObject(
2203     long              BSAHandle,
2204     ObjectDescriptor *BSAobjDescP,
2205     DataBlock        *BSAdataBlockP
2206 )
2207 {
2208    dsInt16_t          rc = 0;
2209    BSA_Int16          bsaRC = 0;
2210    dsUint32_t         dsmHandle;
2211    regFSData          regFilespace ;
2212    dsmObjName         objName ;
2213    ObjAttr            objAttrArea;
2214    sndArchiveData     archData;
2215    DataBlk            dataBlkArea;
2216    dsmSendType        sendType;
2217    dsUint8_t          dsmObjType;
2218    XAPIObjInfo        xapiObjInfo;
2219    mcBindKey          mcBindKey;
2220    BSAObjectOwner     upperNode;  /* upper cased node name */
2221    char               errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
2222    char               ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
2223
2224    if(!dsm_init)
2225    {
2226 #ifdef DEBUG_BUTC
2227         printf("TSM library not mounted. \n");
2228 #endif
2229         if (dsm_MountLibrary())
2230         {
2231                 printf("TSM Library initialisation failed. \n");
2232                 return 1 ;
2233         }
2234 #ifdef DEBUG_BUTC
2235         printf("TSM Library initialisation SUCCESS. \n");
2236 #endif
2237    }
2238
2239    memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
2240    memset(ourMessage,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
2241
2242    dsmHandle = BSAHandle;
2243
2244    if (BSAobjDescP != NULL && BSAdataBlockP != NULL)
2245    {
2246    sprintf(traceStr2, "BSACreateObject ENTRY: BSAHandle:%ld ObjOwner:'%s' appOwner:'%s' \n ObjName:'%.*s%.*s' \n objType:%d  size:'%lu %lu' resourceType:'%s'  \n bufferLen:%d numBytes:%d ",
2247
2248            BSAHandle,
2249            BSAobjDescP->Owner.bsaObjectOwner[0] != '\0' ? BSAobjDescP->Owner.bsaObjectOwner : "",
2250            BSAobjDescP->Owner.appObjectOwner[0] != '\0' ?  BSAobjDescP->Owner.appObjectOwner : "",
2251            100,BSAobjDescP->objName.objectSpaceName[0] != '\0' ? BSAobjDescP->objName.objectSpaceName
2252            : "",
2253            100,BSAobjDescP->objName.pathName[0] != '\0' ? BSAobjDescP->objName.pathName : "",
2254            BSAobjDescP->objectType,
2255            BSAobjDescP->size.left,
2256            BSAobjDescP->size.right,
2257            BSAobjDescP->resourceType[0] != '\0' ?  BSAobjDescP->resourceType : "" ,
2258            BSAdataBlockP->bufferLen,
2259            BSAdataBlockP->numBytes);
2260   }
2261   else
2262   {
2263     if (BSAobjDescP == NULL)
2264       {
2265          bsaRC = BSA_RC_NULL_POINTER;
2266          XOPENRETURN(BSAHandle, "BSACreateObject",
2267                   bsaRC,__FILE__,__LINE__);
2268       }
2269     sprintf(traceStr2, "BSACreateObject ENTRY: BSAHandle:%ld", BSAHandle);
2270   }
2271
2272   ourTrace(BSAHandle, TrFL, traceStr2);
2273
2274    xopenGbl.oper = OPER_SEND_START;    /* save state for EndData later */
2275    /*=================================================================
2276    if (BSAobjDescP->version != ObjectDescriptorVersion)
2277        BSA spec doesn't require this currently..
2278    =================================================================*/
2279
2280    /*===============================================================
2281     if the node name is different - we won't create it compare both
2282     the value passed on the BSAInit and the final value used for the
2283     session (which may be different for Generate)
2284     ===============================================================*/
2285    strcpy(upperNode, BSAobjDescP->Owner.bsaObjectOwner);
2286    StrUpper(upperNode);
2287    if ((strcmp(upperNode, xopenGbl.dsmSessInfo.id)) &&
2288       (strcmp(BSAobjDescP->Owner.bsaObjectOwner, xopenGbl.bsaObjectOwner)))
2289    {
2290       sprintf(traceStr2,
2291              "BSACreateObject: BSAObjectOwner(%s) doesn't match value for session(%s).",
2292               upperNode, xopenGbl.dsmSessInfo.id);
2293       ourTrace(BSAHandle,TrFL, traceStr2);
2294       bsaRC = ADSM_RC_INVALID_NODE;
2295       strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
2296       ourLogEvent_Ex(BSAHandle,logLocal, ourMessage, errPrefix, logSevError);
2297       XOPENRETURN(BSAHandle, "BSACreateObject",
2298                   bsaRC,__FILE__,__LINE__);
2299    }
2300
2301    /*=== check string lengths - if this too long, it won't fit in our objInfo ===*/
2302    if (strlen(BSAobjDescP->desc) > ADSM_MAX_DESC)
2303    {
2304       sprintf(traceStr2,"BSACreateObject: description longer than TSM max (%" AFS_SIZET_FMT "). ",
2305               strlen(BSAobjDescP->desc));
2306       ourTrace(BSAHandle, TrFL, traceStr2);
2307       bsaRC = BSA_RC_DESC_TOO_LONG;
2308       XOPENRETURN(BSAHandle, "BSACreateObject",
2309                   bsaRC,__FILE__,__LINE__);
2310    }
2311    if (strlen(BSAobjDescP->objectInfo) > ADSM_MAX_OBJINFO)
2312    {
2313       sprintf(traceStr2,"BSACreateObject: objInfo longer than TSM max (%" AFS_SIZET_FMT ").",
2314       strlen(BSAobjDescP->objectInfo));
2315       ourTrace(BSAHandle,TrFL, traceStr2);
2316       bsaRC = BSA_RC_OBJINFO_TOO_LONG;
2317       XOPENRETURN(BSAHandle, "BSACreateObject",
2318                   bsaRC,__FILE__,__LINE__);
2319    }
2320
2321    if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
2322    {
2323       sprintf(traceStr2, "BSACreateObject issued without BSABeginTxn");
2324       ourTrace(BSAHandle,TrFL, traceStr2);
2325       bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
2326       XOPENRETURN(BSAHandle, "BSACreateObject",
2327                   bsaRC,__FILE__,__LINE__);
2328    }
2329
2330    if (strlen(BSAobjDescP->objName.objectSpaceName) > BSA_MAX_OSNAME)
2331    {
2332       sprintf(traceStr2, "BSACreateObject: objectSpaceName too long (%" AFS_SIZET_FMT ")",
2333                        strlen(BSAobjDescP->objName.objectSpaceName));
2334       ourTrace(BSAHandle, TrFL, traceStr2);
2335       bsaRC = BSA_RC_OBJNAME_TOO_LONG;
2336       XOPENRETURN(BSAHandle, "BSACreateObject:",
2337                   bsaRC,__FILE__,__LINE__);
2338    }
2339
2340    if (!(xopenGbl.sessFlags & FL_IN_DSM_TXN))        /* first CreateObj */
2341    { /* can't issue RegisterFS if already in Txn */
2342       /*=== Register the file space ===*/
2343       regFilespace.stVersion = regFSDataVersion ;
2344       regFilespace.fsName = BSAobjDescP->objName.objectSpaceName ;
2345
2346       /*===  use resource type for fsType (as it was intended)  ===*/
2347
2348       regFilespace.fsType = BSAobjDescP->resourceType ;
2349       regFilespace.capacity.lo = 0;
2350       regFilespace.capacity.hi = 0;
2351       regFilespace.occupancy.lo = 0;
2352       regFilespace.occupancy.hi = 0;
2353       #if _OPSYS_TYPE == DS_AIX
2354          regFilespace.fsAttr.unixFSAttr.fsInfoLength = strlen(XAPI_FSINFO) ;
2355          strcpy(regFilespace.fsAttr.unixFSAttr.fsInfo, XAPI_FSINFO);
2356       #else
2357          regFilespace.fsAttr.dosFSAttr.fsInfoLength = strlen(XAPI_FSINFO) ;
2358          strcpy(regFilespace.fsAttr.dosFSAttr.fsInfo, XAPI_FSINFO);
2359          regFilespace.fsAttr.dosFSAttr.driveLetter = 'X';
2360       #endif
2361       rc = AFSdsmRegisterFS(dsmHandle, &regFilespace) ;
2362       if ((rc != 0) && (rc != DSM_RC_FS_ALREADY_REGED))
2363       {
2364          sprintf(traceStr2, "BSACreateObject(AFSdsmRegisterFS) error rc = %d",rc);
2365          ourTrace(BSAHandle,TrFL, traceStr2);
2366
2367          xlateRC(BSAHandle, rc, &bsaRC);
2368          XOPENRETURN(BSAHandle, "BSACreateObject(AFSdsmRegisterFS)",
2369                      bsaRC,__FILE__,__LINE__);
2370       }
2371    }
2372
2373    /*========================================================
2374     Check for invalid copyType before sending data. Log error
2375     to dsirror.log file.
2376     ========================================================*/
2377     if (BSAobjDescP->copyType == BSACopyType_ARCHIVE)
2378        sendType = stArchiveMountWait;
2379     else
2380        if (BSAobjDescP->copyType == BSACopyType_BACKUP)
2381           sendType = stBackupMountWait;
2382        else
2383        {
2384            sprintf(traceStr2,
2385                   "BSACreateObject: invalid copyType (%d)",
2386                    BSAobjDescP->copyType);
2387            ourTrace(BSAHandle,TrFL, traceStr2);
2388            bsaRC = ADSM_RC_INVALID_COPYTYPE;
2389            strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
2390            ourLogEvent_Ex(BSAHandle,logLocal, ourMessage, errPrefix, logSevError);
2391            XOPENRETURN(BSAHandle, "BSACreateObject",
2392                        bsaRC,__FILE__,__LINE__);
2393        }
2394
2395    if ((BSAobjDescP->objectType == BSAObjectType_FILE) ||
2396       (BSAobjDescP->objectType == BSAObjectType_DATABASE) ||
2397       (BSAobjDescP->objectType == BSAObjectType_ANY))
2398
2399          dsmObjType = DSM_OBJ_FILE;
2400    else
2401       if (BSAobjDescP->objectType == BSAObjectType_DIRECTORY)
2402          dsmObjType = DSM_OBJ_DIRECTORY;
2403       else
2404       {
2405          sprintf(traceStr2,
2406                "BSACreateObject: invalid objectType (%d)",
2407                 BSAobjDescP->objectType);
2408          ourTrace(BSAHandle,TrFL, traceStr2);
2409          bsaRC = ADSM_RC_INVALID_OBJTYPE;
2410          strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
2411          ourLogEvent_Ex(BSAHandle,logLocal, ourMessage, errPrefix, logSevError);
2412          XOPENRETURN(BSAHandle, "BSACreateObject",
2413                     bsaRC,__FILE__,__LINE__);
2414       }
2415
2416    /*==================================================================
2417     put in a check here - count the number of objects per txn
2418     and compare with xopenGbl.sessInfo.maxObjPerTxn
2419     If reach the limit, EndTxn and start a new one
2420     OK to do this without telling the BSA caller?
2421     Or should we exit with an error to tell them the limit is reached ?
2422     ==================================================================*/
2423
2424     if (!(xopenGbl.sessFlags & FL_IN_DSM_TXN))
2425     {
2426       rc = AFSdsmBeginTxn(dsmHandle);
2427
2428       if (rc)
2429       {
2430          sprintf(traceStr2, "BSACreateObject(AFSdsmBeginTxn) error rc = %d", rc);
2431          ourTrace(BSAHandle,TrFL, traceStr2);
2432          xlateRC(BSAHandle, rc, &bsaRC);
2433          XOPENRETURN(BSAHandle, "BSACreateObject(AFSdsmBeginTxn)",
2434                      bsaRC,__FILE__,__LINE__);
2435       }
2436       xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_DSM_TXN); /* set on */
2437     }
2438
2439     /*=== Backup the data  ===*/
2440
2441    /*================================================================
2442      the entire pathname gets copied into hl during parsing, so
2443      check for that max len as well. For now these are the same value.
2444      =================================================================*/
2445    if (strlen(BSAobjDescP->objName.pathName) >
2446             min(DSM_MAX_HL_LENGTH, BSA_MAX_PATHNAME))
2447    {
2448       sprintf(traceStr2, "BSACreateObject: pathName too long (%" AFS_SIZET_FMT ")",
2449               strlen(BSAobjDescP->objName.pathName));
2450       ourTrace(BSAHandle,TrFL, traceStr2);
2451       bsaRC = BSA_RC_OBJNAME_TOO_LONG;
2452       XOPENRETURN(BSAHandle, "BSACreateObject",
2453                   bsaRC,__FILE__,__LINE__);
2454    }
2455
2456    strcpy(objName.fs,BSAobjDescP->objName.objectSpaceName) ;
2457    /*=== previous code to use only ll field ===*/
2458    /*objName.hl[0] = '\0';
2459      strcpy(objName.ll,BSAobjDescP->objName.pathName) ;
2460    */
2461    xparsePath(BSAHandle, BSAobjDescP->objName.pathName, objName.hl, objName.ll);
2462    objName.objType = dsmObjType ;
2463
2464    objAttrArea.stVersion = ObjAttrVersion ;
2465    strcpy(objAttrArea.owner,BSAobjDescP->Owner.appObjectOwner);
2466    objAttrArea.sizeEstimate.hi = BSAobjDescP->size.left;
2467    objAttrArea.sizeEstimate.lo = BSAobjDescP->size.right;
2468    objAttrArea.objCompressed = bFalse ;  /* let COMPRESSION option decide */
2469    /*=== whether there's actually compression ===*/
2470    objAttrArea.objInfoLength = sizeof(XAPIObjInfo);
2471    objAttrArea.objInfo = (char *)&xapiObjInfo ;
2472
2473    memset(&xapiObjInfo,0x00,sizeof(XAPIObjInfo));
2474    strcpy(xapiObjInfo.resourceType, BSAobjDescP->resourceType);
2475    xapiObjInfo.size.left = BSAobjDescP->size.left;
2476    xapiObjInfo.size.right = BSAobjDescP->size.right;
2477    strcpy(xapiObjInfo.partDesc, BSAobjDescP->desc);
2478    strcpy(xapiObjInfo.partObjInfo, BSAobjDescP->objectInfo);
2479
2480    /*=== check if a lifecycle group name was passed to us ===*/
2481    if (strlen(BSAobjDescP->lGName))
2482       objAttrArea.mcNameP = (char *)BSAobjDescP->lGName ;
2483    else
2484       objAttrArea.mcNameP = NULL;
2485
2486       dataBlkArea.stVersion = DataBlkVersion ;
2487       if (BSAdataBlockP == NULL)
2488       {
2489          dataBlkArea.bufferPtr = NULL;
2490          dataBlkArea.bufferLen = 0;
2491       }
2492       else
2493       {
2494          dataBlkArea.bufferPtr = BSAdataBlockP->bufferPtr ;
2495          dataBlkArea.bufferLen = BSAdataBlockP->bufferLen;
2496       }
2497
2498       /*=======================================================
2499        always issue BindMC because we don't expect applications
2500        to call ResolveLifecycleGroup since it isn't in the
2501        Data Movement subset
2502        =======================================================*/
2503        mcBindKey.stVersion = mcBindKeyVersion ;
2504        rc = AFSdsmBindMC(dsmHandle, &objName, sendType, &mcBindKey);
2505        if (rc)
2506        {
2507           sprintf(traceStr2, "BSACreateObject(AFSdsmBindMC): error rc = %d", rc);
2508           ourTrace(BSAHandle, TrFL, traceStr2);
2509           xlateRC(BSAHandle, rc, &bsaRC);
2510           XOPENRETURN(BSAHandle, "BSACreateObject(dsnBindMC)",
2511                       bsaRC,__FILE__,__LINE__);
2512        }
2513
2514        /*=== now update state since we'll issue the base Send call ===*/
2515
2516        xopenGbl.oper = OPER_SEND_ISSUED;    /* save state for EndData later */
2517
2518        switch (sendType)
2519        {
2520           case (stBackupMountWait) :
2521           rc = AFSdsmSendObj(dsmHandle,
2522                           sendType,
2523                           NULL,
2524                           &objName,
2525                           &objAttrArea,
2526                           &dataBlkArea);
2527           break;
2528
2529           case (stArchiveMountWait) :
2530           archData.stVersion = sndArchiveDataVersion;
2531           archData.descr = (char *)(BSAobjDescP->desc);
2532           rc = AFSdsmSendObj(dsmHandle,
2533                           sendType,
2534                           &archData,
2535                           &objName,
2536                           &objAttrArea,
2537                           &dataBlkArea);
2538           break;
2539           default : ;
2540        }
2541
2542        if (rc != DSM_RC_OK)
2543        {
2544           sprintf(traceStr2, "BSACreateObject(AFSdsmSendObj) error rc = %d", rc);
2545           ourTrace(BSAHandle,TrFL, traceStr2);
2546
2547           if (rc == DSM_RC_WILL_ABORT)  /* save flag */
2548              xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_RC_WILL_ABORT);
2549
2550           xlateRC(BSAHandle, rc, &bsaRC);
2551           XOPENRETURN(BSAHandle, "BSACreateObject(AFSdsmSendObj)",
2552                       bsaRC,__FILE__,__LINE__);
2553        }
2554    XOPENRETURN(BSAHandle, "BSACreateObject",
2555                BSA_RC_SUCCESS, __FILE__,__LINE__);
2556 }
2557
2558
2559 BSA_Int16 BSADeleteObject(
2560     long           BSAHandle,
2561     CopyType       copyType,
2562     ObjectName     *BSAobjNameP,
2563     CopyId         *copyidP
2564 )
2565 {
2566    dsInt16_t      rc = 0;
2567    BSA_Int16      bsaRC = 0;
2568    dsUint32_t     dsmHandle;
2569    dsUint16_t     reason ;                   /* for AFSdsmEndTxn */
2570    dsmObjName     dsmobjName;
2571
2572    dsmDelType delType;
2573    dsmDelInfo delInfo;
2574
2575    delList *llHeadP = NULL;
2576    delList *llTailP = NULL;
2577    delList *ll = NULL;
2578
2579    char errPrefix[DSM_MAX_RC_MSG_LENGTH + 1];
2580    char ourMessage[DSM_MAX_RC_MSG_LENGTH + 1];
2581
2582    if(!dsm_init)
2583    {
2584 #ifdef DEBUG_BUTC
2585         printf("TSM library not mounted. \n");
2586 #endif
2587         if (dsm_MountLibrary())
2588         {
2589                 printf("TSM Library initialisation failed. \n");
2590                 return 1 ;
2591         }
2592 #ifdef DEBUG_BUTC
2593         printf("TSM Library initialisation SUCCESS. \n");
2594 #endif
2595    }
2596
2597    memset(errPrefix,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
2598    memset(ourMessage,     '\0', DSM_MAX_RC_MSG_LENGTH + 1);
2599
2600    dsmHandle = BSAHandle;
2601
2602    sprintf(traceStr2, "BSADeleteObject ENTRY: BSAHandle:%ld CopyType:%d \n ObjName:'%.*s%.*s' copyidP:'%lu %lu'.",
2603            BSAHandle,
2604            copyType,
2605            100,BSAobjNameP->objectSpaceName,
2606            100,BSAobjNameP->pathName,
2607            copyidP->left,
2608            copyidP->right);
2609    ourTrace(BSAHandle, TrFL, traceStr2);
2610    if (copyType != BSACopyType_ARCHIVE)
2611    {
2612       sprintf(traceStr2,
2613               "BSADeleteObject: invalid copyType %d",
2614                copyType);
2615       ourTrace(BSAHandle,TrFL, traceStr2);
2616       bsaRC = ADSM_RC_INVALID_COPYTYPE;
2617       strcpy(ourMessage, ourRCMsg(bsaRC, errPrefix));
2618       ourLogEvent_Ex(BSAHandle, logLocal, ourMessage, errPrefix, logSevError);
2619       XOPENRETURN(BSAHandle, "BSADeleteObject",
2620                   bsaRC,__FILE__,__LINE__);
2621    }
2622
2623    if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
2624    {
2625       sprintf(traceStr2, "BSADeleteObject issued without BSABeginTxn");
2626       ourTrace(BSAHandle, TrFL, traceStr2);
2627
2628       bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
2629       XOPENRETURN(BSAHandle, "BSADeleteObject:",
2630                   bsaRC,__FILE__,__LINE__);
2631    }
2632
2633    strcpy(dsmobjName.fs, BSAobjNameP->objectSpaceName);
2634    xparsePath(BSAHandle, BSAobjNameP->pathName, dsmobjName.hl, dsmobjName.ll);
2635    dsmobjName.objType = DSM_OBJ_FILE;
2636
2637    if (!copyidP)    /* NULL, so query and delete all with same name */
2638    {
2639       if (xopenGbl.sessFlags & FL_IN_DSM_TXN)
2640       /*=== if a trxn had been started, end it before doing Query ===*/
2641       {
2642          rc = AFSdsmEndTxn(dsmHandle, DSM_VOTE_COMMIT, &reason);
2643          xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_DSM_TXN); /* set off */
2644       }
2645       rc = buildList(dsmHandle, &dsmobjName, &llHeadP, &llTailP);
2646       if (rc)
2647       {
2648          bsaRC = BSA_RC_OBJECT_NOT_FOUND;
2649          XOPENRETURN(BSAHandle, "BSADeleteObject(buildList)",
2650                      bsaRC,__FILE__,__LINE__);
2651       }
2652    }
2653
2654    if (!(xopenGbl.sessFlags & FL_IN_DSM_TXN))        /* first call */
2655    {
2656       rc = AFSdsmBeginTxn(dsmHandle);
2657       if (rc)
2658       {
2659          xlateRC(BSAHandle, rc, &bsaRC);
2660          XOPENRETURN(dsmHandle,"BSADeleteObject(AFSdsmBeginTxn)",
2661                      bsaRC,__FILE__,__LINE__);
2662       }
2663       xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_DSM_TXN); /* set on */
2664    }
2665
2666    delType = dtArchive;
2667    delInfo.archInfo.stVersion = delArchVersion;
2668
2669    if (copyidP)   /* single ID to delete */
2670    {
2671       delInfo.archInfo.objId.hi  = copyidP->left;
2672       delInfo.archInfo.objId.lo  = copyidP->right;
2673
2674       if ((rc = AFSdsmDeleteObj(dsmHandle,delType,delInfo)) != DSM_RC_OK)
2675       {
2676          sprintf(traceStr2, "BSADeleteObject: AFSdsmDeleteObj error rc = %d", rc);
2677          ourTrace(dsmHandle,TrFL, traceStr2);
2678       }
2679    }
2680    else   /* multiple IDs to delete */
2681    {
2682       ll = llHeadP;
2683       while (ll)
2684       {
2685          delInfo.archInfo.objId.hi  = ll->objId.hi;
2686          delInfo.archInfo.objId.lo  = ll->objId.lo;
2687          if ((rc = AFSdsmDeleteObj(dsmHandle, delType, delInfo)) != DSM_RC_OK)
2688          {
2689             sprintf(traceStr2, "BSADeleteObject: AFSdsmDeleteObj error rc = %d", rc);
2690             ourTrace(dsmHandle, TrFL, traceStr2);
2691             /*=== break and get out of loop, or keep going? ===*/
2692          }
2693          /*=== incr to next list entry ===*/
2694          ll = ll->next;
2695       }
2696       /*=== free list now that done ===*/
2697       rc =  freeList(&llHeadP, &llTailP);
2698    }
2699
2700    xlateRC(BSAHandle, rc, &bsaRC);
2701    XOPENRETURN(BSAHandle,"BSADeleteObject",
2702                bsaRC,__FILE__,__LINE__)
2703 }
2704
2705 BSA_Int16 BSAMarkObjectInactive(
2706     long            BSAHandle,
2707     ObjectName     *BSAobjNameP
2708 )
2709 {
2710    dsInt16_t      rc = 0;
2711    BSA_Int16      bsaRC = 0;
2712    dsUint32_t     dsmHandle;
2713
2714    dsmObjName           dsmobjName;
2715
2716    qryBackupData        queryBuffer;       /* for query Backup */
2717    qryRespBackupData    qbDataArea;
2718    DataBlk              qDataBlkArea;
2719
2720    dsmDelType           delType;
2721    dsmDelInfo           delInfo;
2722
2723    dsUint16_t           reason ;                   /* for AFSdsmEndTxn */
2724    /*=== build list of all objTypes we find for this name ===*/
2725    dsInt16_t            i;
2726    dsInt16_t            numTypes;
2727    dsUint8_t            listObjType[5];    /* only 2 objTypes defined today */
2728    dsUint32_t           listCopyGroup[5];
2729
2730    if(!dsm_init)
2731    {
2732 #ifdef DEBUG_BUTC
2733         printf("TSM library not mounted. \n");
2734 #endif
2735         if (dsm_MountLibrary())
2736         {
2737                 printf("TSM Library initialisation failed. \n");
2738                 return 1 ;
2739         }
2740 #ifdef DEBUG_BUTC
2741         printf("TSM Library initialisation SUCCESS. \n");
2742 #endif
2743    }
2744
2745    dsmHandle = BSAHandle;
2746    memset(&delInfo, 0x00, sizeof(dsmDelInfo));
2747    memset(&queryBuffer, 0x00, sizeof(qryBackupData));
2748
2749    sprintf(traceStr2, "BSAMarkObjectInactive ENTRY: BSAHandle:%ld \n ObjName:'%.*s%.*s'.",
2750            BSAHandle,
2751            100, BSAobjNameP->objectSpaceName,
2752            100, BSAobjNameP->pathName);
2753    ourTrace(dsmHandle, TrFL, traceStr2);
2754
2755    if (!(xopenGbl.sessFlags & FL_IN_BSA_TXN))
2756    {
2757       sprintf(traceStr2, "BSAMarkObjectInactive: issued without BSABeginTxn.");
2758       ourTrace(BSAHandle, TrFL, traceStr2);
2759       bsaRC = BSA_RC_BAD_CALL_SEQUENCE;
2760       XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
2761                   bsaRC,__FILE__,__LINE__);
2762    }
2763
2764    if (strlen(BSAobjNameP->objectSpaceName) > DSM_MAX_FSNAME_LENGTH)
2765    {
2766       sprintf(traceStr2, "BSAMarkObjectInactive: objectSpaceName too long (%" AFS_SIZET_FMT ")", strlen(BSAobjNameP->objectSpaceName));
2767       ourTrace(BSAHandle,TrFL, traceStr2);
2768
2769       bsaRC = BSA_RC_OBJNAME_TOO_LONG;
2770       XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
2771                   bsaRC,__FILE__,__LINE__);
2772    }
2773    /*===============================================================
2774     The entire pathname gets copied into hl during parsing, so
2775     check for that max len as well. For now these are the same value.
2776     =============================================================== */
2777    if (strlen(BSAobjNameP->pathName) >
2778        min(DSM_MAX_HL_LENGTH, BSA_MAX_PATHNAME))
2779    {
2780       sprintf(traceStr2, "BSAMarkObjectInactive: pathName too long (%" AFS_SIZET_FMT ")",
2781                          strlen(BSAobjNameP->pathName));
2782       ourTrace(BSAHandle,TrFL, traceStr2);
2783       bsaRC = BSA_RC_OBJNAME_TOO_LONG;
2784       XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
2785                   bsaRC,__FILE__,__LINE__);
2786    }
2787
2788    /*==============================================================
2789     we don't allow any wildcard in name because that could retrieve
2790     LOTS of objects and make list processing more complicated.
2791     XBSA spec implies a single object.
2792     ==============================================================*/
2793    if ( strchr(BSAobjNameP->objectSpaceName, '*') ||
2794         strchr(BSAobjNameP->objectSpaceName, '?') ||
2795         strchr(BSAobjNameP->pathName,        '*') ||
2796         strchr(BSAobjNameP->pathName,        '?'))
2797    {
2798
2799       sprintf(traceStr2, "BSAMarkObjectInactive: objName contains a wildcard.")
2800 ;
2801       ourTrace(BSAHandle, TrFL, traceStr2);
2802       /*=== could have a more specific rc, use this for now ===*/
2803       bsaRC = BSA_RC_ABORT_ACTIVE_NOT_FOUND;
2804       XOPENRETURN(BSAHandle, "BSAMarkObjectInactive",
2805                   bsaRC,__FILE__,__LINE__);
2806    }
2807
2808    strcpy(dsmobjName.fs, BSAobjNameP->objectSpaceName);
2809    xparsePath(BSAHandle, BSAobjNameP->pathName, dsmobjName.hl, dsmobjName.ll);
2810    dsmobjName.objType = DSM_OBJ_ANY_TYPE;
2811
2812    /*============================================================
2813     A Backup Delete must include the copy Group and objType this
2814     wasn't passed in, so we have to do a query.
2815     ============================================================*/
2816
2817    queryBuffer.stVersion = qryBackupDataVersion ;
2818    queryBuffer.objName = &dsmobjName;
2819    queryBuffer.owner   = xopenGbl.dsmSessInfo.owner;
2820    queryBuffer.objState = DSM_ACTIVE;              /* only get active one */
2821
2822    if ((rc=AFSdsmBeginQuery(dsmHandle, qtBackup,
2823                         (void *)&queryBuffer )) != DSM_RC_OK)
2824    {
2825       sprintf(traceStr2, "BSAMarkObjectInactive: Call to AFSdsmBeginQuery for Backup error rc = %d", rc);
2826       ourTrace(BSAHandle,TrFL, traceStr2);
2827       xlateRC(BSAHandle, rc, &bsaRC);
2828       if ((rc == DSM_RC_ABORT_NO_MATCH) ||    /* special rc for MarkInact */
2829           (rc == DSM_RC_FILE_SPACE_NOT_FOUND))
2830          bsaRC = BSA_RC_ABORT_ACTIVE_NOT_FOUND;
2831
2832       rc = AFSdsmEndQuery(dsmHandle);
2833       XOPENRETURN(BSAHandle, "BSAMarkObjectInactive: AFSdsmBeginQuery",
2834                   bsaRC,__FILE__,__LINE__);
2835    }
2836
2837    qbDataArea.stVersion   = qryRespBackupDataVersion;
2838    qDataBlkArea.stVersion = DataBlkVersion ;
2839    qDataBlkArea.bufferPtr = (char *)&qbDataArea;
2840    qDataBlkArea.bufferLen = sizeof(qryRespBackupData);
2841
2842    numTypes = 0;
2843    rc = AFSdsmGetNextQObj(dsmHandle, &qDataBlkArea);
2844    while (((rc == DSM_RC_MORE_DATA) ||
2845          (rc == DSM_RC_FINISHED)) &&
2846           qDataBlkArea.numBytes)
2847    {  /* save copy Group we got */
2848       listCopyGroup[numTypes] = qbDataArea.copyGroup;
2849       listObjType[numTypes]   = qbDataArea.objName.objType;
2850       numTypes++;
2851       rc = AFSdsmGetNextQObj(dsmHandle, &qDataBlkArea);
2852    }
2853
2854    if (rc != DSM_RC_FINISHED)
2855    {
2856       xlateRC(BSAHandle, rc, &bsaRC);
2857       if ((rc == DSM_RC_ABORT_NO_MATCH) || /* special rc for MarkInact */
2858           (rc == DSM_RC_FILE_SPACE_NOT_FOUND))
2859          bsaRC = BSA_RC_ABORT_ACTIVE_NOT_FOUND;
2860       rc = AFSdsmEndQuery(dsmHandle);
2861       XOPENRETURN(BSAHandle,"BSAMarkObjectInactive: AFSdsmGetNextQObj",
2862                   bsaRC,__FILE__,__LINE__);
2863    }
2864    rc = AFSdsmEndQuery(dsmHandle);
2865
2866    /*=== now we can do the delete ===*/
2867    rc = AFSdsmBeginTxn(dsmHandle);
2868
2869    if (rc)
2870    {
2871      xlateRC(BSAHandle, rc, &bsaRC);
2872      XOPENRETURN(BSAHandle,"BSAMarkObjectInactive: AFSdsmBeginTxn",
2873                  bsaRC,__FILE__,__LINE__);
2874    }
2875    xopenGbl.sessFlags = (xopenGbl.sessFlags | FL_IN_DSM_TXN); /* set on */
2876
2877    delType = dtBackup;     /* this only applies to Backup */
2878
2879    delInfo.backInfo.stVersion = delBackVersion;
2880    delInfo.backInfo.objNameP = &dsmobjName;
2881
2882    for (i=0; i<numTypes; i++)
2883    {
2884       delInfo.backInfo.copyGroup = listCopyGroup[i];
2885       dsmobjName.objType         = listObjType[i];
2886
2887       if ((rc = AFSdsmDeleteObj(dsmHandle, delType, delInfo)) != DSM_RC_OK)
2888       {
2889
2890          sprintf(traceStr2, "BSAMarkObjectInactive: call to AFSdsmDeleteObj error rc = %d", rc);
2891          ourTrace(BSAHandle, TrFL, traceStr2);
2892       }
2893    }
2894
2895    /*=== issue EndTxn since these can't be nested because of Query sequence ===*/
2896    AFSdsmEndTxn(dsmHandle, DSM_VOTE_COMMIT, &reason);
2897    xopenGbl.sessFlags = (xopenGbl.sessFlags ^ FL_IN_DSM_TXN); /* set off */
2898
2899    xlateRC(BSAHandle, rc, &bsaRC);
2900    XOPENRETURN(BSAHandle,"BSAMarkObjectInactive",
2901                bsaRC,__FILE__,__LINE__);
2902 }
2903
2904 #endif /*xbsa*/