00001
00002
00003
00004
00005
00006
00007
00008
00009 #include <unistd.h>
00010 #include <fcntl.h>
00011 #include "rodsDef.h"
00012 #include "physPath.h"
00013 #include "dataObjOpr.h"
00014 #include "rodsDef.h"
00015 #include "rsGlobalExtern.h"
00016 #include "fileChksum.h"
00017 #include "modDataObjMeta.h"
00018 #include "objMetaOpr.h"
00019 #include "collection.h"
00020 #include "resource.h"
00021 #include "dataObjClose.h"
00022 #include "rcGlobalExtern.h"
00023 #include "reGlobalsExtern.h"
00024 #include "reDefines.h"
00025 #include "reSysDataObjOpr.h"
00026 #include "genQuery.h"
00027 #include "rodsClient.h"
00028
00029 #include <iostream>
00030
00031
00032
00033 #include "eirods_resource_backport.h"
00034 #include "eirods_hierarchy_parser.h"
00035 #include "eirods_stacktrace.h"
00036
00037 int
00038 getFileMode (dataObjInp_t *dataObjInp)
00039 {
00040 int createMode;
00041 int defFileMode;
00042
00043 defFileMode = getDefFileMode ();
00044 if (dataObjInp != NULL &&
00045 (dataObjInp->createMode & 0110) != 0) {
00046 if ((defFileMode & 0070) != 0) {
00047 createMode = defFileMode | 0110;
00048 } else {
00049 createMode = defFileMode | 0100;
00050 }
00051 } else {
00052 createMode = defFileMode;
00053 }
00054
00055 return (createMode);
00056 }
00057
00058 int
00059 getFileFlags (int l1descInx)
00060 {
00061 int flags;
00062
00063 dataObjInp_t *dataObjInp = L1desc[l1descInx].dataObjInp;
00064
00065 if (dataObjInp != NULL) {
00066 flags = dataObjInp->openFlags;
00067 } else {
00068 flags = O_RDONLY;
00069 }
00070
00071 return (flags);
00072 }
00073
00074 int
00075 getFilePathName (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00076 dataObjInp_t *dataObjInp)
00077 {
00078 char *filePath;
00079 vaultPathPolicy_t vaultPathPolicy;
00080 int status;
00081
00082 if (dataObjInp != NULL &&
00083 (filePath = getValByKey (&dataObjInp->condInput, FILE_PATH_KW)) != NULL
00084 && strlen (filePath) > 0) {
00085 rstrcpy (dataObjInfo->filePath, filePath, MAX_NAME_LEN);
00086 return (0);
00087 }
00088
00089
00090 if (dataObjInp != NULL && dataObjInfo->rescInfo == NULL) {
00091 rodsLog (LOG_ERROR,
00092 "getFilePathName: rescInfo for %s not resolved",
00093 dataObjInp->objPath);
00094 return (SYS_INVALID_RESC_INPUT);
00095 }
00096
00097
00098 int chk_path = 0;
00099 eirods::error err = eirods::get_resource_property< int >( dataObjInfo->rescInfo->rescName, "check_path_perm", chk_path );
00100 if( !err.ok() ) {
00101 eirods::log( PASS( err ) );
00102 }
00103
00104 if( NO_CREATE_PATH == chk_path ) {
00105 *dataObjInfo->filePath = '\0';
00106 return 0;
00107 }
00108
00109 std::string vault_path;
00110 status = getLeafRescPathName(dataObjInfo->rescHier, vault_path);
00111 if(status != 0) {
00112 return status;
00113 }
00114
00115 status = getVaultPathPolicy (rsComm, dataObjInfo, &vaultPathPolicy);
00116 if (status < 0) {
00117 return (status);
00118 }
00119
00120 if (vaultPathPolicy.scheme == GRAFT_PATH_S) {
00121 status = setPathForGraftPathScheme (dataObjInp->objPath,
00122 vault_path.c_str(), vaultPathPolicy.addUserName,
00123 rsComm->clientUser.userName, vaultPathPolicy.trimDirCnt,
00124 dataObjInfo->filePath);
00125 } else {
00126 status = setPathForRandomScheme (dataObjInp->objPath,
00127 vault_path.c_str(), rsComm->clientUser.userName,
00128 dataObjInfo->filePath);
00129 }
00130
00131 if (status < 0) {
00132 return (status);
00133 }
00134
00135 return (status);
00136 }
00137
00138 int
00139 getVaultPathPolicy (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00140 vaultPathPolicy_t *outVaultPathPolicy)
00141 {
00142 ruleExecInfo_t rei;
00143 msParam_t *msParam;
00144 int status;
00145
00146 if (outVaultPathPolicy == NULL || dataObjInfo == NULL || rsComm == NULL) {
00147 rodsLog (LOG_ERROR,
00148 "getVaultPathPolicy: NULL input");
00149 return (SYS_INTERNAL_NULL_INPUT_ERR);
00150 }
00151 initReiWithDataObjInp (&rei, rsComm, NULL);
00152
00153 rei.doi = dataObjInfo;
00154 status = applyRule ("acSetVaultPathPolicy", NULL, &rei, NO_SAVE_REI);
00155 if (status < 0) {
00156 rodsLog (LOG_ERROR,
00157 "getVaultPathPolicy: rule acSetVaultPathPolicy error, status = %d",
00158 status);
00159 return (status);
00160 }
00161
00162 if ((msParam = getMsParamByLabel (&rei.inOutMsParamArray,
00163 VAULT_PATH_POLICY)) == NULL) {
00164
00165 outVaultPathPolicy->scheme = DEF_VAULT_PATH_SCHEME;
00166 outVaultPathPolicy->addUserName = DEF_ADD_USER_FLAG;
00167 outVaultPathPolicy->trimDirCnt = DEF_TRIM_DIR_CNT;
00168 } else {
00169 *outVaultPathPolicy = *((vaultPathPolicy_t *) msParam->inOutStruct);
00170 clearMsParamArray (&rei.inOutMsParamArray, 1);
00171 }
00172
00173 if (outVaultPathPolicy->trimDirCnt > DEF_TRIM_DIR_CNT)
00174 outVaultPathPolicy->trimDirCnt = DEF_TRIM_DIR_CNT;
00175
00176 return (0);
00177 }
00178
00179 int
00180 setPathForRandomScheme (char *objPath, const char *vaultPath, char *userName,
00181 char *outPath)
00182 {
00183 int myRandom;
00184 int dir1, dir2;
00185 char logicalCollName[MAX_NAME_LEN];
00186 char logicalFileName[MAX_NAME_LEN];
00187 int status;
00188
00189 myRandom = random ();
00190 dir1 = myRandom & 0xf;
00191 dir2 = (myRandom >> 4) & 0xf;
00192
00193 status = splitPathByKey(objPath,
00194 logicalCollName, logicalFileName, '/');
00195
00196 if (status < 0) {
00197 rodsLog (LOG_ERROR,
00198 "setPathForRandomScheme: splitPathByKey error for %s, status = %d",
00199 outPath, status);
00200 return (status);
00201 }
00202
00203 snprintf (outPath, MAX_NAME_LEN,
00204 "%s/%s/%d/%d/%s.%d", vaultPath, userName, dir1, dir2,
00205 logicalFileName, (uint) time (NULL));
00206 return (0);
00207 }
00208
00209 int
00210 setPathForGraftPathScheme (char *objPath, const char *vaultPath, int addUserName,
00211 char *userName, int trimDirCnt, char *outPath)
00212 {
00213 int i;
00214 char *objPathPtr, *tmpPtr;
00215 int len;
00216
00217 objPathPtr = objPath + 1;
00218
00219 for (i = 0; i < trimDirCnt; i++) {
00220 tmpPtr = strchr (objPathPtr, '/');
00221 if (tmpPtr == NULL) {
00222 rodsLog (LOG_ERROR,
00223 "setPathForGraftPathScheme: objPath %s too short", objPath);
00224 break;
00225 } else {
00226
00227 objPathPtr = tmpPtr + 1;
00228
00229 if (i == 0 && strncmp (objPathPtr, "trash/", 6) == 0) break;
00230 }
00231 }
00232
00233 if (addUserName > 0 && userName != NULL) {
00234 len = snprintf (outPath, MAX_NAME_LEN,
00235 "%s/%s/%s", vaultPath, userName, objPathPtr);
00236 } else {
00237 len = snprintf (outPath, MAX_NAME_LEN,
00238 "%s/%s", vaultPath, objPathPtr);
00239 }
00240
00241 if (len >= MAX_NAME_LEN) {
00242 rodsLog (LOG_ERROR,
00243 "setPathForGraftPathScheme: filePath %s too long", objPath);
00244 return (USER_STRLEN_TOOLONG);
00245 } else {
00246 return (0);
00247 }
00248 }
00249
00250
00251
00252
00253
00254 int
00255 resolveDupFilePath (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00256 dataObjInp_t *dataObjInp)
00257 {
00258 char tmpStr[NAME_LEN];
00259 char *filePath;
00260
00261 if (getSizeInVault (rsComm, dataObjInfo) == SYS_PATH_IS_NOT_A_FILE) {
00262
00263 return (SYS_PATH_IS_NOT_A_FILE);
00264 }
00265 if (chkAndHandleOrphanFile (rsComm, dataObjInfo->objPath, dataObjInfo->rescHier, dataObjInfo->filePath,
00266 dataObjInfo->rescInfo, dataObjInfo->replStatus) >= 0) {
00267
00268 return 0;
00269 }
00270
00271 if (dataObjInp != NULL) {
00272 filePath = getValByKey (&dataObjInp->condInput, FILE_PATH_KW);
00273 if (filePath != NULL && strlen (filePath) > 0) {
00274 return -1;
00275 }
00276 }
00277
00278 if (strlen (dataObjInfo->filePath) >= MAX_NAME_LEN - 3) {
00279 return -1;
00280 }
00281
00282 snprintf (tmpStr, NAME_LEN, ".%d", dataObjInfo->replNum);
00283 strcat (dataObjInfo->filePath, tmpStr);
00284
00285 return (0);
00286 }
00287
00288 int
00289 getchkPathPerm (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00290 dataObjInfo_t *dataObjInfo)
00291 {
00292 int chkPathPerm;
00293 char *filePath;
00294 rescInfo_t *rescInfo;
00295 ruleExecInfo_t rei;
00296
00297 if (rsComm->clientUser.authInfo.authFlag == LOCAL_PRIV_USER_AUTH) {
00298 return (NO_CHK_PATH_PERM);
00299 }
00300
00301 if (dataObjInp == NULL || dataObjInfo == NULL) {
00302 return (NO_CHK_PATH_PERM);
00303 }
00304
00305 rescInfo = dataObjInfo->rescInfo;
00306
00307 if ((filePath = getValByKey (&dataObjInp->condInput, FILE_PATH_KW)) != NULL
00308 && strlen (filePath) > 0) {
00309
00310 if (rescInfo == NULL) {
00311 chkPathPerm = NO_CHK_PATH_PERM;
00312 } else {
00313 initReiWithDataObjInp (&rei, rsComm, dataObjInp);
00314 rei.doi = dataObjInfo;
00315
00316
00317 rei.status = DISALLOW_PATH_REG;
00318 applyRule ("acSetChkFilePathPerm", NULL, &rei, NO_SAVE_REI);
00319
00320 int chk_path = 0;
00321 eirods::error err = eirods::get_resource_property< int >( rescInfo->rescName, "check_path_perm", chk_path );
00322 if( !err.ok() ) {
00323 eirods::log( PASS( err ) );
00324 }
00325
00326 if( err.ok() && ( rei.status == NO_CHK_PATH_PERM || NO_CHK_PATH_PERM == chk_path ) ) {
00327
00328 chkPathPerm = NO_CHK_PATH_PERM;
00329 } else {
00330 chkPathPerm = rei.status;
00331
00332 }
00333 }
00334 } else {
00335 chkPathPerm = NO_CHK_PATH_PERM;
00336 }
00337 return (chkPathPerm);
00338 }
00339
00340 int
00341 getCopiesFromCond (keyValPair_t *condInput)
00342 {
00343 char *myValue;
00344
00345 myValue = getValByKey (condInput, COPIES_KW);
00346
00347 if (myValue == NULL) {
00348 return (1);
00349 } else if (strcmp (myValue, "all") == 0) {
00350 return (ALL_COPIES);
00351 } else {
00352 return (atoi (myValue));
00353 }
00354 }
00355
00356 int
00357 getWriteFlag (int openFlag)
00358 {
00359 if (openFlag & O_WRONLY || openFlag & O_RDWR) {
00360 return (1);
00361 } else {
00362 return (0);
00363 }
00364 }
00365
00366 rodsLong_t
00367 getSizeInVault (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo)
00368 {
00369 rodsStat_t *myStat = NULL;
00370 int status;
00371 rodsLong_t mysize;
00372
00373 status = l3Stat (rsComm, dataObjInfo, &myStat);
00374
00375 if (status < 0 || NULL == myStat) {
00376 rodsLog (LOG_DEBUG,
00377 "getSizeInVault: l3Stat error for %s. status = %d",
00378 dataObjInfo->filePath, status);
00379 return (status);
00380 } else {
00381 if (myStat->st_mode & S_IFDIR) {
00382 return ((rodsLong_t) SYS_PATH_IS_NOT_A_FILE);
00383 }
00384 mysize = myStat->st_size;
00385 free (myStat);
00386 return (mysize);
00387 }
00388 }
00389
00390 int
00391 _dataObjChksum ( rsComm_t *rsComm, dataObjInfo_t *inpDataObjInfo, char **chksumStr)
00392 {
00393 fileChksumInp_t fileChksumInp;
00394 int rescClass = 0;
00395 int status = 0;
00396
00397
00398 dataObjInfo_t *dataObjInfo;
00399 rescInfo_t *rescInfo = inpDataObjInfo->rescInfo;
00400 int destL1descInx = -1;
00401
00402 #if 0 // JMC - removing compound resources
00403 if (rescClass == COMPOUND_CL) {
00404 #if 0
00405 return SYS_CANT_CHKSUM_COMP_RESC_DATA;
00406 #else
00407 dataObjInp_t dataObjInp;
00408 status = getCacheRescInGrp (rsComm, inpDataObjInfo->rescGroupName,inpDataObjInfo->rescInfo, &cacheResc);
00409 if (status < 0) {
00410 rodsLog (LOG_ERROR,
00411 "_dataObjChksum: getCacheRescInGrp %s failed for %s stat=%d",
00412 inpDataObjInfo->rescGroupName, inpDataObjInfo->objPath, status);
00413 return status;
00414 }
00415
00416 memset (&dataObjInp, 0, sizeof (dataObjInp_t));
00417 snprintf (dataObjInp.objPath, MAX_NAME_LEN, "%s.%-d",
00418 inpDataObjInfo->objPath, (int) random());
00419 addKeyVal (&dataObjInp.condInput, DEST_RESC_NAME_KW,
00420 cacheResc->rescName);
00421 addKeyVal (&dataObjInp.condInput, NO_OPEN_FLAG_KW, "");
00422 destL1descInx = _rsDataObjCreate (rsComm, &dataObjInp);
00423 clearKeyVal (&dataObjInp.condInput);
00424 if (destL1descInx < 0) {
00425 rodsLogError (LOG_ERROR, destL1descInx,
00426 "_dataObjChksum: _rsDataObjCreate failed for %s",
00427 inpDataObjInfo->objPath);
00428 return destL1descInx;
00429 }
00430 dataObjInfo = L1desc[destL1descInx].dataObjInfo;
00431 rescInfo = cacheResc;
00432 status = _l3FileStage (rsComm, inpDataObjInfo, dataObjInfo,
00433 getFileMode (NULL));
00434 if (status < 0) {
00435 rodsLogError (LOG_ERROR, status,
00436 "_dataObjChksum: _l3FileStage failed for %s",
00437 dataObjInfo->objPath);
00438 return destL1descInx;
00439 }
00440 #endif
00441 } else if (rescClass == BUNDLE_CL) {
00442 return SYS_CANT_CHKSUM_BUNDLED_DATA;
00443 } else
00444 #endif // JMC
00445
00446 if (rescClass == BUNDLE_CL) {
00447 return SYS_CANT_CHKSUM_BUNDLED_DATA;
00448 } else {
00449 dataObjInfo = inpDataObjInfo;
00450 }
00451
00452
00453 int category = 0;
00454 eirods::error err = eirods::get_resource_property< int >( rescInfo->rescName, "category", category );
00455 if( !err.ok() ) {
00456 eirods::log( PASS( err ) );
00457 }
00458
00459 std::string location;
00460 eirods::error ret;
00461
00462 switch( category ) {
00463 case FILE_CAT:
00464
00465
00466 ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00467 if( !ret.ok() ) {
00468 eirods::log( PASSMSG( "_dataObjChksum - failed in get_loc_for_hier_string", ret ) );
00469 return -1;
00470 }
00471
00472 memset (&fileChksumInp, 0, sizeof (fileChksumInp));
00473 fileChksumInp.fileType = static_cast< fileDriverType_t >( -1 );
00474 rstrcpy (fileChksumInp.addr.hostAddr, location.c_str(),NAME_LEN);
00475 rstrcpy (fileChksumInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
00476 rstrcpy (fileChksumInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00477 rstrcpy (fileChksumInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00478 fileChksumInp.in_pdmo = dataObjInfo->in_pdmo;
00479 status = rsFileChksum (rsComm, &fileChksumInp, chksumStr);
00480 break;
00481 default:
00482 rodsLog (LOG_NOTICE,
00483 "_dataObjChksum: rescCat type %d is not recognized", category );
00484 status = SYS_INVALID_RESC_TYPE;
00485 break;
00486 }
00487
00488
00489 if (destL1descInx >= 0) {
00490 l3Unlink (rsComm, L1desc[destL1descInx].dataObjInfo);
00491 freeL1desc (destL1descInx);
00492 }
00493
00494 return (status);
00495 }
00496
00497 int
00498 dataObjChksumAndReg (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00499 char **chksumStr)
00500 {
00501 keyValPair_t regParam;
00502 modDataObjMeta_t modDataObjMetaInp;
00503 int status;
00504
00505 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00506 if (status < 0) {
00507 rodsLog (LOG_NOTICE,
00508 "dataObjChksumAndReg: _dataObjChksum error for %s, status = %d",
00509 dataObjInfo->objPath, status);
00510 return (status);
00511 }
00512
00513
00514 memset (®Param, 0, sizeof (regParam));
00515 addKeyVal (®Param, CHKSUM_KW, *chksumStr);
00516
00517 modDataObjMetaInp.dataObjInfo = dataObjInfo;
00518 modDataObjMetaInp.regParam = ®Param;
00519
00520 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00521
00522 clearKeyVal (®Param);
00523
00524 if (status < 0) {
00525 rodsLog (LOG_NOTICE,
00526 "dataObjChksumAndReg: rsModDataObjMeta error for %s, status = %d",
00527 dataObjInfo->objPath, status);
00528
00529 }
00530
00531 return (0);
00532 }
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543 int
00544 chkAndHandleOrphanFile (rsComm_t *rsComm, char* objPath, char* rescHier, char *filePath, rescInfo_t *rescInfo,
00545 int replStatus)
00546 {
00547
00548 fileRenameInp_t fileRenameInp;
00549 int status;
00550 dataObjInfo_t myDataObjInfo;
00551
00552 int category = 0;
00553 eirods::error err = eirods::get_resource_property< int >( rescInfo->rescName, "category", category );
00554 if( !err.ok() ) {
00555 eirods::log( PASS( err ) );
00556 }
00557
00558
00559 if( FILE_CAT != category ) {
00560
00561 return (-1);
00562 }
00563
00564 if (strlen (filePath) + 17 >= MAX_NAME_LEN) {
00565
00566 return (-1);
00567 }
00568
00569
00570
00571 memset (&myDataObjInfo, 0, sizeof (myDataObjInfo));
00572 memset (&fileRenameInp, 0, sizeof (fileRenameInp));
00573 if ((status = chkOrphanFile (rsComm, filePath, rescInfo->rescName, &myDataObjInfo)) == 0) {
00574 rstrcpy (fileRenameInp.oldFileName, filePath, MAX_NAME_LEN);
00575 rstrcpy (fileRenameInp.rescHier, rescHier, MAX_NAME_LEN);
00576 rstrcpy(fileRenameInp.objPath, objPath, MAX_NAME_LEN);
00577
00578
00579 if (replStatus > OLD_COPY || isTrashPath (myDataObjInfo.objPath)) {
00580 modDataObjMeta_t modDataObjMetaInp;
00581 keyValPair_t regParam;
00582
00583
00584
00585 status = renameFilePathToNewDir (rsComm, REPL_DIR, &fileRenameInp,
00586 rescInfo, 1);
00587 if (status < 0) {
00588 return (status);
00589 }
00590
00591 memset (®Param, 0, sizeof (regParam));
00592 addKeyVal (®Param, FILE_PATH_KW, fileRenameInp.newFileName);
00593 modDataObjMetaInp.dataObjInfo = &myDataObjInfo;
00594 modDataObjMetaInp.regParam = ®Param;
00595 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00596 clearKeyVal (®Param);
00597 if (status < 0) {
00598 rodsLog (LOG_ERROR,
00599 "chkAndHandleOrphan: rsModDataObjMeta of %s error. stat = %d",
00600 fileRenameInp.newFileName, status);
00601
00602 rstrcpy (fileRenameInp.oldFileName, fileRenameInp.newFileName,
00603 MAX_NAME_LEN);
00604 rstrcpy (fileRenameInp.newFileName, filePath, MAX_NAME_LEN);
00605 rstrcpy(fileRenameInp.rescHier, myDataObjInfo.rescHier, MAX_NAME_LEN);
00606 status = rsFileRename (rsComm, &fileRenameInp);
00607
00608 if (status < 0) {
00609 rodsLog (LOG_ERROR,
00610 "chkAndHandleOrphan: rsFileRename %s failed, status = %d",
00611 fileRenameInp.oldFileName, status);
00612 return (status);
00613 }
00614
00615 return (-1);
00616 } else {
00617 return (0);
00618 }
00619 } else {
00620
00621
00622 rstrcpy (fileRenameInp.oldFileName, filePath, MAX_NAME_LEN);
00623 status = renameFilePathToNewDir (rsComm, REPL_DIR, &fileRenameInp,
00624 rescInfo, 0);
00625 if (status >= 0) {
00626 rstrcpy (filePath, fileRenameInp.newFileName, MAX_NAME_LEN);
00627 return (0);
00628 } else {
00629 return (status);
00630 }
00631 }
00632
00633 } else if (status > 0) {
00634
00635 rstrcpy (fileRenameInp.oldFileName, filePath, MAX_NAME_LEN);
00636 rstrcpy (fileRenameInp.rescHier, rescHier, MAX_NAME_LEN);
00637 rstrcpy (fileRenameInp.objPath, objPath, MAX_NAME_LEN);
00638 status = renameFilePathToNewDir (rsComm, ORPHAN_DIR, &fileRenameInp,
00639 rescInfo, 1);
00640 if (status >= 0) {
00641 return (1);
00642 } else {
00643 return (status);
00644 }
00645 } else {
00646
00647 return (status);
00648 }
00649 }
00650
00651 int
00652 renameFilePathToNewDir (rsComm_t *rsComm, char *newDir,
00653 fileRenameInp_t *fileRenameInp, rescInfo_t *rescInfo, int renameFlag)
00654 {
00655 int len, status;
00656 char *oldPtr, *newPtr;
00657 char *filePath = fileRenameInp->oldFileName;
00658
00659
00660
00661 std::string location;
00662 eirods::error ret = eirods::get_loc_for_hier_string( fileRenameInp->rescHier, location );
00663 if( !ret.ok() ) {
00664 eirods::log( PASSMSG( "renameFilePathToNewDir - failed in get_loc_for_hier_string", ret ) );
00665 return -1;
00666 }
00667
00668 rstrcpy (fileRenameInp->addr.hostAddr, location.c_str(), NAME_LEN);
00669
00670 len = strlen (rescInfo->rescVaultPath);
00671
00672 if (len <= 0) {
00673 return (-1);
00674 }
00675
00676 if (strncmp (filePath, rescInfo->rescVaultPath, len) != 0) {
00677
00678 return -1;
00679 }
00680
00681 rstrcpy (fileRenameInp->newFileName, rescInfo->rescVaultPath, MAX_NAME_LEN);
00682 oldPtr = filePath + len;
00683 newPtr = fileRenameInp->newFileName + len;
00684
00685 snprintf (newPtr, MAX_NAME_LEN - len, "/%s%s.%-d", newDir, oldPtr,
00686 (uint) random());
00687
00688 if (renameFlag > 0) {
00689 status = rsFileRename (rsComm, fileRenameInp);
00690 if (status < 0) {
00691 rodsLog (LOG_NOTICE,
00692 "renameFilePathToNewDir:rsFileRename from %s to %s failed,stat=%d",
00693 filePath, fileRenameInp->newFileName, status);
00694 return -1;
00695 } else {
00696 return (0);
00697 }
00698 } else {
00699 return (0);
00700 }
00701 }
00702
00703
00704
00705
00706
00707
00708 int
00709 syncDataObjPhyPath (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00710 dataObjInfo_t *dataObjInfoHead, char *acLCollection)
00711 {
00712 dataObjInfo_t *tmpDataObjInfo;
00713 int status;
00714 int savedStatus = 0;
00715
00716 tmpDataObjInfo = dataObjInfoHead;
00717 while (tmpDataObjInfo != NULL) {
00718 status = syncDataObjPhyPathS( rsComm, dataObjInp, tmpDataObjInfo, acLCollection );
00719
00720 if (status < 0) {
00721 savedStatus = status;
00722 }
00723
00724 tmpDataObjInfo = tmpDataObjInfo->next;
00725 }
00726
00727 return (savedStatus);
00728 }
00729
00730 int
00731 syncDataObjPhyPathS (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00732 dataObjInfo_t *dataObjInfo, char *acLCollection)
00733 {
00734 int status, status1;
00735 fileRenameInp_t fileRenameInp;
00736 rescInfo_t *rescInfo = 0;
00737 modDataObjMeta_t modDataObjMetaInp;
00738 keyValPair_t regParam;
00739 vaultPathPolicy_t vaultPathPolicy;
00740
00741 if (strcmp (dataObjInfo->rescInfo->rescName, BUNDLE_RESC) == 0)
00742 return 0;
00743
00744 int create_path = 0;
00745 eirods::error err = eirods::get_resource_property< int >( dataObjInfo->rescInfo->rescName, "create_path", create_path );
00746 if( !err.ok() ) {
00747 eirods::log( PASS( err ) );
00748 }
00749
00750
00751 if( NO_CREATE_PATH == create_path ) {
00752
00753 return 0;
00754 }
00755
00756 status = getVaultPathPolicy (rsComm, dataObjInfo, &vaultPathPolicy);
00757 if (status < 0) {
00758 rodsLog (LOG_NOTICE,
00759 "syncDataObjPhyPathS: getVaultPathPolicy error for %s, status = %d",
00760 dataObjInfo->objPath, status);
00761 } else {
00762 if (vaultPathPolicy.scheme != GRAFT_PATH_S) {
00763
00764 return (0);
00765 }
00766 }
00767
00768 if (isInVault (dataObjInfo) == 0) {
00769
00770 return (0);
00771 }
00772
00773 if (dataObjInfo->rescInfo->rescStatus == INT_RESC_STATUS_DOWN)
00774 return SYS_RESC_IS_DOWN;
00775
00776
00777
00778 std::string location;
00779 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00780 if( !ret.ok() ) {
00781 eirods::log( PASSMSG( "syncDataObjPhyPathS - failed in get_loc_for_hier_string", ret ) );
00782 return -1;
00783 }
00784
00785
00786 memset (&fileRenameInp, 0, sizeof (fileRenameInp));
00787 rstrcpy (fileRenameInp.oldFileName, dataObjInfo->filePath, MAX_NAME_LEN);
00788 rstrcpy (fileRenameInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00789 rstrcpy(fileRenameInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00790 if (dataObjInp == NULL) {
00791 dataObjInp_t myDdataObjInp;
00792 memset (&myDdataObjInp, 0, sizeof (myDdataObjInp));
00793 rstrcpy (myDdataObjInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00794 status = getFilePathName (rsComm, dataObjInfo, &myDdataObjInp);
00795 } else {
00796 status = getFilePathName (rsComm, dataObjInfo, dataObjInp);
00797 }
00798
00799 if (strcmp (fileRenameInp.oldFileName, dataObjInfo->filePath) == 0) {
00800 return (0);
00801 }
00802
00803 rescInfo = dataObjInfo->rescInfo;
00804
00805 if (getSizeInVault (rsComm, dataObjInfo) >= 0) {
00806 if (chkAndHandleOrphanFile (rsComm, dataObjInfo->objPath, dataObjInfo->rescHier,
00807 dataObjInfo->filePath, rescInfo, OLD_COPY) <= 0) {
00808 rodsLog (LOG_ERROR,
00809 "syncDataObjPhyPath:newFileName %s already in use",
00810 dataObjInfo->filePath);
00811 return (SYS_PHY_PATH_INUSE);
00812 }
00813 }
00814
00815
00816
00817 rstrcpy (fileRenameInp.addr.hostAddr, location.c_str(), NAME_LEN);
00818 rstrcpy (fileRenameInp.newFileName, dataObjInfo->filePath,
00819 MAX_NAME_LEN);
00820 status = rsFileRename (rsComm, &fileRenameInp);
00821 if (status < 0) {
00822 rodsLog (LOG_ERROR,
00823 "syncDataObjPhyPath:rsFileRename from %s to %s failed,status=%d",
00824 fileRenameInp.oldFileName, fileRenameInp.newFileName, status);
00825 return (status);
00826 }
00827
00828
00829 memset (®Param, 0, sizeof (regParam));
00830 addKeyVal (®Param, FILE_PATH_KW, fileRenameInp.newFileName);
00831 if (acLCollection != NULL)
00832 addKeyVal (®Param, ACL_COLLECTION_KW, acLCollection);
00833 modDataObjMetaInp.dataObjInfo = dataObjInfo;
00834 modDataObjMetaInp.regParam = ®Param;
00835 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00836 clearKeyVal (®Param);
00837 if (status < 0) {
00838 char tmpPath[MAX_NAME_LEN];
00839 rodsLog (LOG_ERROR,
00840 "syncDataObjPhyPath: rsModDataObjMeta of %s error. stat = %d",
00841 fileRenameInp.newFileName, status);
00842
00843 rstrcpy (tmpPath, fileRenameInp.oldFileName, MAX_NAME_LEN);
00844 rstrcpy (fileRenameInp.oldFileName, fileRenameInp.newFileName,
00845 MAX_NAME_LEN);
00846 rstrcpy (fileRenameInp.newFileName, tmpPath, MAX_NAME_LEN);
00847 status1 = rsFileRename (rsComm, &fileRenameInp);
00848
00849 if (status1 < 0) {
00850 rodsLog (LOG_ERROR,
00851 "syncDataObjPhyPath: rollback rename %s failed, status = %d",
00852 fileRenameInp.oldFileName, status1);
00853 }
00854 return (status);
00855 }
00856 return (0);
00857 }
00858
00859
00860
00861
00862
00863
00864 int
00865 syncCollPhyPath (rsComm_t *rsComm, char *collection)
00866 {
00867 int status, i;
00868 int savedStatus = 0;
00869 genQueryOut_t *genQueryOut = NULL;
00870 genQueryInp_t genQueryInp;
00871 int continueInx;
00872
00873 status = rsQueryDataObjInCollReCur (rsComm, collection,
00874 &genQueryInp, &genQueryOut, NULL, 0);
00875
00876 if (status<0 && status != CAT_NO_ROWS_FOUND) {
00877 savedStatus=status;
00878 }
00879
00880 while (status >= 0) {
00881 sqlResult_t *dataIdRes, *subCollRes, *dataNameRes, *replNumRes,
00882 *rescNameRes, *filePathRes, *rescHierRes;
00883 char *tmpDataId, *tmpDataName, *tmpSubColl, *tmpReplNum,
00884 *tmpRescName, *tmpFilePath, *tmpRescHier;
00885 dataObjInfo_t dataObjInfo;
00886
00887 memset (&dataObjInfo, 0, sizeof (dataObjInfo));
00888
00889 if ((dataIdRes = getSqlResultByInx (genQueryOut, COL_D_DATA_ID))
00890 == NULL) {
00891 rodsLog (LOG_ERROR,
00892 "syncCollPhyPath: getSqlResultByInx for COL_COLL_NAME failed");
00893 return (UNMATCHED_KEY_OR_INDEX);
00894 }
00895 if ((subCollRes = getSqlResultByInx (genQueryOut, COL_COLL_NAME))
00896 == NULL) {
00897 rodsLog (LOG_ERROR,
00898 "syncCollPhyPath: getSqlResultByInx for COL_COLL_NAME failed");
00899 return (UNMATCHED_KEY_OR_INDEX);
00900 }
00901 if ((dataNameRes = getSqlResultByInx (genQueryOut, COL_DATA_NAME))
00902 == NULL) {
00903 rodsLog (LOG_ERROR,
00904 "syncCollPhyPath: getSqlResultByInx for COL_DATA_NAME failed");
00905 return (UNMATCHED_KEY_OR_INDEX);
00906 }
00907 if ((replNumRes = getSqlResultByInx (genQueryOut, COL_DATA_REPL_NUM))
00908 == NULL) {
00909 rodsLog (LOG_ERROR,
00910 "syncCollPhyPath:getSqlResultByIn for COL_DATA_REPL_NUM failed");
00911 return (UNMATCHED_KEY_OR_INDEX);
00912 }
00913 if ((rescNameRes = getSqlResultByInx (genQueryOut, COL_D_RESC_NAME))
00914 == NULL) {
00915 rodsLog (LOG_ERROR,
00916 "syncCollPhyPath: getSqlResultByInx for COL_D_RESC_NAME failed");
00917 return (UNMATCHED_KEY_OR_INDEX);
00918 }
00919 if ((filePathRes = getSqlResultByInx (genQueryOut, COL_D_DATA_PATH))
00920 == NULL) {
00921 rodsLog (LOG_ERROR,
00922 "syncCollPhyPath: getSqlResultByInx for COL_D_DATA_PATH failed");
00923 return (UNMATCHED_KEY_OR_INDEX);
00924 }
00925 if ((rescHierRes = getSqlResultByInx (genQueryOut, COL_D_RESC_HIER))
00926 == NULL) {
00927 rodsLog (LOG_ERROR,
00928 "syncCollPhyPath: getSqlResultByInx for COL_D_RESC_HIER failed");
00929 return (UNMATCHED_KEY_OR_INDEX);
00930 }
00931
00932 for (i = 0;i < genQueryOut->rowCnt; i++) {
00933 tmpDataId = &dataIdRes->value[dataIdRes->len * i];
00934 tmpDataName = &dataNameRes->value[dataNameRes->len * i];
00935 tmpSubColl = &subCollRes->value[subCollRes->len * i];
00936 tmpReplNum = &replNumRes->value[replNumRes->len * i];
00937 tmpRescName = &rescNameRes->value[rescNameRes->len * i];
00938 tmpFilePath = &filePathRes->value[filePathRes->len * i];
00939 tmpRescHier = &rescHierRes->value[rescHierRes->len * i];
00940
00941 dataObjInfo.dataId = strtoll (tmpDataId, 0, 0);
00942 snprintf (dataObjInfo.objPath, MAX_NAME_LEN, "%s/%s",
00943 tmpSubColl, tmpDataName);
00944 dataObjInfo.replNum = atoi (tmpReplNum);
00945 rstrcpy (dataObjInfo.rescName, tmpRescName, NAME_LEN);
00946 rstrcpy (dataObjInfo.rescHier, tmpRescHier, MAX_NAME_LEN);
00947
00948
00949
00950
00951
00952
00953
00954 dataObjInfo.rescInfo = new rescInfo_t;
00955 eirods::error err = eirods::get_resc_info( tmpRescName, *dataObjInfo.rescInfo );
00956 if( !err.ok() ) {
00957 std::stringstream msg;
00958 msg << "getDefaultLocalRescInfo - failed to get resource info";
00959 msg << tmpRescName;
00960 eirods::log( PASS( err ) );
00961 }
00962
00963 rstrcpy (dataObjInfo.filePath, tmpFilePath, MAX_NAME_LEN);
00964
00965 status = syncDataObjPhyPathS (rsComm, NULL, &dataObjInfo,
00966 collection);
00967 if (status < 0) {
00968 rodsLog (LOG_ERROR,
00969 "syncCollPhyPath: syncDataObjPhyPathS error for %s,stat=%d",
00970 dataObjInfo.filePath, status);
00971 savedStatus = status;
00972 }
00973
00974 }
00975
00976 continueInx = genQueryOut->continueInx;
00977
00978 freeGenQueryOut (&genQueryOut);
00979
00980 if (continueInx > 0) {
00981
00982 genQueryInp.continueInx = continueInx;
00983 status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00984 } else {
00985 break;
00986 }
00987 }
00988 clearGenQueryInp (&genQueryInp);
00989
00990 return (savedStatus);
00991 }
00992
00993 int
00994 isInVault (dataObjInfo_t *dataObjInfo)
00995 {
00996 int len;
00997
00998 if (dataObjInfo == NULL || dataObjInfo->rescInfo == NULL) {
00999 return (SYS_INTERNAL_NULL_INPUT_ERR);
01000 }
01001
01002 std::string vault_path;
01003 eirods::error ret = eirods::get_vault_path_for_hier_string(dataObjInfo->rescHier, vault_path);
01004 if(!ret.ok()) {
01005 std::stringstream msg;
01006 msg << __FUNCTION__;
01007 msg << " - Failed to get the vault path for the hierarchy: \"" << dataObjInfo->rescHier << "\"";
01008 ret = PASSMSG(msg.str(), ret);
01009 eirods::log(ret);
01010 return ret.code();
01011 }
01012 len = vault_path.size();
01013
01014 if (strncmp (vault_path.c_str(),
01015 dataObjInfo->filePath, len) == 0) {
01016 return (1);
01017 } else {
01018 return (0);
01019 }
01020 }
01021
01022 #if 0 // JMC - UNUSED
01023
01024
01025
01026
01027 int
01028 initStructFileOprInp (rsComm_t *rsComm,
01029 structFileOprInp_t *structFileOprInp,
01030 structFileExtAndRegInp_t *structFileExtAndRegInp,
01031 dataObjInfo_t *dataObjInfo)
01032 {
01033 int status;
01034 vaultPathPolicy_t vaultPathPolicy;
01035 int addUserNameFlag;
01036
01037 memset (structFileOprInp, 0, sizeof (structFileOprInp_t));
01038 structFileOprInp->specColl = (specColl_t*)malloc (sizeof (specColl_t));
01039 memset (structFileOprInp->specColl, 0, sizeof (specColl_t));
01040 if( strcmp (dataObjInfo->dataType, TAR_DT_STR) == 0 ||
01041 strstr (dataObjInfo->dataType, BUNDLE_STR) == 0) {
01042 structFileOprInp->specColl->type = TAR_STRUCT_FILE_T;
01043 } else if (strcmp (dataObjInfo->dataType, HAAW_DT_STR) == 0) {
01044 structFileOprInp->specColl->type = HAAW_STRUCT_FILE_T;
01045 } else {
01046 rodsLog (LOG_ERROR,
01047 "initStructFileOprInp: objType %s of %s is not a struct file",
01048 dataObjInfo->dataType, dataObjInfo->objPath);
01049 return SYS_OBJ_TYPE_NOT_STRUCT_FILE;
01050 }
01051
01052 rstrcpy (structFileOprInp->specColl->collection,
01053 structFileExtAndRegInp->collection, MAX_NAME_LEN);
01054 rstrcpy (structFileOprInp->specColl->objPath,
01055 structFileExtAndRegInp->objPath, MAX_NAME_LEN);
01056 structFileOprInp->specColl->collClass = STRUCT_FILE_COLL;
01057 rstrcpy (structFileOprInp->specColl->resource, dataObjInfo->rescName,
01058 NAME_LEN);
01059 rstrcpy (structFileOprInp->specColl->phyPath,
01060 dataObjInfo->filePath, MAX_NAME_LEN);
01061
01062 NAME_LEN);
01063
01064 status = getVaultPathPolicy (rsComm, dataObjInfo, &vaultPathPolicy);
01065 if (status < 0) {
01066 return (status);
01067 }
01068
01069 if (vaultPathPolicy.scheme == GRAFT_PATH_S) {
01070 addUserNameFlag = vaultPathPolicy.addUserName;
01071 } else {
01072 rodsLog (LOG_ERROR,
01073 "initStructFileOprInp: vaultPathPolicy.scheme %d for resource %s is not GRAFT_PATH_S",
01074 vaultPathPolicy.scheme, structFileOprInp->specColl->resource);
01075 return SYS_WRONG_RESC_POLICY_FOR_BUN_OPR;
01076 }
01077 status = setPathForGraftPathScheme (structFileExtAndRegInp->collection,
01078 dataObjInfo->rescInfo->rescVaultPath, addUserNameFlag,
01079 rsComm->clientUser.userName, vaultPathPolicy.trimDirCnt,
01080 structFileOprInp->specColl->cacheDir);
01081
01082 return (status);
01083 }
01084 #endif // JMC - UNUSED
01085
01086 int
01087 getDefFileMode ()
01088 {
01089 int defFileMode;
01090 char *modeStr;
01091 if ((modeStr = getenv ("DefFileMode")) != NULL && *modeStr == '0') {
01092 defFileMode = strtol (getenv ("DefFileMode"), 0, 0);
01093 } else {
01094 defFileMode = DEFAULT_FILE_MODE;
01095 }
01096 return defFileMode;
01097 }
01098
01099 int
01100 getDefDirMode ()
01101 {
01102 int defDirMode;
01103 char *modeStr;
01104 if ((modeStr = getenv ("DefDirMode")) != NULL && *modeStr == '0') {
01105 defDirMode = strtol (getenv ("DefDirMode"), 0, 0);
01106 } else {
01107 defDirMode = DEFAULT_DIR_MODE;
01108 }
01109 return defDirMode;
01110 }
01111
01112 int
01113 getLogPathFromPhyPath (char *phyPath, rescInfo_t *rescInfo, char *outLogPath)
01114 {
01115 int len;
01116 char *tmpPtr;
01117 zoneInfo_t *tmpZoneInfo = NULL;
01118 int status;
01119
01120 if (phyPath == NULL || rescInfo == NULL || outLogPath == NULL)
01121 return USER__NULL_INPUT_ERR;
01122
01123 len = strlen (rescInfo->rescVaultPath);
01124 if (strncmp (rescInfo->rescVaultPath, phyPath, len) != 0) return -1;
01125 tmpPtr = phyPath + len;
01126
01127 if (*tmpPtr != '/') return -1;
01128
01129 tmpPtr ++;
01130 status = getLocalZoneInfo (&tmpZoneInfo);
01131 if (status < 0 || NULL == tmpZoneInfo ) return status;
01132
01133 len = strlen (tmpZoneInfo->zoneName);
01134 if (strncmp (tmpZoneInfo->zoneName, tmpPtr, len) == 0 &&
01135 *(tmpPtr + len) == '/') {
01136
01137 tmpPtr += (len + 1);
01138 }
01139
01140 snprintf (outLogPath, MAX_NAME_LEN, "/%s/%s", tmpZoneInfo->zoneName,
01141 tmpPtr);
01142
01143 return 0;
01144 }
01145
01146
01147
01148
01149
01150 int
01151 rsMkOrphanPath (rsComm_t *rsComm, char *objPath, char *orphanPath)
01152 {
01153 int status;
01154 char *tmpStr;
01155 char *orphanPathPtr;
01156 int len;
01157 char parentColl[MAX_NAME_LEN], childName[MAX_NAME_LEN];
01158 collInp_t collCreateInp;
01159
01160 status = splitPathByKey(objPath, parentColl, childName, '/');
01161
01162 if (status < 0) {
01163 rodsLog (LOG_ERROR,
01164 "rsMkOrphanPath: splitPathByKey error for %s, status = %d",
01165 objPath, status);
01166 return (status);
01167 }
01168 orphanPathPtr = orphanPath;
01169 *orphanPathPtr = '/';
01170 orphanPathPtr++;
01171 tmpStr = objPath + 1;
01172
01173 while (*tmpStr != '\0') {
01174 *orphanPathPtr = *tmpStr;
01175 orphanPathPtr ++;
01176 len ++;
01177 if (*tmpStr == '/') {
01178 tmpStr ++;
01179 break;
01180 }
01181 tmpStr ++;
01182 }
01183 len = strlen (rsComm->clientUser.userName) +
01184 strlen (rsComm->clientUser.rodsZone);
01185 snprintf (orphanPathPtr, len + 20, "trash/orphan/%s#%s",
01186 rsComm->clientUser.userName, rsComm->clientUser.rodsZone);
01187
01188 memset (&collCreateInp, 0, sizeof (collCreateInp));
01189 rstrcpy (collCreateInp.collName, orphanPath, MAX_NAME_LEN);
01190 status = rsCollCreate (rsComm, &collCreateInp);
01191
01192 if (status < 0 && status != CAT_NAME_EXISTS_AS_COLLECTION) {
01193 rodsLogError (LOG_ERROR, status,
01194 "rsMkOrphanPath: rsCollCreate error for %s",
01195 orphanPath);
01196 }
01197 orphanPathPtr = orphanPath + strlen (orphanPath);
01198
01199 snprintf (orphanPathPtr, strlen (childName) + 20, "/%s.%-d",
01200 childName, (uint) random());
01201
01202 return 0;
01203 }
01204
01205
01206
01207 int
01208 getDataObjLockPath (char *objPath, char **outLockPath)
01209 {
01210 int i;
01211 char *objPathPtr, *tmpPtr;
01212 char tmpPath[MAX_NAME_LEN];
01213 int c;
01214 int len;
01215
01216 if (objPath == NULL || outLockPath == NULL) return USER__NULL_INPUT_ERR;
01217 objPathPtr = objPath;
01218
01219
01220 for (i = 0; i < 3; i++) {
01221 tmpPtr = strchr (objPathPtr, '/');
01222 if (tmpPtr == NULL) {
01223 break;
01224 } else {
01225
01226 objPathPtr = tmpPtr + 1;
01227 }
01228 }
01229 rstrcpy (tmpPath, objPathPtr, MAX_NAME_LEN);
01230
01231 objPathPtr = tmpPath;
01232
01233 while ((c = *objPathPtr) != '\0') {
01234 if (c == '/')
01235 *objPathPtr = '.';
01236 objPathPtr++;
01237 }
01238
01239 len = strlen (getConfigDir()) + strlen (LOCK_FILE_DIR) +
01240 strlen (tmpPath) + strlen (LOCK_FILE_TRAILER) + 10;
01241 *outLockPath = (char *) malloc (len);
01242
01243 snprintf (*outLockPath, len, "%-s/%-s/%-s.%-s", getConfigDir(),
01244 LOCK_FILE_DIR, tmpPath, LOCK_FILE_TRAILER);
01245
01246 return 0;
01247 }
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257 int
01258 fsDataObjLock (char *objPath, int cmd, int type, int infd)
01259 {
01260 int status;
01261 int myFd;
01262 struct flock myflock;
01263 char *path = NULL;
01264
01265 if (type != F_UNLCK) {
01266 if ((status = getDataObjLockPath (objPath, &path)) < 0) {
01267 rodsLogError (LOG_ERROR, status,
01268 "fsDataObjLock: getDataObjLockPath error for %s", objPath);
01269 return status;
01270 }
01271 myFd = open (path, O_RDWR | O_CREAT, 0644);
01272 if (myFd < 0) {
01273 status = FILE_OPEN_ERR - errno;
01274 rodsLogError (LOG_ERROR, status,
01275 "fsDataObjLock: open error for %s", objPath);
01276 return status;
01277 }
01278 } else {
01279 myFd = infd;
01280 }
01281 #ifndef _WIN32
01282 bzero (&myflock, sizeof (myflock));
01283 myflock.l_type = type;
01284 myflock.l_whence = SEEK_SET;
01285 status = fcntl (myFd, cmd, &myflock);
01286 if (status < 0) {
01287
01288
01289 status = SYS_FS_LOCK_ERR - errno;
01290 rodsLogError( LOG_DEBUG, status,"fsDataObjLock: fcntl error for %s, cmd = %d, type = %d",
01291 objPath, cmd, type);
01292
01293 if (path != NULL) free (path);
01294
01295 close (myFd);
01296 return (status);
01297 }
01298 #endif
01299 if (path != NULL) free (path);
01300 if (type == F_UNLCK) {
01301 close (myFd);
01302 myFd = 0;
01303 } else if (cmd == F_GETLK) {
01304
01305 close (myFd);
01306 myFd = myflock.l_type;
01307 }
01308 return (myFd);
01309 }
01310
01311 int
01312 getLeafRescPathName(
01313 const std::string& _resc_hier,
01314 std::string& _ret_string)
01315 {
01316 int result = 0;
01317 eirods::hierarchy_parser hp;
01318 eirods::error ret;
01319 ret = hp.set_string(_resc_hier);
01320 if(!ret.ok()) {
01321 std::stringstream msg;
01322 msg << "Unable to parse hierarchy string: \"" << _resc_hier << "\"";
01323 eirods::log(LOG_ERROR, msg.str());
01324 result = ret.code();
01325 } else {
01326 std::string leaf;
01327 ret = hp.last_resc(leaf);
01328 if(!ret.ok()) {
01329 std::stringstream msg;
01330 msg << "Unable to retrieve last resource from hierarchy string: \"" << _resc_hier << "\"";
01331 eirods::log(LOG_ERROR, msg.str());
01332 result = ret.code();
01333 } else {
01334 ret = eirods::get_resource_property<std::string>(leaf, "path", _ret_string);
01335 if(!ret.ok()) {
01336 std::stringstream msg;
01337 msg << "Unable to get vault path from resource: \"" << leaf << "\"";
01338 eirods::log(LOG_ERROR, msg.str());
01339 result = ret.code();
01340 }
01341 }
01342 }
01343 return result;
01344 }
01345
01346
01347