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