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