irods  4.2.8
About: iRODS (the integrated Rule Oriented Data System) is a distributed data-management system for creating data grids, digital libraries, persistent archives, and real-time data systems.
  Fossies Dox: irods-4.2.8.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

specColl.cpp
Go to the documentation of this file.
1 
3 /* specColl.c - special collection (mounted and linked collections) routines */
4 
5 #include "rcMisc.h"
6 #include "dataObjOpr.hpp"
7 #include "specColl.hpp"
8 #include "collection.hpp"
9 #include "resource.hpp"
10 #include "genQuery.h"
11 #include "modColl.h"
12 #include "icatDefines.h"
13 #include "dataObjClose.h"
14 #include "objMetaOpr.hpp"
15 #include "rsGenQuery.hpp"
16 #include "rsModColl.hpp"
17 #include "rsDataObjClose.hpp"
18 
19 // =-=-=-=-=-=-=-
21 #include "irods_stacktrace.hpp"
22 
23 static int HaveFailedSpecCollPath = 0;
25 
26 /* querySpecColl - The query can produce multiple answer and only one
27  * is correct. e.g., objPath = /x/yabc can produce answers:
28  * /x/y, /x/ya, /x/yabc, etc. The calling subroutine need to screen
29  * /x/y, /x/ya out
30  * check queueSpecCollCache () for screening.
31  */
32 int
33 querySpecColl( rsComm_t *rsComm, char *objPath, genQueryOut_t **genQueryOut ) {
34  genQueryInp_t genQueryInp;
35  int status;
36  char condStr[MAX_NAME_LEN];
37 
38  if ( HaveFailedSpecCollPath && strcmp( objPath, FailedSpecCollPath ) == 0 ) {
39  return CAT_NO_ROWS_FOUND;
40  }
41 
42  /* see if objPath is in the path of a spec collection */
43  memset( &genQueryInp, 0, sizeof( genQueryInp ) );
44 
45  snprintf( condStr, MAX_NAME_LEN, "parent_of '%s'", objPath );
46  addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, condStr );
47  rstrcpy( condStr, "like '_%'", MAX_NAME_LEN );
48  addInxVal( &genQueryInp.sqlCondInp, COL_COLL_TYPE, condStr );
49 
50  addInxIval( &genQueryInp.selectInp, COL_COLL_ID, 1 );
51  addInxIval( &genQueryInp.selectInp, COL_COLL_NAME, 1 );
52  addInxIval( &genQueryInp.selectInp, COL_COLL_OWNER_NAME, 1 );
53  addInxIval( &genQueryInp.selectInp, COL_COLL_OWNER_ZONE, 1 );
54  addInxIval( &genQueryInp.selectInp, COL_COLL_CREATE_TIME, 1 );
55  addInxIval( &genQueryInp.selectInp, COL_COLL_MODIFY_TIME, 1 );
56  addInxIval( &genQueryInp.selectInp, COL_COLL_TYPE, 1 );
57  addInxIval( &genQueryInp.selectInp, COL_COLL_INFO1, 1 );
58  addInxIval( &genQueryInp.selectInp, COL_COLL_INFO2, 1 );
59 
60  genQueryInp.maxRows = MAX_SQL_ROWS;
61 
62  status = rsGenQuery( rsComm, &genQueryInp, genQueryOut );
63 
64  clearGenQueryInp( &genQueryInp );
65 
66  if ( status < 0 ) {
69  return status;
70  }
71 
72  return 0;
73 }
74 
75 /* queueSpecCollCache - queue the specColl given in genQueryOut.
76  * genQueryOut may contain multiple answer and only one
77  * is correct. e.g., objPath = /x/yabc can produce answers:
78  * /x/y, /x/ya, /x/yabc, etc. The calling subroutine need to screen
79  * /x/y, /x/ya out
80  */
81 
82 int
83 queueSpecCollCache( rsComm_t *rsComm, genQueryOut_t *genQueryOut, char *objPath ) { // JMC - backport 4680
84  int status;
85  int i;
86  sqlResult_t *dataId;
87  sqlResult_t *ownerName;
88  sqlResult_t *ownerZone;
89  sqlResult_t *createTime;
90  sqlResult_t *modifyTime;
92  sqlResult_t *collection;
93  sqlResult_t *collInfo1;
94  sqlResult_t *collInfo2;
95  char *tmpDataId, *tmpOwnerName, *tmpOwnerZone, *tmpCreateTime,
96  *tmpModifyTime, *tmpCollType, *tmpCollection, *tmpCollInfo1,
97  *tmpCollInfo2;
98  specColl_t *specColl;
99 
100  if ( ( dataId = getSqlResultByInx( genQueryOut, COL_COLL_ID ) ) == NULL ) {
102  "queueSpecCollCache: getSqlResultByInx for COL_COLL_ID failed" );
103  return UNMATCHED_KEY_OR_INDEX;
104  }
105  else if ( ( ownerName = getSqlResultByInx( genQueryOut,
106  COL_COLL_OWNER_NAME ) ) == NULL ) {
108  "queueSpecCollCache:getSqlResultByInx for COL_COLL_OWNER_NAME failed" );
109  return UNMATCHED_KEY_OR_INDEX;
110  }
111  else if ( ( ownerZone = getSqlResultByInx( genQueryOut,
112  COL_COLL_OWNER_ZONE ) ) == NULL ) {
114  "queueSpecCollCache:getSqlResultByInx for COL_COLL_OWNER_ZONE failed" );
115  return UNMATCHED_KEY_OR_INDEX;
116  }
117  else if ( ( createTime = getSqlResultByInx( genQueryOut,
118  COL_COLL_CREATE_TIME ) ) == NULL ) {
120  "queueSpecCollCache:getSqlResultByInx for COL_COLL_CREATE_TIME failed" );
121  return UNMATCHED_KEY_OR_INDEX;
122  }
123  else if ( ( modifyTime = getSqlResultByInx( genQueryOut,
124  COL_COLL_MODIFY_TIME ) ) == NULL ) {
126  "queueSpecCollCache:getSqlResultByInx for COL_COLL_MODIFY_TIME failed" );
127  return UNMATCHED_KEY_OR_INDEX;
128  }
129  else if ( ( collType = getSqlResultByInx( genQueryOut,
130  COL_COLL_TYPE ) ) == NULL ) {
132  "queueSpecCollCache:getSqlResultByInx for COL_COLL_TYPE failed" );
133  return UNMATCHED_KEY_OR_INDEX;
134  }
135  else if ( ( collection = getSqlResultByInx( genQueryOut,
136  COL_COLL_NAME ) ) == NULL ) {
138  "queueSpecCollCache:getSqlResultByInx for COL_COLL_NAME failed" );
139  return UNMATCHED_KEY_OR_INDEX;
140  }
141  else if ( ( collInfo1 = getSqlResultByInx( genQueryOut,
142  COL_COLL_INFO1 ) ) == NULL ) {
144  "queueSpecCollCache:getSqlResultByInx for COL_COLL_INFO1 failed" );
145  return UNMATCHED_KEY_OR_INDEX;
146  }
147  else if ( ( collInfo2 = getSqlResultByInx( genQueryOut,
148  COL_COLL_INFO2 ) ) == NULL ) {
150  "queueSpecCollCache:getSqlResultByInx for COL_COLL_INFO2 failed" );
151  return UNMATCHED_KEY_OR_INDEX;
152  }
153 
154  for ( i = 0; i <= genQueryOut->rowCnt; i++ ) {
155  int len;
156  char *tmpPtr;
157 
158  tmpCollection = &collection->value[collection->len * i];
159 
160  len = strlen( tmpCollection );
161  tmpPtr = objPath + len;
162 
163  if ( *tmpPtr == '\0' || *tmpPtr == '/' ) {
164  specCollCache_t * tmpSpecCollCache = ( specCollCache_t* )malloc( sizeof( specCollCache_t ) );
165  memset( tmpSpecCollCache, 0, sizeof( specCollCache_t ) );
166 
167  tmpDataId = &dataId->value[dataId->len * i];
168  tmpOwnerName = &ownerName->value[ownerName->len * i];
169  tmpOwnerZone = &ownerZone->value[ownerZone->len * i];
170  tmpCreateTime = &createTime->value[createTime->len * i];
171  tmpModifyTime = &modifyTime->value[modifyTime->len * i];
172  tmpCollType = &collType->value[collType->len * i];
173  tmpCollInfo1 = &collInfo1->value[collInfo1->len * i];
174  tmpCollInfo2 = &collInfo2->value[collInfo2->len * i];
175 
176  specColl = &tmpSpecCollCache->specColl;
177  status = resolveSpecCollType( tmpCollType, tmpCollection, tmpCollInfo1, tmpCollInfo2, specColl );
178  if ( status < 0 ) {
179  free( tmpSpecCollCache );
180  return status;
181  }
182 
183  // =-=-=-=-=-=-=-
184  // JMC - backport 4680
185  if ( specColl->collClass == STRUCT_FILE_COLL &&
186  specColl->type == TAR_STRUCT_FILE_T ) {
187  /* tar struct file. need to get phyPath */
188  status = getPhyPath( rsComm, specColl->objPath, specColl->resource, specColl->phyPath, specColl->rescHier );
189  if ( status < 0 ) {
190  rodsLog( LOG_ERROR, "queueSpecCollCache - getPhyPath failed for [%s] on resource [%s] with cache dir [%s] and collection [%s]",
191  specColl->objPath, specColl->resource, specColl->cacheDir, specColl->collection );
192  free( tmpSpecCollCache );
193  return status;
194  }
195  }
196  // =-=-=-=-=-=-=-
197  rstrcpy( tmpSpecCollCache->collId, tmpDataId, NAME_LEN );
198  rstrcpy( tmpSpecCollCache->ownerName, tmpOwnerName, NAME_LEN );
199  rstrcpy( tmpSpecCollCache->ownerZone, tmpOwnerZone, NAME_LEN );
200  rstrcpy( tmpSpecCollCache->createTime, tmpCreateTime, TIME_LEN );
201  rstrcpy( tmpSpecCollCache->modifyTime, tmpModifyTime, TIME_LEN );
202  tmpSpecCollCache->next = SpecCollCacheHead;
203  SpecCollCacheHead = tmpSpecCollCache;
204 
205  return 0;
206  }
207  }
208 
209  return CAT_NO_ROWS_FOUND;
210 }
211 
212 int
214  specCollCache_t *tmpSpecCollCache;
215 
216  tmpSpecCollCache = ( specCollCache_t* )malloc( sizeof( specCollCache_t ) );
217  memset( tmpSpecCollCache, 0, sizeof( specCollCache_t ) );
218 
219  tmpSpecCollCache->specColl = *rodsObjStatOut->specColl;
220 
221  rstrcpy( tmpSpecCollCache->collId, rodsObjStatOut->dataId, NAME_LEN );
222  rstrcpy( tmpSpecCollCache->ownerName, rodsObjStatOut->ownerName, NAME_LEN );
223  rstrcpy( tmpSpecCollCache->ownerZone, rodsObjStatOut->ownerZone, NAME_LEN );
224  rstrcpy( tmpSpecCollCache->createTime, rodsObjStatOut->createTime, TIME_LEN );
225  rstrcpy( tmpSpecCollCache->modifyTime, rodsObjStatOut->modifyTime, TIME_LEN );
226 
227 
228  tmpSpecCollCache->next = SpecCollCacheHead;
229  SpecCollCacheHead = tmpSpecCollCache;
230 
231  return 0;
232 
233 }
234 
236 matchSpecCollCache( char *objPath ) {
237  specCollCache_t *tmpSpecCollCache = SpecCollCacheHead;
238 
239  while ( tmpSpecCollCache != NULL ) {
240  int len = strlen( tmpSpecCollCache->specColl.collection );
241  if ( strncmp( tmpSpecCollCache->specColl.collection, objPath, len )
242  == 0 ) {
243  char *tmpPtr = objPath + len;
244 
245  if ( *tmpPtr == '\0' || *tmpPtr == '/' ) {
246  return tmpSpecCollCache;
247  }
248  }
249  tmpSpecCollCache = tmpSpecCollCache->next;
250  }
251  return NULL;
252 }
253 
254 int
255 getSpecCollCache( rsComm_t *rsComm, char *objPath,
256  int inCachOnly, specCollCache_t **specCollCache ) {
257  int status;
258  genQueryOut_t *genQueryOut = NULL;
259 
260  if ( ( *specCollCache = matchSpecCollCache( objPath ) ) != NULL ) {
261  return 0;
262  }
263  else if ( inCachOnly > 0 ) {
265  }
266 
267  status = querySpecColl( rsComm, objPath, &genQueryOut );
268  if ( status < 0 ) {
269  freeGenQueryOut( &genQueryOut );
270  return status;
271  }
272 
273  status = queueSpecCollCache( rsComm, genQueryOut, objPath ); // JMC - backport 4680
274  freeGenQueryOut( &genQueryOut );
275 
276  if ( status < 0 ) {
277  return status;
278  }
279  *specCollCache = SpecCollCacheHead; /* queued at top */
280 
281  return 0;
282 }
283 
284 int
285 modCollInfo2( rsComm_t *rsComm, specColl_t *specColl, int clearFlag ) {
286 
287  int status;
288  char collInfo2[MAX_NAME_LEN];
289  collInp_t modCollInp;
290 
291  memset( &modCollInp, 0, sizeof( modCollInp ) );
292  rstrcpy( modCollInp.collName, specColl->collection, MAX_NAME_LEN );
293  //addKeyVal( &modCollInp.condInput, COLLECTION_TYPE_KW,
294  // TAR_STRUCT_FILE_STR ); /* need this or rsModColl fail */
295  if ( clearFlag > 0 ) {
296  rstrcpy( collInfo2, "NULL_SPECIAL_VALUE", MAX_NAME_LEN );
297  }
298  else {
299  makeCachedStructFileStr( collInfo2, specColl );
300  }
301  addKeyVal( &modCollInp.condInput, COLLECTION_INFO2_KW, collInfo2 );
302  status = rsModColl( rsComm, &modCollInp );
303  if ( status < 0 ) {
305  "tarSubStructFileWrite:rsModColl error for Coll %s,stat=%d",
306  modCollInp.collName, status );
307  }
308  return status;
309 }
310 
311 /* statPathInSpecColl - stat the path given in objPath assuming it is
312  * in the path of a special collection. The inCachOnly flag asks it to
313  * check the specColl in the global cache only. The output of the
314  * stat is given in rodsObjStatOut.
315  *
316  */
317 
318 int
319 statPathInSpecColl( rsComm_t *rsComm, char *objPath,
320  int inCachOnly, rodsObjStat_t **rodsObjStatOut ) {
321  int status;
322  dataObjInfo_t *dataObjInfo = NULL;
323  specColl_t *specColl;
324  specCollCache_t *specCollCache;
325 
326  if ( ( status = getSpecCollCache( rsComm, objPath, inCachOnly,
327  &specCollCache ) ) < 0 ) {
331  "statPathInSpecColl: getSpecCollCache for %s, status = %d",
332  objPath, status );
333  }
334  return status;
335  }
336 
337  if ( *rodsObjStatOut == NULL ) {
338  *rodsObjStatOut = ( rodsObjStat_t * ) malloc( sizeof( rodsObjStat_t ) );
339  }
340  memset( *rodsObjStatOut, 0, sizeof( rodsObjStat_t ) );
341  specColl = &specCollCache->specColl;
342  rstrcpy( ( *rodsObjStatOut )->dataId, specCollCache->collId, NAME_LEN );
343  rstrcpy( ( *rodsObjStatOut )->ownerName, specCollCache->ownerName, NAME_LEN );
344  rstrcpy( ( *rodsObjStatOut )->ownerZone, specCollCache->ownerZone, NAME_LEN );
345 
346  status = specCollSubStat( rsComm, specColl, objPath, UNKNOWN_COLL_PERM, &dataObjInfo );
347 
348  if ( status < 0 ) {
349  if ( dataObjInfo != NULL ) {
350  if ( dataObjInfo->specColl != NULL ) {
351  ( *rodsObjStatOut )->specColl = dataObjInfo->specColl;
352  }
353  else {
354  replSpecColl( &specCollCache->specColl,
355  &( *rodsObjStatOut )->specColl );
356  }
357  if ( specColl->collClass == LINKED_COLL ) {
358  rstrcpy( ( *rodsObjStatOut )->specColl->objPath,
359  dataObjInfo->objPath, MAX_NAME_LEN );
360  }
361  else {
362  ( *rodsObjStatOut )->specColl->objPath[0] = '\0';
363  }
364  dataObjInfo->specColl = NULL;
365  }
366  ( *rodsObjStatOut )->objType = UNKNOWN_OBJ_T;
367  rstrcpy( ( *rodsObjStatOut )->createTime, specCollCache->createTime,
368  TIME_LEN );
369  rstrcpy( ( *rodsObjStatOut )->modifyTime, specCollCache->modifyTime,
370  TIME_LEN );
371  freeAllDataObjInfo( dataObjInfo );
372  /* XXXXX 0 return is creating a problem for fuse */
373  return 0;
374  }
375  else {
376  ( *rodsObjStatOut )->specColl = dataObjInfo->specColl;
377  dataObjInfo->specColl = NULL;
378 
379  if ( specColl->collClass == LINKED_COLL ) {
380  rstrcpy( ( *rodsObjStatOut )->ownerName, dataObjInfo->dataOwnerName,
381  NAME_LEN );
382  rstrcpy( ( *rodsObjStatOut )->ownerZone, dataObjInfo->dataOwnerZone,
383  NAME_LEN );
384  snprintf( ( *rodsObjStatOut )->dataId, NAME_LEN, "%lld",
385  dataObjInfo->dataId );
386  /* save the linked path here */
387  rstrcpy( ( *rodsObjStatOut )->specColl->objPath,
388  dataObjInfo->objPath, MAX_NAME_LEN );
389  }
390  ( *rodsObjStatOut )->objType = ( objType_t )status;
391  ( *rodsObjStatOut )->objSize = dataObjInfo->dataSize;
392  rstrcpy( ( *rodsObjStatOut )->createTime, dataObjInfo->dataCreate,
393  TIME_LEN );
394  rstrcpy( ( *rodsObjStatOut )->modifyTime, dataObjInfo->dataModify,
395  TIME_LEN );
396  freeAllDataObjInfo( dataObjInfo );
397  }
398 
399  return status;
400 }
401 
402 /* specCollSubStat - Given specColl and the object path (subPath),
403  * returns a dataObjInfo struct with dataObjInfo->specColl != NULL.
404  * Returns COLL_OBJ_T if the path is a collection or DATA_OBJ_T if the
405  * path is a data oobject.
406  */
407 
408 int
409 specCollSubStat( rsComm_t *rsComm, specColl_t *specColl,
410  char *subPath, specCollPerm_t specCollPerm, dataObjInfo_t **dataObjInfo ) {
411  int status;
412  int objType;
414  dataObjInfo_t *myDataObjInfo = NULL;;
415 
416  if ( dataObjInfo == NULL ) {
417  return USER__NULL_INPUT_ERR;
418  }
419  *dataObjInfo = NULL;
420 
421  if ( specColl->collClass == MOUNTED_COLL ) {
422  /* a mount point */
423  myDataObjInfo = *dataObjInfo = ( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
424 
425  memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
426 
427  /*status = resolveResc (specColl->resource, &myDataObjInfo->rescInfo);
428  if (status < 0) {
429  rodsLog( LOG_ERROR,"specCollSubStat: resolveResc error for %s, status = %d",
430  specColl->resource, status);
431  freeDataObjInfo (myDataObjInfo);
432  *dataObjInfo = NULL;
433  return status;
434  }*/
435 
436  rstrcpy( myDataObjInfo->objPath, subPath, MAX_NAME_LEN );
437  rstrcpy( myDataObjInfo->subPath, subPath, MAX_NAME_LEN );
438  rstrcpy( myDataObjInfo->rescName, specColl->resource, NAME_LEN );
439  rstrcpy( myDataObjInfo->rescHier, specColl->rescHier, MAX_NAME_LEN );
440  rstrcpy( myDataObjInfo->dataType, "generic", NAME_LEN );
441  irods::error ret = resc_mgr.hier_to_leaf_id(myDataObjInfo->rescHier,myDataObjInfo->rescId);
442  if( !ret.ok() ) {
443  irods::log(PASS(ret));
444  }
445 
447  specColl->phyPath, subPath, myDataObjInfo->filePath );
448  if ( status < 0 ) {
449  freeDataObjInfo( myDataObjInfo );
450  *dataObjInfo = NULL;
451  return status;
452  }
453  replSpecColl( specColl, &myDataObjInfo->specColl );
454  }
455  else if ( specColl->collClass == LINKED_COLL ) {
456 
457  /* a link point */
458  specCollCache_t *specCollCache = NULL;
459  char newPath[MAX_NAME_LEN];
460  specColl_t *curSpecColl;
461  char *accessStr;
462  dataObjInp_t myDataObjInp;
463  rodsObjStat_t *rodsObjStatOut = NULL;
464 
465  *dataObjInfo = NULL;
466  curSpecColl = specColl;
467 
468  status = getMountedSubPhyPath( curSpecColl->collection,
469  curSpecColl->phyPath, subPath, newPath );
470  if ( status < 0 ) {
471  return status;
472  }
473 
474  status = resolveLinkedPath( rsComm, newPath, &specCollCache, NULL );
475  if ( status < 0 ) {
476  return status;
477  }
478  if ( specCollCache != NULL &&
479  specCollCache->specColl.collClass != LINKED_COLL ) {
480 
481  status = specCollSubStat( rsComm, &specCollCache->specColl,
482  newPath, specCollPerm, dataObjInfo );
483  return status;
484  }
485  bzero( &myDataObjInp, sizeof( myDataObjInp ) );
486  rstrcpy( myDataObjInp.objPath, newPath, MAX_NAME_LEN );
487 
488  status = collStat( rsComm, &myDataObjInp, &rodsObjStatOut );
489  if ( status >= 0 && NULL != rodsObjStatOut ) { /* a collection */ // JMC cppcheck - nullptr
490  myDataObjInfo = *dataObjInfo =
491  ( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
492  memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
493  replSpecColl( curSpecColl, &myDataObjInfo->specColl );
494  rstrcpy( myDataObjInfo->objPath, newPath, MAX_NAME_LEN );
495  myDataObjInfo->dataId = strtoll( rodsObjStatOut->dataId, 0, 0 );
496  rstrcpy( myDataObjInfo->dataOwnerName, rodsObjStatOut->ownerName, NAME_LEN );
497  rstrcpy( myDataObjInfo->dataOwnerZone, rodsObjStatOut->ownerZone, NAME_LEN );
498  rstrcpy( myDataObjInfo->dataCreate, rodsObjStatOut->createTime, TIME_LEN );
499  rstrcpy( myDataObjInfo->dataModify, rodsObjStatOut->modifyTime, TIME_LEN );
500  freeRodsObjStat( rodsObjStatOut );
501  return COLL_OBJ_T;
502  }
503  freeRodsObjStat( rodsObjStatOut );
504 
505  /* data object */
506  if ( specCollPerm == READ_COLL_PERM ) {
507  accessStr = ACCESS_READ_OBJECT;
508  }
509  else if ( specCollPerm == WRITE_COLL_PERM ) {
510  accessStr = ACCESS_DELETE_OBJECT;
511  }
512  else {
513  accessStr = NULL;
514  }
515 
516  status = getDataObjInfo( rsComm, &myDataObjInp, dataObjInfo,
517  accessStr, 0 );
518  if ( status < 0 ) {
519  myDataObjInfo = *dataObjInfo =
520  ( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
521  memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
522  replSpecColl( curSpecColl, &myDataObjInfo->specColl );
523  rstrcpy( myDataObjInfo->objPath, newPath, MAX_NAME_LEN );
525  "specCollSubStat: getDataObjInfo error for %s, status = %d",
526  newPath, status );
527  return status;
528  }
529  else {
530  replSpecColl( curSpecColl, &( *dataObjInfo )->specColl );
531  return DATA_OBJ_T;
532  }
533  }
534  else if ( getStructFileType( specColl ) >= 0 ) {
535 
536  /* bundle */
537  dataObjInp_t myDataObjInp;
538  dataObjInfo_t *tmpDataObjInfo;
539 
540  bzero( &myDataObjInp, sizeof( myDataObjInp ) );
541  rstrcpy( myDataObjInp.objPath, specColl->objPath, MAX_NAME_LEN );
542  // add the resource hierarchy to the condInput of the inp
543  addKeyVal( &myDataObjInp.condInput, RESC_HIER_STR_KW, specColl->rescHier );
544  status = getDataObjInfo( rsComm, &myDataObjInp, dataObjInfo, NULL, 1 );
545  if ( status < 0 ) {
547  "specCollSubStat: getDataObjInfo error for %s, status = %d",
548  myDataObjInp.objPath, status );
549  *dataObjInfo = NULL;
550  return status;
551  }
552 
553  /* screen out any stale copies */
554  status = sortObjInfoForOpen( dataObjInfo, &myDataObjInp.condInput, 0 );
555  if ( status < 0 ) {
557  "specCollSubStat: sortObjInfoForOpen error for %s. status = %d",
558  myDataObjInp.objPath, status );
559  return status;
560  }
561 
562  if ( strlen( specColl->resource ) > 0 ) {
563  if ( requeDataObjInfoByResc( dataObjInfo, specColl->resource,
564  0, 1 ) >= 0 ) {
565  if ( strstr( ( *dataObjInfo )->rescHier,
566  specColl->resource ) == 0 ) {
568  "specCollSubStat: %s in %s does not match cache resc %s",
569  myDataObjInp.objPath, ( *dataObjInfo )->rescName,
570  specColl->resource );
571  freeAllDataObjInfo( *dataObjInfo );
572  *dataObjInfo = NULL;
574  }
575  }
576  else {
578  "specCollSubStat: requeDataObjInfoByResc %s, resc %s error",
579  myDataObjInp.objPath, specColl->resource );
580  freeAllDataObjInfo( *dataObjInfo );
581  *dataObjInfo = NULL;
583  }
584  }
585 
586  /* free all the other dataObjInfo */
587  if ( ( *dataObjInfo )->next != NULL ) {
588  freeAllDataObjInfo( ( *dataObjInfo )->next );
589  ( *dataObjInfo )->next = NULL;
590  }
591 
592  /* fill in DataObjInfo */
593  tmpDataObjInfo = *dataObjInfo;
594  replSpecColl( specColl, &tmpDataObjInfo->specColl );
595  rstrcpy( specColl->resource, tmpDataObjInfo->rescName, NAME_LEN );
596  rstrcpy( specColl->rescHier, tmpDataObjInfo->rescHier, MAX_NAME_LEN );
597  rstrcpy( specColl->phyPath, tmpDataObjInfo->filePath, MAX_NAME_LEN );
598  rstrcpy( tmpDataObjInfo->subPath, subPath, MAX_NAME_LEN );
599  specColl->replNum = tmpDataObjInfo->replNum;
600 
601  if ( strcmp( ( *dataObjInfo )->subPath, specColl->collection ) == 0 ) {
602  /* no need to go down */
603  return COLL_OBJ_T;
604  }
605  }
606  else {
608  "specCollSubStat: Unknown specColl collClass = %d",
609  specColl->collClass );
611  }
612  status = l3Stat( rsComm, *dataObjInfo, &rodsStat );
613 
614  if ( status < 0 ) {
615  return status;
616  }
617 
618  if ( rodsStat->st_ctim != 0 ) {
619  snprintf( ( *dataObjInfo )->dataCreate, TIME_LEN, "%d", rodsStat->st_ctim );
620  snprintf( ( *dataObjInfo )->dataModify, TIME_LEN, "%d", rodsStat->st_mtim );
621  }
622 
623  if ( rodsStat->st_mode & S_IFDIR ) {
624  objType = COLL_OBJ_T;
625  }
626  else {
627  objType = DATA_OBJ_T;
628  ( *dataObjInfo )->dataSize = rodsStat->st_size;
629  }
630  free( rodsStat );
631 
632  return objType;
633 }
634 
635 /* resolvePathInSpecColl - given the object path in dataObjInp->objPath, see if
636  * it is in the path of a special collection (mounted or structfile).
637  * If it is not in a special collection, returns a -ive value.
638  * The inCachOnly flag asks it to check the specColl in the global cache only
639  * If it is, returns a dataObjInfo struct with dataObjInfo->specColl != NULL.
640  * Returns COLL_OBJ_T if the path is a collection or DATA_OBJ_T if the
641  * path is a data oobject.
642  */
643 int
644 resolvePathInSpecColl( rsComm_t *rsComm, char *objPath,
645  specCollPerm_t specCollPerm, int inCachOnly, dataObjInfo_t **dataObjInfo ) {
646  specCollCache_t *specCollCache;
647  specColl_t *cachedSpecColl;
648  int status;
649  char *accessStr;
650 
651  if ( objPath == NULL ) {
653  }
654  if ( ( status = getSpecCollCache( rsComm, objPath, inCachOnly,
655  &specCollCache ) ) < 0 ) {
656 
657  return status;
658  }
659  else {
660  cachedSpecColl = &specCollCache->specColl;
661  }
662 
663  if ( specCollPerm != UNKNOWN_COLL_PERM ) {
664  if ( specCollPerm == WRITE_COLL_PERM ) {
665  accessStr = ACCESS_DELETE_OBJECT;
666  }
667  else {
668  accessStr = ACCESS_READ_OBJECT;
669  }
670 
671  if ( specCollCache->perm < specCollPerm ) {
672  status = checkCollAccessPerm( rsComm, cachedSpecColl->collection,
673  accessStr );
674  if ( status < 0 ) {
676  "resolvePathInSpecColl:checkCollAccessPerm err for %s,stat=%d",
677  cachedSpecColl->collection, status );
678  return status;
679  }
680  else {
681  specCollCache->perm = specCollPerm;
682  }
683  }
684  }
685 
686  status = specCollSubStat( rsComm, cachedSpecColl, objPath,
687  specCollPerm, dataObjInfo );
688 
689  if ( status < 0 ) {
690  if ( *dataObjInfo != NULL ) {
691  /* does not exist. return the dataObjInfo anyway */
693  }
695  "resolvePathInSpecColl: specCollSubStat error for %s, status = %d",
696  objPath, status );
697  return status;
698  }
699  else {
700  if ( *dataObjInfo != NULL ) {
701  if ( specCollPerm == WRITE_COLL_PERM ) {
702  ( *dataObjInfo )->writeFlag = 1;
703  }
704  }
705  }
706 
707  return status;
708 }
709 
710 int
711 resolveLinkedPath( rsComm_t *rsComm, char *objPath,
712  specCollCache_t **specCollCache, keyValPair_t *condInput ) {
713  int linkCnt = 0;
714  specColl_t *curSpecColl;
715  char prevNewPath[MAX_NAME_LEN];
716  specCollCache_t *oldSpecCollCache = NULL;
717  int status;
718 
719  *specCollCache = NULL;
720 
721  if ( getValByKey( condInput, TRANSLATED_PATH_KW ) != NULL ) {
722  return 0;
723  }
724 
725  addKeyVal( condInput, TRANSLATED_PATH_KW, "" );
726  while ( (status = getSpecCollCache( rsComm, objPath, 0, specCollCache )) >= 0 &&
727  ( *specCollCache )->specColl.collClass == LINKED_COLL ) {
728  oldSpecCollCache = *specCollCache;
729  if ( linkCnt++ >= MAX_LINK_CNT ) {
731  "resolveLinkedPath: linkCnt for %s exceeds %d",
732  objPath, MAX_LINK_CNT );
734  }
735 
736  curSpecColl = &( *specCollCache )->specColl;
737  if ( strcmp( curSpecColl->collection, objPath ) == 0 &&
738  getValByKey( condInput, NO_TRANSLATE_LINKPT_KW ) != NULL ) {
739  return 0;
740  }
741  rstrcpy( prevNewPath, objPath, MAX_NAME_LEN );
742  status = getMountedSubPhyPath( curSpecColl->collection,
743  curSpecColl->phyPath, prevNewPath, objPath );
744  if ( status < 0 ) {
745  return status;
746  }
747  }
748  if ( *specCollCache == NULL ) {
749  *specCollCache = oldSpecCollCache;
750  }
751  // Issue 3913 - this failure must be bubbled up to the user
752  if (status == USER_STRLEN_TOOLONG) {
753  return USER_STRLEN_TOOLONG;
754  }
755  return linkCnt;
756 }
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
getValByKey
char * getValByKey(const keyValPair_t *condInput, const char *keyWord)
Definition: rcMisc.cpp:675
DataObjInp::objPath
char objPath[(1024+64)]
Definition: dataObjInpOut.h:66
COL_COLL_OWNER_ZONE
#define COL_COLL_OWNER_ZONE
Definition: rodsGenQuery.h:192
MAX_SQL_ROWS
#define MAX_SQL_ROWS
Definition: rodsGenQuery.h:16
NULL
#define NULL
Definition: rodsDef.h:70
rodsStat::st_mode
unsigned int st_mode
Definition: rodsType.h:56
ACCESS_READ_OBJECT
#define ACCESS_READ_OBJECT
Definition: icatDefines.h:52
rsComm_t
Definition: rcConnect.h:145
getPhyPath
int getPhyPath(rsComm_t *rsComm, char *objName, char *resource, char *phyPath, char *rescHier)
Definition: objMetaOpr.cpp:86
addKeyVal
int addKeyVal(keyValPair_t *condInput, const char *keyWord, const char *value)
Definition: rcMisc.cpp:789
SYS_INTERNAL_NULL_INPUT_ERR
@ SYS_INTERNAL_NULL_INPUT_ERR
Definition: rodsErrorTable.h:92
rodsStat::st_ctim
unsigned int st_ctim
Definition: rodsType.h:63
DataObjInfo::dataCreate
char dataCreate[32]
Definition: objInfo.h:150
statPathInSpecColl
int statPathInSpecColl(rsComm_t *rsComm, char *objPath, int inCachOnly, rodsObjStat_t **rodsObjStatOut)
Definition: specColl.cpp:319
COLLECTION_INFO2_KW
#define COLLECTION_INFO2_KW
Definition: rodsKeyWdDef.h:69
DataObjInfo::dataModify
char dataModify[32]
Definition: objInfo.h:151
specColl.hpp
modColl.h
CollInp
Definition: dataObjInpOut.h:157
UNMATCHED_KEY_OR_INDEX
@ UNMATCHED_KEY_OR_INDEX
Definition: rodsErrorTable.h:244
SpecColl::resource
char resource[64]
Definition: objInfo.h:83
rodsObjStat::dataId
char dataId[64]
Definition: objStat.h:12
UNKNOWN_OBJ_T
@ UNKNOWN_OBJ_T
Definition: rodsType.h:37
resolveSpecCollType
int resolveSpecCollType(char *type, char *collection, char *collInfo1, char *collInfo2, specColl_t *specColl)
Definition: rcMisc.cpp:3127
SpecCollCacheHead
specCollCache_t * SpecCollCacheHead
Definition: irods_server_globals.cpp:49
SpecCollCache::ownerName
char ownerName[64]
Definition: objInfo.h:106
irods_stacktrace.hpp
PASS
#define PASS(prev_error_)
Definition: irods_error.hpp:118
resc_mgr
irods::resource_manager resc_mgr
Definition: irods_resource_manager.cpp:31
SpecCollCache::ownerZone
char ownerZone[64]
Definition: objInfo.h:107
DataObjInfo::dataOwnerZone
char dataOwnerZone[64]
Definition: objInfo.h:139
SpecCollCache::perm
specCollPerm_t perm
Definition: objInfo.h:103
makeCachedStructFileStr
int makeCachedStructFileStr(char *collInfo2, specColl_t *specColl)
Definition: rcMisc.cpp:3242
SYS_SPEC_COLL_OBJ_NOT_EXIST
@ SYS_SPEC_COLL_OBJ_NOT_EXIST
Definition: rodsErrorTable.h:123
COL_COLL_OWNER_NAME
#define COL_COLL_OWNER_NAME
Definition: rodsGenQuery.h:191
specCollSubStat
int specCollSubStat(rsComm_t *rsComm, specColl_t *specColl, char *subPath, specCollPerm_t specCollPerm, dataObjInfo_t **dataObjInfo)
Definition: specColl.cpp:409
GenQueryInp
Definition: rodsGenQuery.h:24
DataObjInfo::dataType
char dataType[64]
Definition: objInfo.h:133
SpecColl::phyPath
char phyPath[(1024+64)]
Definition: objInfo.h:85
rcMisc.h
queueSpecCollCache
int queueSpecCollCache(rsComm_t *rsComm, genQueryOut_t *genQueryOut, char *objPath)
Definition: specColl.cpp:83
freeDataObjInfo
int freeDataObjInfo(dataObjInfo_t *dataObjInfo)
Definition: rcMisc.cpp:544
SpecCollCache::next
struct SpecCollCache * next
Definition: objInfo.h:110
SpecColl::cacheDir
char cacheDir[(1024+64)]
Definition: objInfo.h:89
DataObjInfo::rescId
rodsLong_t rescId
Definition: objInfo.h:164
SpecColl::type
structFileType_t type
Definition: objInfo.h:78
querySpecColl
int querySpecColl(rsComm_t *rsComm, char *objPath, genQueryOut_t **genQueryOut)
Definition: specColl.cpp:33
getStructFileType
int getStructFileType(specColl_t *specColl)
Definition: objMetaOpr.cpp:386
DataObjInfo::rescHier
char rescHier[(1024+64)]
Definition: objInfo.h:132
rodsObjStat::ownerName
char ownerName[64]
Definition: objStat.h:14
SpecColl::replNum
int replNum
Definition: objInfo.h:93
rodsStat::st_mtim
unsigned int st_mtim
Definition: rodsType.h:62
collStat
int collStat(rsComm_t *rsComm, dataObjInp_t *dataObjInp, rodsObjStat_t **rodsObjStatOut)
Definition: collection.cpp:271
irods_resource_backport.hpp
SpecColl
Definition: objInfo.h:76
WRITE_COLL_PERM
@ WRITE_COLL_PERM
Definition: objInfo.h:99
COL_COLL_ID
#define COL_COLL_ID
Definition: rodsGenQuery.h:188
SpecCollCache::collId
char collId[64]
Definition: objInfo.h:105
STRUCT_FILE_COLL
@ STRUCT_FILE_COLL
Definition: objInfo.h:47
DataObjInfo::filePath
char filePath[(1024+64)]
Definition: objInfo.h:137
addInxVal
int addInxVal(inxValPair_t *inxValPair, int inx, const char *value)
Definition: rcMisc.cpp:921
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
modCollInfo2
int modCollInfo2(rsComm_t *rsComm, specColl_t *specColl, int clearFlag)
Definition: specColl.cpp:285
NO_TRANSLATE_LINKPT_KW
#define NO_TRANSLATE_LINKPT_KW
Definition: rodsKeyWdDef.h:98
DataObjInfo::dataId
rodsLong_t dataId
Definition: objInfo.h:143
checkCollAccessPerm
int checkCollAccessPerm(rsComm_t *rsComm, char *collection, char *accessPerm)
Definition: collection.cpp:35
GenQueryInp::selectInp
inxIvalPair_t selectInp
Definition: rodsGenQuery.h:53
GenQueryInp::maxRows
int maxRows
Definition: rodsGenQuery.h:25
DataObjInfo::specColl
specColl_t * specColl
Definition: objInfo.h:158
COL_COLL_MODIFY_TIME
#define COL_COLL_MODIFY_TIME
Definition: rodsGenQuery.h:197
rodsStat::st_size
rodsLong_t st_size
Definition: rodsType.h:53
freeRodsObjStat
int freeRodsObjStat(rodsObjStat_t *rodsObjStat)
Definition: rcMisc.cpp:3537
COLL_OBJ_T
@ COLL_OBJ_T
Definition: rodsType.h:39
matchSpecCollCache
specCollCache_t * matchSpecCollCache(char *objPath)
Definition: specColl.cpp:236
rodsStat
Definition: rodsType.h:52
LINKED_COLL
@ LINKED_COLL
Definition: objInfo.h:49
RESC_HIER_STR_KW
#define RESC_HIER_STR_KW
Definition: rodsKeyWdDef.h:225
l3Stat
int l3Stat(rsComm_t *rsComm, dataObjInfo_t *dataObjInfo, rodsStat_t **myStat)
Definition: rsDataObjClose.cpp:768
rodsObjStat::modifyTime
char modifyTime[32]
Definition: objStat.h:17
getSqlResultByInx
sqlResult_t * getSqlResultByInx(genQueryOut_t *genQueryOut, int attriInx)
Definition: rcMisc.cpp:1387
LOG_DEBUG
#define LOG_DEBUG
Definition: rodsLog.h:23
DataObjInfo::dataOwnerName
char dataOwnerName[64]
Definition: objInfo.h:138
freeAllDataObjInfo
int freeAllDataObjInfo(dataObjInfo_t *dataObjInfoHead)
Definition: rcMisc.cpp:561
rsModColl
int rsModColl(rsComm_t *rsComm, collInp_t *modCollInp)
Definition: rsModColl.cpp:14
TIME_LEN
#define TIME_LEN
Definition: rodsDef.h:54
rsModColl.hpp
SYS_LINK_CNT_EXCEEDED_ERR
@ SYS_LINK_CNT_EXCEEDED_ERR
Definition: rodsErrorTable.h:173
getSpecCollCache
int getSpecCollCache(rsComm_t *rsComm, char *objPath, int inCachOnly, specCollCache_t **specCollCache)
Definition: specColl.cpp:255
UNKNOWN_COLL_PERM
@ UNKNOWN_COLL_PERM
Definition: objInfo.h:97
GenQueryInp::sqlCondInp
inxValPair_t sqlCondInp
Definition: rodsGenQuery.h:56
DataObjInp
Definition: dataObjInpOut.h:65
rsDataObjClose.hpp
genQuery.h
queueSpecCollCacheWithObjStat
int queueSpecCollCacheWithObjStat(rodsObjStat_t *rodsObjStatOut)
Definition: specColl.cpp:213
MAX_NAME_LEN
#define MAX_NAME_LEN
Definition: rodsDef.h:61
specCollPerm_t
specCollPerm_t
Definition: objInfo.h:96
addInxIval
int addInxIval(inxIvalPair_t *inxIvalPair, int inx, int value)
Definition: rcMisc.cpp:883
CollInp::condInput
keyValPair_t condInput
Definition: dataObjInpOut.h:161
GenQueryOut
Definition: rodsGenQuery.h:67
sortObjInfoForOpen
int sortObjInfoForOpen(dataObjInfo_t **dataObjInfoHead, keyValPair_t *condInput, int writeFlag)
Definition: dataObjOpr.cpp:548
DataObjInfo::replNum
int replNum
Definition: objInfo.h:140
collType
ReIterableType collType(Res *coll)
Definition: functions.cpp:323
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
SpecColl::rescHier
char rescHier[(1024+64)]
Definition: objInfo.h:84
TRANSLATED_PATH_KW
#define TRANSLATED_PATH_KW
Definition: rodsKeyWdDef.h:97
READ_COLL_PERM
@ READ_COLL_PERM
Definition: objInfo.h:98
collection.hpp
GenQueryOut::rowCnt
int rowCnt
Definition: rodsGenQuery.h:68
irods::log
void log(const error &)
Definition: irods_log.cpp:13
LOG_NOTICE
#define LOG_NOTICE
Definition: rodsLog.h:33
rodsObjStat::ownerZone
char ownerZone[64]
Definition: objStat.h:15
icatDefines.h
dataObjClose.h
getDataObjInfo
int getDataObjInfo(rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t **dataObjInfoHead, char *accessPerm, int ignoreCondInput)
Definition: dataObjOpr.cpp:87
COL_COLL_TYPE
#define COL_COLL_TYPE
Definition: rodsGenQuery.h:198
irods::error
Definition: irods_error.hpp:23
DATA_OBJ_T
@ DATA_OBJ_T
Definition: rodsType.h:38
SpecColl::collection
char collection[(1024+64)]
Definition: objInfo.h:79
SqlResult::value
char * value
Definition: rodsGenQuery.h:64
resolveLinkedPath
int resolveLinkedPath(rsComm_t *rsComm, char *objPath, specCollCache_t **specCollCache, keyValPair_t *condInput)
Definition: specColl.cpp:711
SpecCollCache::modifyTime
char modifyTime[64]
Definition: objInfo.h:109
FailedSpecCollPath
static char FailedSpecCollPath[(1024+64)]
Definition: specColl.cpp:24
SYS_UNKNOWN_SPEC_COLL_CLASS
@ SYS_UNKNOWN_SPEC_COLL_CLASS
Definition: rodsErrorTable.h:127
TAR_STRUCT_FILE_T
@ TAR_STRUCT_FILE_T
Definition: objInfo.h:55
irods::resource_manager::hier_to_leaf_id
error hier_to_leaf_id(const std::string &, rodsLong_t &)
Definition: irods_resource_manager.cpp:1082
DataObjInfo::rescName
char rescName[64]
Definition: objInfo.h:131
CAT_NO_ROWS_FOUND
@ CAT_NO_ROWS_FOUND
Definition: rodsErrorTable.h:423
SqlResult
Definition: rodsGenQuery.h:61
USER_STRLEN_TOOLONG
@ USER_STRLEN_TOOLONG
Definition: rodsErrorTable.h:237
SYS_SPEC_COLL_NOT_IN_CACHE
@ SYS_SPEC_COLL_NOT_IN_CACHE
Definition: rodsErrorTable.h:122
COL_COLL_NAME
#define COL_COLL_NAME
Definition: rodsGenQuery.h:189
MOUNTED_COLL
@ MOUNTED_COLL
Definition: objInfo.h:48
resource.hpp
replSpecColl
int replSpecColl(specColl_t *inSpecColl, specColl_t **outSpecColl)
Definition: rcMisc.cpp:778
SqlResult::len
int len
Definition: rodsGenQuery.h:63
CollInp::collName
char collName[(1024+64)]
Definition: dataObjInpOut.h:158
COL_COLL_CREATE_TIME
#define COL_COLL_CREATE_TIME
Definition: rodsGenQuery.h:196
rodsObjStat
Definition: objStat.h:8
rodsObjStat::createTime
char createTime[32]
Definition: objStat.h:16
DataObjInfo::objPath
char objPath[(1024+64)]
Definition: objInfo.h:130
rodsObjStat::specColl
specColl_t * specColl
Definition: objStat.h:18
resolvePathInSpecColl
int resolvePathInSpecColl(rsComm_t *rsComm, char *objPath, specCollPerm_t specCollPerm, int inCachOnly, dataObjInfo_t **dataObjInfo)
Definition: specColl.cpp:644
rsGenQuery.hpp
HaveFailedSpecCollPath
static int HaveFailedSpecCollPath
Definition: specColl.cpp:23
rstrcpy
char * rstrcpy(char *dest, const char *src, int maxLen)
Definition: stringOpr.cpp:51
dataObjOpr.hpp
COL_COLL_INFO1
#define COL_COLL_INFO1
Definition: rodsGenQuery.h:199
DataObjInp::condInput
keyValPair_t condInput
Definition: dataObjInpOut.h:74
requeDataObjInfoByResc
int requeDataObjInfoByResc(dataObjInfo_t **dataObjInfoHead, const char *preferedResc, int writeFlag, int topFlag)
Definition: dataObjOpr.cpp:760
ACCESS_DELETE_OBJECT
#define ACCESS_DELETE_OBJECT
Definition: icatDefines.h:60
freeGenQueryOut
int freeGenQueryOut(genQueryOut_t **genQueryOut)
Definition: rcMisc.cpp:1133
NAME_LEN
#define NAME_LEN
Definition: rodsDef.h:55
KeyValPair
Definition: objInfo.h:120
SpecCollCache::createTime
char createTime[64]
Definition: objInfo.h:108
irods::error::ok
bool ok()
Definition: irods_error.cpp:258
SpecColl::objPath
char objPath[(1024+64)]
Definition: objInfo.h:80
getMountedSubPhyPath
int getMountedSubPhyPath(char *logMountPoint, char *phyMountPoint, char *logSubPath, char *phySubPathOut)
Definition: rcMisc.cpp:3078
DataObjInfo
Definition: objInfo.h:129
DataObjInfo::dataSize
rodsLong_t dataSize
Definition: objInfo.h:134
clearGenQueryInp
void clearGenQueryInp(void *voidInp)
Definition: rcMisc.cpp:1118
COL_COLL_INFO2
#define COL_COLL_INFO2
Definition: rodsGenQuery.h:200
rsGenQuery
int rsGenQuery(rsComm_t *rsComm, genQueryInp_t *genQueryInp, genQueryOut_t **genQueryOut)
Definition: rsGenQuery.cpp:604
SpecCollCache::specColl
specColl_t specColl
Definition: objInfo.h:104
MAX_LINK_CNT
#define MAX_LINK_CNT
Definition: objInfo.h:40
SpecCollCache
Definition: objInfo.h:102
objMetaOpr.hpp
objType_t
objType_t
Definition: rodsType.h:36
SpecColl::collClass
specCollClass_t collClass
Definition: objInfo.h:77
DataObjInfo::subPath
char subPath[(1024+64)]
Definition: objInfo.h:157
USER__NULL_INPUT_ERR
@ USER__NULL_INPUT_ERR
Definition: rodsErrorTable.h:247
SYS_CACHE_STRUCT_FILE_RESC_ERR
@ SYS_CACHE_STRUCT_FILE_RESC_ERR
Definition: rodsErrorTable.h:132