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