00001
00002
00003
00004
00005
00006
00007 #include "dataObjOpr.h"
00008 #include "specColl.h"
00009 #include "collection.h"
00010 #include "resource.h"
00011 #include "genQuery.h"
00012 #include "rodsClient.h"
00013
00014
00015
00016 #include "eirods_resource_backport.h"
00017 #include "eirods_stacktrace.h"
00018
00019 static int HaveFailedSpecCollPath = 0;
00020 static char FailedSpecCollPath[MAX_NAME_LEN];
00021
00022
00023
00024
00025
00026
00027
00028 int
00029 querySpecColl (rsComm_t *rsComm, char *objPath, genQueryOut_t **genQueryOut)
00030 {
00031 genQueryInp_t genQueryInp;
00032 int status;
00033 char condStr[MAX_NAME_LEN];
00034
00035 if (HaveFailedSpecCollPath && strcmp (objPath, FailedSpecCollPath) == 0) {
00036 return CAT_NO_ROWS_FOUND;
00037 }
00038
00039
00040 memset (&genQueryInp, 0, sizeof (genQueryInp));
00041
00042 snprintf (condStr, MAX_NAME_LEN, "parent_of '%s'", objPath);
00043 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, condStr);
00044 rstrcpy (condStr, "like '_%'", MAX_NAME_LEN);
00045 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_TYPE, condStr);
00046
00047 addInxIval (&genQueryInp.selectInp, COL_COLL_ID, 1);
00048 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
00049 addInxIval (&genQueryInp.selectInp, COL_COLL_OWNER_NAME, 1);
00050 addInxIval (&genQueryInp.selectInp, COL_COLL_OWNER_ZONE, 1);
00051 addInxIval (&genQueryInp.selectInp, COL_COLL_CREATE_TIME, 1);
00052 addInxIval (&genQueryInp.selectInp, COL_COLL_MODIFY_TIME, 1);
00053 addInxIval (&genQueryInp.selectInp, COL_COLL_TYPE, 1);
00054 addInxIval (&genQueryInp.selectInp, COL_COLL_INFO1, 1);
00055 addInxIval (&genQueryInp.selectInp, COL_COLL_INFO2, 1);
00056
00057 genQueryInp.maxRows = MAX_SQL_ROWS;
00058
00059 status = rsGenQuery (rsComm, &genQueryInp, genQueryOut);
00060
00061 clearGenQueryInp (&genQueryInp);
00062
00063 if (status < 0) {
00064 rstrcpy (FailedSpecCollPath, objPath, MAX_NAME_LEN);
00065 HaveFailedSpecCollPath = 1;
00066 return (status);
00067 }
00068
00069 return (0);
00070 }
00071
00072
00073
00074
00075
00076
00077
00078
00079 int
00080 queueSpecCollCache( rsComm_t *rsComm, genQueryOut_t *genQueryOut, char *objPath )
00081 {
00082 specCollCache_t *tmpSpecCollCache;
00083 int status;
00084 int i;
00085 sqlResult_t *dataId;
00086 sqlResult_t *ownerName;
00087 sqlResult_t *ownerZone;
00088 sqlResult_t *createTime;
00089 sqlResult_t *modifyTime;
00090 sqlResult_t *collType;
00091 sqlResult_t *collection;
00092 sqlResult_t *collInfo1;
00093 sqlResult_t *collInfo2;
00094 char *tmpDataId, *tmpOwnerName, *tmpOwnerZone, *tmpCreateTime,
00095 *tmpModifyTime, *tmpCollType, *tmpCollection, *tmpCollInfo1,
00096 *tmpCollInfo2;
00097 specColl_t *specColl;
00098
00099 if ((dataId = getSqlResultByInx (genQueryOut, COL_COLL_ID)) == NULL) {
00100 rodsLog (LOG_ERROR,
00101 "queueSpecCollCache: getSqlResultByInx for COL_COLL_ID failed");
00102 return (UNMATCHED_KEY_OR_INDEX);
00103 } else if ((ownerName = getSqlResultByInx (genQueryOut,
00104 COL_COLL_OWNER_NAME)) == NULL) {
00105 rodsLog (LOG_ERROR,
00106 "queueSpecCollCache:getSqlResultByInx for COL_COLL_OWNER_NAME failed");
00107 return (UNMATCHED_KEY_OR_INDEX);
00108 } else if ((ownerZone = getSqlResultByInx (genQueryOut,
00109 COL_COLL_OWNER_ZONE)) == NULL) {
00110 rodsLog (LOG_ERROR,
00111 "queueSpecCollCache:getSqlResultByInx for COL_COLL_OWNER_ZONE failed");
00112 return (UNMATCHED_KEY_OR_INDEX);
00113 } else if ((createTime = getSqlResultByInx (genQueryOut,
00114 COL_COLL_CREATE_TIME)) == NULL) {
00115 rodsLog (LOG_ERROR,
00116 "queueSpecCollCache:getSqlResultByInx for COL_COLL_CREATE_TIME failed");
00117 return (UNMATCHED_KEY_OR_INDEX);
00118 } else if ((modifyTime = getSqlResultByInx (genQueryOut,
00119 COL_COLL_MODIFY_TIME)) == NULL) {
00120 rodsLog (LOG_ERROR,
00121 "queueSpecCollCache:getSqlResultByInx for COL_COLL_MODIFY_TIME failed");
00122 return (UNMATCHED_KEY_OR_INDEX);
00123 } else if ((collType = getSqlResultByInx (genQueryOut,
00124 COL_COLL_TYPE)) == NULL) {
00125 rodsLog (LOG_ERROR,
00126 "queueSpecCollCache:getSqlResultByInx for COL_COLL_TYPE failed");
00127 return (UNMATCHED_KEY_OR_INDEX);
00128 } else if ((collection = getSqlResultByInx (genQueryOut,
00129 COL_COLL_NAME)) == NULL) {
00130 rodsLog (LOG_ERROR,
00131 "queueSpecCollCache:getSqlResultByInx for COL_COLL_NAME failed");
00132 return (UNMATCHED_KEY_OR_INDEX);
00133 } else if ((collInfo1 = getSqlResultByInx (genQueryOut,
00134 COL_COLL_INFO1)) == NULL) {
00135 rodsLog (LOG_ERROR,
00136 "queueSpecCollCache:getSqlResultByInx for COL_COLL_INFO1 failed");
00137 return (UNMATCHED_KEY_OR_INDEX);
00138 } else if ((collInfo2 = getSqlResultByInx (genQueryOut,
00139 COL_COLL_INFO2)) == NULL) {
00140 rodsLog (LOG_ERROR,
00141 "queueSpecCollCache:getSqlResultByInx for COL_COLL_INFO2 failed");
00142 return (UNMATCHED_KEY_OR_INDEX);
00143 }
00144
00145 for (i = 0; i <= genQueryOut->rowCnt; i++) {
00146 int len;
00147 char *tmpPtr;
00148
00149 tmpCollection = &collection->value[collection->len * i];
00150
00151 len = strlen (tmpCollection);
00152 tmpPtr = objPath + len;
00153
00154 if (*tmpPtr == '\0' || *tmpPtr == '/') {
00155 tmpSpecCollCache = (specCollCache_t*)malloc (sizeof (specCollCache_t));
00156 memset (tmpSpecCollCache, 0, sizeof (specCollCache_t));
00157
00158 tmpDataId = &dataId->value[dataId->len * i];
00159 tmpOwnerName = &ownerName->value[ownerName->len * i];
00160 tmpOwnerZone = &ownerZone->value[ownerZone->len * i];
00161 tmpCreateTime = &createTime->value[createTime->len * i];
00162 tmpModifyTime = &modifyTime->value[modifyTime->len * i];
00163 tmpCollType = &collType->value[collType->len * i];
00164 tmpCollInfo1 = &collInfo1->value[collInfo1->len * i];
00165 tmpCollInfo2 = &collInfo2->value[collInfo2->len * i];
00166
00167 specColl = &tmpSpecCollCache->specColl;
00168 status = resolveSpecCollType( tmpCollType, tmpCollection,tmpCollInfo1, tmpCollInfo2, specColl );
00169 if( status < 0 ) {
00170 return status;
00171 }
00172
00173
00174
00175 if( specColl->collClass == STRUCT_FILE_COLL &&
00176 specColl->type == TAR_STRUCT_FILE_T ) {
00177
00178 status = getPhyPath( rsComm, specColl->objPath, specColl->resource, specColl->phyPath, specColl->rescHier );
00179 if( status < 0 ) {
00180 rodsLog( LOG_ERROR, "queueSpecCollCache - getPhyPath failed for [%s] on resource [%s] with cache dir [%s] and collection [%s]",
00181 specColl->objPath, specColl->resource, specColl->cacheDir, specColl->collection );
00182 return status;
00183 }
00184 }
00185
00186 rstrcpy (tmpSpecCollCache->collId, tmpDataId, NAME_LEN);
00187 rstrcpy (tmpSpecCollCache->ownerName, tmpOwnerName, NAME_LEN);
00188 rstrcpy (tmpSpecCollCache->ownerZone, tmpOwnerZone, NAME_LEN);
00189 rstrcpy (tmpSpecCollCache->createTime, tmpCreateTime, NAME_LEN);
00190 rstrcpy (tmpSpecCollCache->modifyTime, tmpModifyTime, NAME_LEN);
00191 tmpSpecCollCache->next = SpecCollCacheHead;
00192 SpecCollCacheHead = tmpSpecCollCache;
00193
00194 return 0;
00195 }
00196 }
00197
00198 return CAT_NO_ROWS_FOUND;
00199 }
00200
00201 int
00202 queueSpecCollCacheWithObjStat (rodsObjStat_t *rodsObjStatOut)
00203 {
00204 specCollCache_t *tmpSpecCollCache;
00205
00206 tmpSpecCollCache = (specCollCache_t*)malloc (sizeof (specCollCache_t));
00207 memset (tmpSpecCollCache, 0, sizeof (specCollCache_t));
00208
00209 tmpSpecCollCache->specColl = *rodsObjStatOut->specColl;
00210
00211 rstrcpy (tmpSpecCollCache->collId, rodsObjStatOut->dataId, NAME_LEN);
00212 rstrcpy (tmpSpecCollCache->ownerName, rodsObjStatOut->ownerName, NAME_LEN);
00213 rstrcpy (tmpSpecCollCache->ownerZone, rodsObjStatOut->ownerZone, NAME_LEN);
00214 rstrcpy (tmpSpecCollCache->createTime, rodsObjStatOut->createTime,
00215 NAME_LEN);
00216 rstrcpy (tmpSpecCollCache->modifyTime, rodsObjStatOut->modifyTime,
00217 NAME_LEN);
00218
00219 tmpSpecCollCache->next = SpecCollCacheHead;
00220 SpecCollCacheHead = tmpSpecCollCache;
00221
00222 return 0;
00223
00224 }
00225
00226 specCollCache_t *
00227 matchSpecCollCache (char *objPath)
00228 {
00229 specCollCache_t *tmpSpecCollCache = SpecCollCacheHead;
00230
00231 while (tmpSpecCollCache != NULL) {
00232 int len = strlen (tmpSpecCollCache->specColl.collection);
00233 if (strncmp (tmpSpecCollCache->specColl.collection, objPath, len)
00234 == 0) {
00235 char *tmpPtr = objPath + len;
00236
00237 if (*tmpPtr == '\0' || *tmpPtr == '/') {
00238 return (tmpSpecCollCache);
00239 }
00240 }
00241 tmpSpecCollCache = tmpSpecCollCache->next;
00242 }
00243 return (NULL);
00244 }
00245
00246 int
00247 getSpecCollCache (rsComm_t *rsComm, char *objPath,
00248 int inCachOnly, specCollCache_t **specCollCache)
00249 {
00250 int status;
00251 genQueryOut_t *genQueryOut = NULL;
00252
00253 if ((*specCollCache = matchSpecCollCache (objPath)) != NULL) {
00254 return (0);
00255 } else if (inCachOnly > 0) {
00256 return (SYS_SPEC_COLL_NOT_IN_CACHE);
00257 }
00258
00259 status = querySpecColl (rsComm, objPath, &genQueryOut);
00260 if (status < 0) return (status);
00261
00262 status = queueSpecCollCache (rsComm, genQueryOut, objPath);
00263 freeGenQueryOut (&genQueryOut);
00264
00265 if (status < 0) return (status);
00266 *specCollCache = SpecCollCacheHead;
00267
00268 return (0);
00269 }
00270
00271 int
00272 modCollInfo2 (rsComm_t *rsComm, specColl_t *specColl, int clearFlag)
00273 {
00274 int status;
00275 char collInfo2[MAX_NAME_LEN];
00276 collInp_t modCollInp;
00277
00278 memset (&modCollInp, 0, sizeof (modCollInp));
00279 rstrcpy (modCollInp.collName, specColl->collection, MAX_NAME_LEN);
00280 addKeyVal (&modCollInp.condInput, COLLECTION_TYPE_KW,
00281 TAR_STRUCT_FILE_STR);
00282 if (clearFlag > 0) {
00283 rstrcpy (collInfo2, "NULL_SPECIAL_VALUE", MAX_NAME_LEN);
00284 } else {
00285 makeCachedStructFileStr (collInfo2, specColl);
00286 }
00287 addKeyVal (&modCollInp.condInput, COLLECTION_INFO2_KW, collInfo2);
00288 status = rsModColl (rsComm, &modCollInp);
00289 if (status < 0) {
00290 rodsLog (LOG_NOTICE,
00291 "tarSubStructFileWrite:rsModColl error for Coll %s,stat=%d",
00292 modCollInp.collName, status);
00293 }
00294 return status;
00295 }
00296
00297
00298
00299
00300
00301
00302
00303
00304 int
00305 statPathInSpecColl (rsComm_t *rsComm, char *objPath,
00306 int inCachOnly, rodsObjStat_t **rodsObjStatOut)
00307 {
00308 int status;
00309 dataObjInfo_t *dataObjInfo = NULL;
00310 specColl_t *specColl;
00311 specCollCache_t *specCollCache;
00312 if ((status = getSpecCollCache (rsComm, objPath, inCachOnly,
00313 &specCollCache)) < 0) {
00314 if (status != SYS_SPEC_COLL_NOT_IN_CACHE &&
00315 status != CAT_NO_ROWS_FOUND){
00316 rodsLog (LOG_ERROR,
00317 "statPathInSpecColl: getSpecCollCache for %s, status = %d",
00318 objPath, status);
00319 }
00320 return (status);
00321 }
00322
00323 if (*rodsObjStatOut == NULL)
00324 *rodsObjStatOut = (rodsObjStat_t *) malloc (sizeof (rodsObjStat_t));
00325 memset (*rodsObjStatOut, 0, sizeof (rodsObjStat_t));
00326 specColl = &specCollCache->specColl;
00327 rstrcpy ((*rodsObjStatOut)->dataId, specCollCache->collId, NAME_LEN);
00328 rstrcpy ((*rodsObjStatOut)->ownerName, specCollCache->ownerName, NAME_LEN);
00329 rstrcpy ((*rodsObjStatOut)->ownerZone, specCollCache->ownerZone, NAME_LEN);
00330
00331 status = specCollSubStat (rsComm, specColl, objPath, UNKNOW_COLL_PERM, &dataObjInfo );
00332
00333
00334 if (status < 0) {
00335 if (dataObjInfo != NULL) {
00336 if (dataObjInfo->specColl != NULL) {
00337 (*rodsObjStatOut)->specColl = dataObjInfo->specColl;
00338 } else {
00339 replSpecColl (&specCollCache->specColl,
00340 &(*rodsObjStatOut)->specColl);
00341 }
00342 if (specColl->collClass == LINKED_COLL) {
00343 rstrcpy ((*rodsObjStatOut)->specColl->objPath,
00344 dataObjInfo->objPath, MAX_NAME_LEN);
00345 } else {
00346 (*rodsObjStatOut)->specColl->objPath[0] = '\0';
00347 }
00348 dataObjInfo->specColl = NULL;
00349 }
00350 (*rodsObjStatOut)->objType = UNKNOWN_OBJ_T;
00351 rstrcpy ((*rodsObjStatOut)->createTime, specCollCache->createTime,
00352 NAME_LEN);
00353 rstrcpy ((*rodsObjStatOut)->modifyTime, specCollCache->modifyTime,
00354 NAME_LEN);
00355 freeAllDataObjInfo (dataObjInfo);
00356
00357 return (0);
00358 } else {
00359 (*rodsObjStatOut)->specColl = dataObjInfo->specColl;
00360 dataObjInfo->specColl = NULL;
00361
00362 if (specColl->collClass == LINKED_COLL) {
00363 rstrcpy ((*rodsObjStatOut)->ownerName, dataObjInfo->dataOwnerName,
00364 NAME_LEN);
00365 rstrcpy ((*rodsObjStatOut)->ownerZone, dataObjInfo->dataOwnerZone,
00366 NAME_LEN);
00367 snprintf ((*rodsObjStatOut)->dataId, NAME_LEN, "%lld",
00368 dataObjInfo->dataId);
00369
00370 rstrcpy ((*rodsObjStatOut)->specColl->objPath,
00371 dataObjInfo->objPath, MAX_NAME_LEN);
00372 }
00373 (*rodsObjStatOut)->objType = (objType_t)status;
00374 (*rodsObjStatOut)->objSize = dataObjInfo->dataSize;
00375 rstrcpy ((*rodsObjStatOut)->createTime, dataObjInfo->dataCreate,
00376 NAME_LEN);
00377 rstrcpy ((*rodsObjStatOut)->modifyTime, dataObjInfo->dataModify,
00378 NAME_LEN);
00379 freeAllDataObjInfo (dataObjInfo);
00380 }
00381
00382 return (status);
00383 }
00384
00385
00386
00387
00388
00389
00390
00391 int
00392 specCollSubStat (rsComm_t *rsComm, specColl_t *specColl,
00393 char *subPath, specCollPerm_t specCollPerm, dataObjInfo_t **dataObjInfo)
00394 {
00395 int status;
00396 int objType;
00397 rodsStat_t *rodsStat = NULL;
00398 dataObjInfo_t *myDataObjInfo = NULL;;
00399
00400 if (dataObjInfo == NULL) return USER__NULL_INPUT_ERR;
00401 *dataObjInfo = NULL;
00402
00403 if (specColl->collClass == MOUNTED_COLL) {
00404
00405 myDataObjInfo = *dataObjInfo = (dataObjInfo_t *) malloc (sizeof (dataObjInfo_t));
00406
00407 memset (myDataObjInfo, 0, sizeof (dataObjInfo_t));
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418 myDataObjInfo->rescInfo = new rescInfo_t;
00419 eirods::error err = eirods::get_resc_info( specColl->resource, *myDataObjInfo->rescInfo );
00420 if( !err.ok() ) {
00421 std::stringstream msg;
00422 msg << "specCollSubStat - failed to get resource info";
00423 msg << specColl->resource;
00424 eirods::log( PASS( false, -1, msg.str(), err ) );
00425 freeDataObjInfo (myDataObjInfo);
00426 *dataObjInfo = NULL;
00427 return err.code();
00428 }
00429
00430
00431
00432 rstrcpy (myDataObjInfo->objPath, subPath, MAX_NAME_LEN);
00433 rstrcpy (myDataObjInfo->subPath, subPath, MAX_NAME_LEN);
00434 rstrcpy (myDataObjInfo->rescName, specColl->resource, NAME_LEN);
00435 rstrcpy (myDataObjInfo->rescHier, specColl->rescHier, MAX_NAME_LEN);
00436 rstrcpy (myDataObjInfo->dataType, "generic", NAME_LEN);
00437
00438 status = getMountedSubPhyPath (specColl->collection,
00439 specColl->phyPath, subPath, myDataObjInfo->filePath);
00440 if (status < 0) {
00441 freeDataObjInfo (myDataObjInfo);
00442 *dataObjInfo = NULL;
00443 return (status);
00444 }
00445 replSpecColl (specColl, &myDataObjInfo->specColl);
00446 } else if (specColl->collClass == LINKED_COLL) {
00447
00448
00449 specCollCache_t *specCollCache = NULL;
00450 char newPath[MAX_NAME_LEN];
00451 specColl_t *curSpecColl;
00452 char *accessStr;
00453 dataObjInp_t myDataObjInp;
00454 rodsObjStat_t *rodsObjStatOut = NULL;
00455
00456 *dataObjInfo = NULL;
00457 curSpecColl = specColl;
00458
00459 status = getMountedSubPhyPath (curSpecColl->collection,
00460 curSpecColl->phyPath, subPath, newPath);
00461 if (status < 0) {
00462 return (status);
00463 }
00464
00465 status = resolveLinkedPath (rsComm, newPath, &specCollCache, NULL);
00466 if (status < 0) return status;
00467 if (specCollCache != NULL &&
00468 specCollCache->specColl.collClass != LINKED_COLL) {
00469
00470 status = specCollSubStat (rsComm, &specCollCache->specColl,
00471 newPath, specCollPerm, dataObjInfo);
00472 return status;
00473 }
00474 bzero (&myDataObjInp, sizeof (myDataObjInp));
00475 rstrcpy (myDataObjInp.objPath, newPath, MAX_NAME_LEN);
00476
00477 status = collStat (rsComm, &myDataObjInp, &rodsObjStatOut);
00478 if (status >= 0 && NULL != rodsObjStatOut ) {
00479 myDataObjInfo = *dataObjInfo =
00480 (dataObjInfo_t *) malloc (sizeof (dataObjInfo_t));
00481 memset (myDataObjInfo, 0, sizeof (dataObjInfo_t));
00482 replSpecColl (curSpecColl, &myDataObjInfo->specColl);
00483 rstrcpy (myDataObjInfo->objPath, newPath, MAX_NAME_LEN);
00484 myDataObjInfo->dataId = strtoll (rodsObjStatOut->dataId, 0, 0);
00485 rstrcpy (myDataObjInfo->dataOwnerName, rodsObjStatOut->ownerName, NAME_LEN);
00486 rstrcpy (myDataObjInfo->dataOwnerZone, rodsObjStatOut->ownerZone, NAME_LEN);
00487 rstrcpy (myDataObjInfo->dataCreate, rodsObjStatOut->createTime,TIME_LEN);
00488 rstrcpy (myDataObjInfo->dataModify, rodsObjStatOut->modifyTime,TIME_LEN);
00489 freeRodsObjStat (rodsObjStatOut);
00490 return COLL_OBJ_T;
00491 }
00492
00493
00494 if (specCollPerm == READ_COLL_PERM) {
00495 accessStr = ACCESS_READ_OBJECT;
00496 } else if (specCollPerm == WRITE_COLL_PERM) {
00497 accessStr = ACCESS_DELETE_OBJECT;
00498 } else {
00499 accessStr = NULL;
00500 }
00501
00502 status = getDataObjInfo (rsComm, &myDataObjInp, dataObjInfo,
00503 accessStr, 0);
00504 if (status < 0) {
00505 myDataObjInfo = *dataObjInfo =
00506 (dataObjInfo_t *) malloc (sizeof (dataObjInfo_t));
00507 memset (myDataObjInfo, 0, sizeof (dataObjInfo_t));
00508 replSpecColl (curSpecColl, &myDataObjInfo->specColl);
00509 rstrcpy (myDataObjInfo->objPath, newPath, MAX_NAME_LEN);
00510 rodsLog (LOG_DEBUG,
00511 "specCollSubStat: getDataObjInfo error for %s, status = %d",
00512 newPath, status);
00513 return (status);
00514 } else {
00515 replSpecColl (curSpecColl, &(*dataObjInfo)->specColl);
00516 return DATA_OBJ_T;
00517 }
00518 } else if (getStructFileType (specColl) >= 0) {
00519
00520
00521 dataObjInp_t myDataObjInp;
00522 dataObjInfo_t *tmpDataObjInfo;
00523
00524 bzero (&myDataObjInp, sizeof (myDataObjInp));
00525 rstrcpy (myDataObjInp.objPath, specColl->objPath, MAX_NAME_LEN);
00526 status = getDataObjInfo (rsComm, &myDataObjInp, dataObjInfo, NULL, 1);
00527 if (status < 0) {
00528 rodsLog (LOG_ERROR,
00529 "specCollSubStat: getDataObjInfo error for %s, status = %d",
00530 myDataObjInp.objPath, status);
00531 *dataObjInfo = NULL;
00532 return (status);
00533 }
00534
00535
00536 status = sortObjInfoForOpen (rsComm, dataObjInfo,
00537 &myDataObjInp.condInput, 0);
00538 if (status < 0) {
00539 rodsLog (LOG_ERROR,
00540 "specCollSubStat: sortObjInfoForOpen error for %s. status = %d",
00541 myDataObjInp.objPath, status);
00542 return status;
00543 }
00544
00545 if (strlen (specColl->resource) > 0) {
00546 if (requeDataObjInfoByResc (dataObjInfo, specColl->resource,
00547 0, 1) >= 0) {
00548 if (strcmp (specColl->resource,
00549 (*dataObjInfo)->rescName) != 0) {
00550 rodsLog (LOG_ERROR,
00551 "specCollSubStat: %s in %s does not match cache resc %s",
00552 myDataObjInp.objPath, (*dataObjInfo)->rescName,
00553 specColl->resource);
00554 freeAllDataObjInfo (*dataObjInfo);
00555 *dataObjInfo = NULL;
00556 return (SYS_CACHE_STRUCT_FILE_RESC_ERR);
00557 }
00558 } else {
00559 rodsLog (LOG_ERROR,
00560 "specCollSubStat: requeDataObjInfoByResc %s, resc %s error",
00561 myDataObjInp.objPath, specColl->resource);
00562 freeAllDataObjInfo (*dataObjInfo);
00563 *dataObjInfo = NULL;
00564 return (SYS_CACHE_STRUCT_FILE_RESC_ERR);
00565 }
00566 }
00567
00568
00569 if ((*dataObjInfo)->next != NULL) {
00570 freeAllDataObjInfo ((*dataObjInfo)->next);
00571 (*dataObjInfo)->next = NULL;
00572 }
00573
00574
00575 tmpDataObjInfo = *dataObjInfo;
00576 replSpecColl (specColl, &tmpDataObjInfo->specColl);
00577 rstrcpy( specColl->resource,tmpDataObjInfo->rescName, NAME_LEN );
00578 rstrcpy( specColl->rescHier,tmpDataObjInfo->rescHier, NAME_LEN );
00579 rstrcpy( specColl->phyPath,tmpDataObjInfo->filePath, MAX_NAME_LEN );
00580 rstrcpy( tmpDataObjInfo->subPath, subPath, MAX_NAME_LEN );
00581 specColl->replNum = tmpDataObjInfo->replNum;
00582
00583 if (strcmp ((*dataObjInfo)->subPath, specColl->collection) == 0) {
00584
00585 return (COLL_OBJ_T);
00586 }
00587 } else {
00588 rodsLog (LOG_ERROR,
00589 "specCollSubStat: Unknown specColl collClass = %d",
00590 specColl->collClass);
00591 return (SYS_UNKNOWN_SPEC_COLL_CLASS);
00592 }
00593 status = l3Stat (rsComm, *dataObjInfo, &rodsStat);
00594 if (status < 0) {
00595 return status;
00596 }
00597
00598 if (rodsStat->st_ctim != 0) {
00599 snprintf ((*dataObjInfo)->dataCreate, NAME_LEN, "%d",
00600 rodsStat->st_ctim);
00601 snprintf ((*dataObjInfo)->dataModify, NAME_LEN, "%d",
00602 rodsStat->st_mtim);
00603 }
00604
00605 if (rodsStat->st_mode & S_IFDIR) {
00606 objType = COLL_OBJ_T;
00607 } else {
00608 objType = DATA_OBJ_T;
00609 (*dataObjInfo)->dataSize = rodsStat->st_size;
00610 }
00611 free (rodsStat);
00612
00613 return (objType);
00614 }
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624 int
00625 resolvePathInSpecColl (rsComm_t *rsComm, char *objPath,
00626 specCollPerm_t specCollPerm, int inCachOnly, dataObjInfo_t **dataObjInfo)
00627 {
00628 specCollCache_t *specCollCache;
00629 specColl_t *cachedSpecColl;
00630 int status;
00631 char *accessStr;
00632
00633 if (objPath == NULL) {
00634 return (SYS_INTERNAL_NULL_INPUT_ERR);
00635 }
00636 if ((status = getSpecCollCache (rsComm, objPath, inCachOnly,
00637 &specCollCache)) < 0) {
00638
00639 return (status);
00640 } else {
00641 cachedSpecColl = &specCollCache->specColl;
00642 }
00643
00644 if (specCollPerm != UNKNOW_COLL_PERM) {
00645 if (specCollPerm == WRITE_COLL_PERM) {
00646 accessStr = ACCESS_DELETE_OBJECT;
00647 } else {
00648 accessStr = ACCESS_READ_OBJECT;
00649 }
00650
00651 if (specCollCache->perm < specCollPerm) {
00652 status = checkCollAccessPerm (rsComm, cachedSpecColl->collection,
00653 accessStr);
00654 if (status < 0) {
00655 rodsLog (LOG_ERROR,
00656 "resolvePathInSpecColl:checkCollAccessPerm err for %s,stat=%d",
00657 cachedSpecColl->collection, status);
00658 return (status);
00659 } else {
00660 specCollCache->perm = specCollPerm;
00661 }
00662 }
00663 }
00664
00665 status = specCollSubStat (rsComm, cachedSpecColl, objPath,
00666 specCollPerm, dataObjInfo);
00667
00668 if (status < 0) {
00669 if (*dataObjInfo != NULL) {
00670
00671 return (SYS_SPEC_COLL_OBJ_NOT_EXIST);
00672 }
00673 rodsLog (LOG_ERROR,
00674 "resolvePathInSpecColl: specCollSubStat error for %s, status = %d",
00675 objPath, status);
00676 return (status);
00677 } else {
00678 if (*dataObjInfo != NULL) {
00679 if (specCollPerm == WRITE_COLL_PERM)
00680 (*dataObjInfo)->writeFlag = 1;
00681 }
00682 }
00683
00684 return (status);
00685 }
00686
00687 int
00688 resolveLinkedPath (rsComm_t *rsComm, char *objPath,
00689 specCollCache_t **specCollCache, keyValPair_t *condInput)
00690 {
00691 int linkCnt = 0;
00692 specColl_t *curSpecColl;
00693 char prevNewPath[MAX_NAME_LEN];
00694 specCollCache_t *oldSpecCollCache = NULL;
00695 int status;
00696
00697 *specCollCache = NULL;
00698
00699 if (getValByKey (condInput, TRANSLATED_PATH_KW) != NULL)
00700 return 0;
00701
00702 addKeyVal (condInput, TRANSLATED_PATH_KW, "");
00703 while (getSpecCollCache (rsComm, objPath, 0, specCollCache) >= 0 &&
00704 (*specCollCache)->specColl.collClass == LINKED_COLL) {
00705 oldSpecCollCache = *specCollCache;
00706 if (linkCnt++ >= MAX_LINK_CNT) {
00707 rodsLog (LOG_ERROR,
00708 "resolveLinkedPath: linkCnt for %s exceeds %d",
00709 objPath, MAX_LINK_CNT);
00710 return SYS_LINK_CNT_EXCEEDED_ERR;
00711 }
00712
00713 curSpecColl = &(*specCollCache)->specColl;
00714 if (strcmp (curSpecColl->collection, objPath) == 0 &&
00715 getValByKey (condInput, NO_TRANSLATE_LINKPT_KW) != NULL) {
00716 return 0;
00717 }
00718 rstrcpy (prevNewPath, objPath, MAX_NAME_LEN);
00719 status = getMountedSubPhyPath (curSpecColl->collection,
00720 curSpecColl->phyPath, prevNewPath, objPath);
00721 if (status < 0) {
00722 return (status);
00723 }
00724 }
00725 if (*specCollCache == NULL) *specCollCache = oldSpecCollCache;
00726 return linkCnt;
00727 }
00728