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, TIME_LEN);
00190 rstrcpy (tmpSpecCollCache->modifyTime, tmpModifyTime, TIME_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,TIME_LEN);
00215 rstrcpy (tmpSpecCollCache->modifyTime, rodsObjStatOut->modifyTime,TIME_LEN);
00216
00217
00218 tmpSpecCollCache->next = SpecCollCacheHead;
00219 SpecCollCacheHead = tmpSpecCollCache;
00220
00221 return 0;
00222
00223 }
00224
00225 specCollCache_t *
00226 matchSpecCollCache (char *objPath)
00227 {
00228 specCollCache_t *tmpSpecCollCache = SpecCollCacheHead;
00229
00230 while (tmpSpecCollCache != NULL) {
00231 int len = strlen (tmpSpecCollCache->specColl.collection);
00232 if (strncmp (tmpSpecCollCache->specColl.collection, objPath, len)
00233 == 0) {
00234 char *tmpPtr = objPath + len;
00235
00236 if (*tmpPtr == '\0' || *tmpPtr == '/') {
00237 return (tmpSpecCollCache);
00238 }
00239 }
00240 tmpSpecCollCache = tmpSpecCollCache->next;
00241 }
00242 return (NULL);
00243 }
00244
00245 int
00246 getSpecCollCache (rsComm_t *rsComm, char *objPath,
00247 int inCachOnly, specCollCache_t **specCollCache)
00248 {
00249 int status;
00250 genQueryOut_t *genQueryOut = NULL;
00251
00252 if ((*specCollCache = matchSpecCollCache (objPath)) != NULL) {
00253 return (0);
00254 } else if (inCachOnly > 0) {
00255 return (SYS_SPEC_COLL_NOT_IN_CACHE);
00256 }
00257
00258 status = querySpecColl (rsComm, objPath, &genQueryOut);
00259 if (status < 0) return (status);
00260
00261 status = queueSpecCollCache (rsComm, genQueryOut, objPath);
00262 freeGenQueryOut (&genQueryOut);
00263
00264 if (status < 0) return (status);
00265 *specCollCache = SpecCollCacheHead;
00266
00267 return (0);
00268 }
00269
00270 int
00271 modCollInfo2 (rsComm_t *rsComm, specColl_t *specColl, int clearFlag)
00272 {
00273 int status;
00274 char collInfo2[MAX_NAME_LEN];
00275 collInp_t modCollInp;
00276
00277 memset (&modCollInp, 0, sizeof (modCollInp));
00278 rstrcpy (modCollInp.collName, specColl->collection, MAX_NAME_LEN);
00279 addKeyVal (&modCollInp.condInput, COLLECTION_TYPE_KW,
00280 TAR_STRUCT_FILE_STR);
00281 if (clearFlag > 0) {
00282 rstrcpy (collInfo2, "NULL_SPECIAL_VALUE", MAX_NAME_LEN);
00283 } else {
00284 makeCachedStructFileStr (collInfo2, specColl);
00285 }
00286 addKeyVal (&modCollInp.condInput, COLLECTION_INFO2_KW, collInfo2);
00287 status = rsModColl (rsComm, &modCollInp);
00288 if (status < 0) {
00289 rodsLog (LOG_NOTICE,
00290 "tarSubStructFileWrite:rsModColl error for Coll %s,stat=%d",
00291 modCollInp.collName, status);
00292 }
00293 return status;
00294 }
00295
00296
00297
00298
00299
00300
00301
00302
00303 int
00304 statPathInSpecColl (rsComm_t *rsComm, char *objPath,
00305 int inCachOnly, rodsObjStat_t **rodsObjStatOut)
00306 {
00307 int status;
00308 dataObjInfo_t *dataObjInfo = NULL;
00309 specColl_t *specColl;
00310 specCollCache_t *specCollCache;
00311
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 TIME_LEN);
00353 rstrcpy ((*rodsObjStatOut)->modifyTime, specCollCache->modifyTime,
00354 TIME_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 TIME_LEN);
00377 rstrcpy ((*rodsObjStatOut)->modifyTime, dataObjInfo->dataModify,
00378 TIME_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 << "failed to get resource info [";
00423 msg << specColl->resource;
00424 msg << "]";
00425 eirods::log( PASSMSG( msg.str(), err ) );
00426 freeDataObjInfo (myDataObjInfo);
00427 *dataObjInfo = NULL;
00428 return err.code();
00429 }
00430
00431
00432
00433 rstrcpy (myDataObjInfo->objPath, subPath, MAX_NAME_LEN);
00434 rstrcpy (myDataObjInfo->subPath, subPath, MAX_NAME_LEN);
00435 rstrcpy (myDataObjInfo->rescName, specColl->resource, NAME_LEN);
00436 rstrcpy (myDataObjInfo->rescHier, specColl->rescHier, MAX_NAME_LEN);
00437 rstrcpy (myDataObjInfo->dataType, "generic", NAME_LEN);
00438
00439 status = getMountedSubPhyPath (specColl->collection,
00440 specColl->phyPath, subPath, myDataObjInfo->filePath);
00441 if (status < 0) {
00442 freeDataObjInfo (myDataObjInfo);
00443 *dataObjInfo = NULL;
00444 return (status);
00445 }
00446 replSpecColl (specColl, &myDataObjInfo->specColl);
00447 } else if (specColl->collClass == LINKED_COLL) {
00448
00449
00450 specCollCache_t *specCollCache = NULL;
00451 char newPath[MAX_NAME_LEN];
00452 specColl_t *curSpecColl;
00453 char *accessStr;
00454 dataObjInp_t myDataObjInp;
00455 rodsObjStat_t *rodsObjStatOut = NULL;
00456
00457 *dataObjInfo = NULL;
00458 curSpecColl = specColl;
00459
00460 status = getMountedSubPhyPath (curSpecColl->collection,
00461 curSpecColl->phyPath, subPath, newPath);
00462 if (status < 0) {
00463 return (status);
00464 }
00465
00466 status = resolveLinkedPath (rsComm, newPath, &specCollCache, NULL);
00467 if (status < 0) return status;
00468 if (specCollCache != NULL &&
00469 specCollCache->specColl.collClass != LINKED_COLL) {
00470
00471 status = specCollSubStat (rsComm, &specCollCache->specColl,
00472 newPath, specCollPerm, dataObjInfo);
00473 return status;
00474 }
00475 bzero (&myDataObjInp, sizeof (myDataObjInp));
00476 rstrcpy (myDataObjInp.objPath, newPath, MAX_NAME_LEN);
00477
00478 status = collStat (rsComm, &myDataObjInp, &rodsObjStatOut);
00479 if (status >= 0 && NULL != rodsObjStatOut ) {
00480 myDataObjInfo = *dataObjInfo =
00481 (dataObjInfo_t *) malloc (sizeof (dataObjInfo_t));
00482 memset (myDataObjInfo, 0, sizeof (dataObjInfo_t));
00483 replSpecColl (curSpecColl, &myDataObjInfo->specColl);
00484 rstrcpy (myDataObjInfo->objPath, newPath, MAX_NAME_LEN);
00485 myDataObjInfo->dataId = strtoll (rodsObjStatOut->dataId, 0, 0);
00486 rstrcpy (myDataObjInfo->dataOwnerName, rodsObjStatOut->ownerName, NAME_LEN);
00487 rstrcpy (myDataObjInfo->dataOwnerZone, rodsObjStatOut->ownerZone, NAME_LEN);
00488 rstrcpy (myDataObjInfo->dataCreate, rodsObjStatOut->createTime,TIME_LEN);
00489 rstrcpy (myDataObjInfo->dataModify, rodsObjStatOut->modifyTime,TIME_LEN);
00490 freeRodsObjStat (rodsObjStatOut);
00491 return COLL_OBJ_T;
00492 }
00493
00494
00495 if (specCollPerm == READ_COLL_PERM) {
00496 accessStr = ACCESS_READ_OBJECT;
00497 } else if (specCollPerm == WRITE_COLL_PERM) {
00498 accessStr = ACCESS_DELETE_OBJECT;
00499 } else {
00500 accessStr = NULL;
00501 }
00502
00503 status = getDataObjInfo (rsComm, &myDataObjInp, dataObjInfo,
00504 accessStr, 0);
00505 if (status < 0) {
00506 myDataObjInfo = *dataObjInfo =
00507 (dataObjInfo_t *) malloc (sizeof (dataObjInfo_t));
00508 memset (myDataObjInfo, 0, sizeof (dataObjInfo_t));
00509 replSpecColl (curSpecColl, &myDataObjInfo->specColl);
00510 rstrcpy (myDataObjInfo->objPath, newPath, MAX_NAME_LEN);
00511 rodsLog (LOG_DEBUG,
00512 "specCollSubStat: getDataObjInfo error for %s, status = %d",
00513 newPath, status);
00514 return (status);
00515 } else {
00516 replSpecColl (curSpecColl, &(*dataObjInfo)->specColl);
00517 return DATA_OBJ_T;
00518 }
00519 } else if (getStructFileType (specColl) >= 0) {
00520
00521
00522 dataObjInp_t myDataObjInp;
00523 dataObjInfo_t *tmpDataObjInfo;
00524
00525 bzero (&myDataObjInp, sizeof (myDataObjInp));
00526 rstrcpy (myDataObjInp.objPath, specColl->objPath, MAX_NAME_LEN);
00527
00528 addKeyVal(&myDataObjInp.condInput, RESC_HIER_STR_KW, specColl->rescHier);
00529 status = getDataObjInfo (rsComm, &myDataObjInp, dataObjInfo, NULL, 1);
00530 if (status < 0) {
00531 rodsLog (LOG_ERROR,
00532 "specCollSubStat: getDataObjInfo error for %s, status = %d",
00533 myDataObjInp.objPath, status);
00534 *dataObjInfo = NULL;
00535 return (status);
00536 }
00537
00538
00539 status = sortObjInfoForOpen (rsComm, dataObjInfo,
00540 &myDataObjInp.condInput, 0);
00541 if (status < 0) {
00542 rodsLog (LOG_ERROR,
00543 "specCollSubStat: sortObjInfoForOpen error for %s. status = %d",
00544 myDataObjInp.objPath, status);
00545 return status;
00546 }
00547
00548 if (strlen (specColl->resource) > 0) {
00549 if (requeDataObjInfoByResc (dataObjInfo, specColl->resource,
00550 0, 1) >= 0) {
00551 if (strcmp (specColl->resource,
00552 (*dataObjInfo)->rescName) != 0) {
00553 rodsLog (LOG_ERROR,
00554 "specCollSubStat: %s in %s does not match cache resc %s",
00555 myDataObjInp.objPath, (*dataObjInfo)->rescName,
00556 specColl->resource);
00557 freeAllDataObjInfo (*dataObjInfo);
00558 *dataObjInfo = NULL;
00559 return (SYS_CACHE_STRUCT_FILE_RESC_ERR);
00560 }
00561 } else {
00562 rodsLog (LOG_ERROR,
00563 "specCollSubStat: requeDataObjInfoByResc %s, resc %s error",
00564 myDataObjInp.objPath, specColl->resource);
00565 freeAllDataObjInfo (*dataObjInfo);
00566 *dataObjInfo = NULL;
00567 return (SYS_CACHE_STRUCT_FILE_RESC_ERR);
00568 }
00569 }
00570
00571
00572 if ((*dataObjInfo)->next != NULL) {
00573 freeAllDataObjInfo ((*dataObjInfo)->next);
00574 (*dataObjInfo)->next = NULL;
00575 }
00576
00577
00578 tmpDataObjInfo = *dataObjInfo;
00579 replSpecColl (specColl, &tmpDataObjInfo->specColl);
00580 rstrcpy( specColl->resource,tmpDataObjInfo->rescName, NAME_LEN );
00581 rstrcpy( specColl->rescHier,tmpDataObjInfo->rescHier, MAX_NAME_LEN );
00582 rstrcpy( specColl->phyPath,tmpDataObjInfo->filePath, MAX_NAME_LEN );
00583 rstrcpy( tmpDataObjInfo->subPath, subPath, MAX_NAME_LEN );
00584 specColl->replNum = tmpDataObjInfo->replNum;
00585
00586 if (strcmp ((*dataObjInfo)->subPath, specColl->collection) == 0) {
00587
00588 return (COLL_OBJ_T);
00589 }
00590 } else {
00591 rodsLog (LOG_ERROR,
00592 "specCollSubStat: Unknown specColl collClass = %d",
00593 specColl->collClass);
00594 return (SYS_UNKNOWN_SPEC_COLL_CLASS);
00595 }
00596 status = l3Stat (rsComm, *dataObjInfo, &rodsStat);
00597 if (status < 0) {
00598 return status;
00599 }
00600
00601 if (rodsStat->st_ctim != 0) {
00602 snprintf ((*dataObjInfo)->dataCreate, TIME_LEN, "%d", rodsStat->st_ctim);
00603 snprintf ((*dataObjInfo)->dataModify, TIME_LEN, "%d", rodsStat->st_mtim);
00604 }
00605
00606 if (rodsStat->st_mode & S_IFDIR) {
00607 objType = COLL_OBJ_T;
00608 } else {
00609 objType = DATA_OBJ_T;
00610 (*dataObjInfo)->dataSize = rodsStat->st_size;
00611 }
00612 free (rodsStat);
00613
00614 return (objType);
00615 }
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625 int
00626 resolvePathInSpecColl (rsComm_t *rsComm, char *objPath,
00627 specCollPerm_t specCollPerm, int inCachOnly, dataObjInfo_t **dataObjInfo)
00628 {
00629 specCollCache_t *specCollCache;
00630 specColl_t *cachedSpecColl;
00631 int status;
00632 char *accessStr;
00633
00634 if (objPath == NULL) {
00635 return (SYS_INTERNAL_NULL_INPUT_ERR);
00636 }
00637 if ((status = getSpecCollCache (rsComm, objPath, inCachOnly,
00638 &specCollCache)) < 0) {
00639
00640 return (status);
00641 } else {
00642 cachedSpecColl = &specCollCache->specColl;
00643 }
00644
00645 if (specCollPerm != UNKNOW_COLL_PERM) {
00646 if (specCollPerm == WRITE_COLL_PERM) {
00647 accessStr = ACCESS_DELETE_OBJECT;
00648 } else {
00649 accessStr = ACCESS_READ_OBJECT;
00650 }
00651
00652 if (specCollCache->perm < specCollPerm) {
00653 status = checkCollAccessPerm (rsComm, cachedSpecColl->collection,
00654 accessStr);
00655 if (status < 0) {
00656 rodsLog (LOG_ERROR,
00657 "resolvePathInSpecColl:checkCollAccessPerm err for %s,stat=%d",
00658 cachedSpecColl->collection, status);
00659 return (status);
00660 } else {
00661 specCollCache->perm = specCollPerm;
00662 }
00663 }
00664 }
00665
00666 status = specCollSubStat (rsComm, cachedSpecColl, objPath,
00667 specCollPerm, dataObjInfo);
00668
00669 if (status < 0) {
00670 if (*dataObjInfo != NULL) {
00671
00672 return (SYS_SPEC_COLL_OBJ_NOT_EXIST);
00673 }
00674 rodsLog (LOG_ERROR,
00675 "resolvePathInSpecColl: specCollSubStat error for %s, status = %d",
00676 objPath, status);
00677 return (status);
00678 } else {
00679 if (*dataObjInfo != NULL) {
00680 if (specCollPerm == WRITE_COLL_PERM)
00681 (*dataObjInfo)->writeFlag = 1;
00682 }
00683 }
00684
00685 return (status);
00686 }
00687
00688 int
00689 resolveLinkedPath (rsComm_t *rsComm, char *objPath,
00690 specCollCache_t **specCollCache, keyValPair_t *condInput)
00691 {
00692 int linkCnt = 0;
00693 specColl_t *curSpecColl;
00694 char prevNewPath[MAX_NAME_LEN];
00695 specCollCache_t *oldSpecCollCache = NULL;
00696 int status;
00697
00698 *specCollCache = NULL;
00699
00700 if (getValByKey (condInput, TRANSLATED_PATH_KW) != NULL)
00701 return 0;
00702
00703 addKeyVal (condInput, TRANSLATED_PATH_KW, "");
00704 while (getSpecCollCache (rsComm, objPath, 0, specCollCache) >= 0 &&
00705 (*specCollCache)->specColl.collClass == LINKED_COLL) {
00706 oldSpecCollCache = *specCollCache;
00707 if (linkCnt++ >= MAX_LINK_CNT) {
00708 rodsLog (LOG_ERROR,
00709 "resolveLinkedPath: linkCnt for %s exceeds %d",
00710 objPath, MAX_LINK_CNT);
00711 return SYS_LINK_CNT_EXCEEDED_ERR;
00712 }
00713
00714 curSpecColl = &(*specCollCache)->specColl;
00715 if (strcmp (curSpecColl->collection, objPath) == 0 &&
00716 getValByKey (condInput, NO_TRANSLATE_LINKPT_KW) != NULL) {
00717 return 0;
00718 }
00719 rstrcpy (prevNewPath, objPath, MAX_NAME_LEN);
00720 status = getMountedSubPhyPath (curSpecColl->collection,
00721 curSpecColl->phyPath, prevNewPath, objPath);
00722 if (status < 0) {
00723 return (status);
00724 }
00725 }
00726 if (*specCollCache == NULL) *specCollCache = oldSpecCollCache;
00727 return linkCnt;
00728 }
00729