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