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)  

lsUtil.cpp
Go to the documentation of this file.
1 #include "rodsPath.h"
2 #include "rodsErrorTable.h"
3 #include "rodsLog.h"
4 #include "lsUtil.h"
5 #include "miscUtil.h"
6 #include "rcGlobalExtern.h"
7 
8 #include "filesystem.hpp"
9 #include "irods_query.hpp"
10 
11 #include <boost/format.hpp>
12 
14 
15 int
16 lsUtil( rcComm_t *conn, rodsEnv *myRodsEnv, rodsArguments_t *myRodsArgs,
17  rodsPathInp_t *rodsPathInp ) {
18 
19  if ( rodsPathInp == NULL ) {
20  return USER__NULL_INPUT_ERR;
21  }
22 
23  if ( myRodsArgs->ticket == True ) {
24  if ( myRodsArgs->ticketString == NULL ) {
25  rodsLog( LOG_ERROR, "initCondForPut: NULL ticketString error" );
26  return USER__NULL_INPUT_ERR;
27  }
28 
29  setSessionTicket( conn, myRodsArgs->ticketString );
30  }
31 
32  genQueryInp_t genQueryInp;
33  initCondForLs( &genQueryInp );
34 
35  int savedStatus = 0;
36 
37  for ( int i = 0; i < rodsPathInp->numSrc; i++ ) {
38  int status = 0;
39  rstrcpy( zoneHint, rodsPathInp->srcPath[i].outPath, MAX_NAME_LEN );
40 
41  namespace fs = irods::experimental::filesystem;
42 
43  auto* src_path = rodsPathInp->srcPath[i].outPath;
44  const auto object_status = fs::client::status(*conn, src_path);
45 
46  if (!fs::client::exists(object_status)) {
47  rodsLog(LOG_ERROR, "lsUtil: srcPath %s does not exist or user lacks access permission", src_path);
48  savedStatus = USER_INPUT_PATH_ERR;
49  continue;
50  }
51 
52  // Need to populate dataId in srcPath as it is needed for getting permissions info
53  char coll_name[MAX_NAME_LEN]{};
54  char data_name[MAX_NAME_LEN]{};
55  status = splitPathByKey(rodsPathInp->srcPath[i].outPath, coll_name, MAX_NAME_LEN, data_name, MAX_NAME_LEN, '/');
56  if (status < 0) {
57  return status;
58  }
59 
60  const std::string query_str{(boost::format(
61  "select DATA_ID where DATA_NAME = '%s' and COLL_NAME = '%s'") % data_name % coll_name).str()};
62  irods::query<rcComm_t> qobj{conn, query_str};
63  if (qobj.size() > 0) {
64  const auto id = qobj.front()[0];
65  if (!id.empty()) {
66  rstrcpy(rodsPathInp->srcPath[i].dataId, id.c_str(), sizeof(rodsPathInp->srcPath[i].dataId));
67  }
68  }
69 
70  if (fs::client::is_data_object(object_status)) {
71  status = lsDataObjUtil( conn, &rodsPathInp->srcPath[i], myRodsArgs, &genQueryInp );
72  }
73  else if (fs::client::is_collection(object_status)) {
74  status = lsCollUtil( conn, &rodsPathInp->srcPath[i], myRodsEnv, myRodsArgs );
75  }
76  else {
77  /* should not be here */
78  rodsLog(LOG_ERROR, "lsUtil: invalid ls objType %d for %s", rodsPathInp->srcPath[i].objType, src_path);
79  return USER_INPUT_PATH_ERR;
80  }
81 
82  /* XXXX may need to return a global status */
84  rodsLogError(LOG_ERROR, status, "lsUtil: ls error for %s, status = %d", src_path, status);
85  savedStatus = status;
86  }
87  }
88 
89  return savedStatus;
90 }
91 
92 int
94  rodsArguments_t *rodsArgs, genQueryInp_t *genQueryInp ) {
95  int status = 0;
96 
97 
98  if ( rodsArgs->longOption == True ) {
99  if ( srcPath->rodsObjStat != NULL &&
100  srcPath->rodsObjStat->specColl != NULL ) {
101  if ( srcPath->rodsObjStat->specColl->collClass == LINKED_COLL ) {
102  lsDataObjUtilLong( conn, srcPath->rodsObjStat->specColl->objPath,
103  rodsArgs, genQueryInp );
104  }
105  else {
106  lsSpecDataObjUtilLong( srcPath, rodsArgs );
107  }
108  }
109  else {
110  lsDataObjUtilLong( conn, srcPath->outPath, rodsArgs, genQueryInp );
111  }
112  }
113  else if ( rodsArgs->bundle == True ) {
114  lsSubfilesInBundle( conn, srcPath->outPath );
115  }
116  else {
117  printLsStrShort( srcPath->outPath );
118  if ( rodsArgs->accessControl == True ) {
119  printDataAcl( conn, srcPath->dataId );
120  }
121  }
122 
123  if ( srcPath == NULL ) {
125  "lsDataObjUtil: NULL srcPath input" );
126  return USER__NULL_INPUT_ERR;
127  }
128 
129  return status;
130 }
131 
132 int
133 printLsStrShort( char *srcPath ) {
134  printf( " %s\n", srcPath );
135  return 0;
136 }
137 
138 int
139 lsDataObjUtilLong( rcComm_t *conn, char *srcPath,
140  rodsArguments_t *rodsArgs, genQueryInp_t *genQueryInp ) {
141  int status;
142  genQueryOut_t *genQueryOut = NULL;
143  char myColl[MAX_NAME_LEN], myData[MAX_NAME_LEN];
144  char condStr[MAX_NAME_LEN];
145  int queryFlags;
146 
147  queryFlags = setQueryFlag( rodsArgs );
148  setQueryInpForData( queryFlags, genQueryInp );
149  genQueryInp->maxRows = MAX_SQL_ROWS;
150 
151  memset( myColl, 0, MAX_NAME_LEN );
152  memset( myData, 0, MAX_NAME_LEN );
153 
154  if ( ( status = splitPathByKey(
155  srcPath, myColl, MAX_NAME_LEN, myData, MAX_NAME_LEN, '/' ) ) < 0 ) {
157  "setQueryInpForLong: splitPathByKey for %s error, status = %d",
158  srcPath, status );
159  return status;
160  }
161 
162  // Need to clear each time in case there are multiple inputs to ils -l
163  clearInxVal( &genQueryInp->sqlCondInp );
164  snprintf( condStr, MAX_NAME_LEN, "='%s'", myColl );
165  addInxVal( &genQueryInp->sqlCondInp, COL_COLL_NAME, condStr );
166  snprintf( condStr, MAX_NAME_LEN, "='%s'", myData );
167  addInxVal( &genQueryInp->sqlCondInp, COL_DATA_NAME, condStr );
168 
169  status = rcGenQuery( conn, genQueryInp, &genQueryOut );
170 
171  if ( status < 0 ) {
172  if ( status == CAT_NO_ROWS_FOUND ) {
173  rodsLog( LOG_ERROR, "%s does not exist or user lacks access permission",
174  srcPath );
175  }
176  else {
178  "lsDataObjUtilLong: rcGenQuery error for %s", srcPath );
179  }
180  return status;
181  }
182  printLsLong( conn, rodsArgs, genQueryOut );
183 
184  return 0;
185 }
186 
187 int
189  genQueryOut_t *genQueryOut ) {
190  int i = 0;
191  sqlResult_t *dataName = 0, *replNum = 0, *dataSize = 0, *rescName = 0,
192  *replStatus = 0, *dataModify = 0, *dataOwnerName = 0, *dataId = 0;
193  sqlResult_t *chksumStr = 0, *dataPath = 0, *dataType = 0,*rescHier;
194 
195  char *tmpDataId = 0;
196  int queryFlags = 0;
197 
198  if ( genQueryOut == NULL ) {
199  return USER__NULL_INPUT_ERR;
200  }
201 
202  queryFlags = setQueryFlag( rodsArgs );
203 
204  if ( rodsArgs->veryLongOption == True ) {
205  if ( ( chksumStr = getSqlResultByInx( genQueryOut, COL_D_DATA_CHECKSUM ) )
206  == NULL ) {
208  "printLsLong: getSqlResultByInx for COL_D_DATA_CHECKSUM failed" );
209  return UNMATCHED_KEY_OR_INDEX;
210  }
211 
212  if ( ( dataPath = getSqlResultByInx( genQueryOut, COL_D_DATA_PATH ) )
213  == NULL ) {
215  "printLsLong: getSqlResultByInx for COL_D_DATA_PATH failed" );
216  return UNMATCHED_KEY_OR_INDEX;
217  }
218 
219  if ( ( dataType = getSqlResultByInx( genQueryOut, COL_DATA_TYPE_NAME ) ) == NULL ) {
220 
222  "printLsLong: getSqlResultByInx for COL_DATA_TYPE_NAME failed" );
223  return UNMATCHED_KEY_OR_INDEX;
224  }
225  }
226 
227  if ( ( dataId = getSqlResultByInx( genQueryOut, COL_D_DATA_ID ) ) == NULL ) {
229  "printLsLong: getSqlResultByInx for COL_D_DATA_ID failed" );
230  return UNMATCHED_KEY_OR_INDEX;
231  }
232 
233  if ( ( dataName = getSqlResultByInx( genQueryOut, COL_DATA_NAME ) ) == NULL ) {
235  "printLsLong: getSqlResultByInx for COL_DATA_NAME failed" );
236  return UNMATCHED_KEY_OR_INDEX;
237  }
238 
239  if ( ( replNum = getSqlResultByInx( genQueryOut, COL_DATA_REPL_NUM ) ) ==
240  NULL ) {
242  "printLsLong: getSqlResultByInx for COL_DATA_REPL_NUM failed" );
243  return UNMATCHED_KEY_OR_INDEX;
244  }
245 
246  if ( ( dataSize = getSqlResultByInx( genQueryOut, COL_DATA_SIZE ) ) == NULL ) {
248  "printLsLong: getSqlResultByInx for COL_DATA_SIZE failed" );
249  return UNMATCHED_KEY_OR_INDEX;
250  }
251 
252  if ( ( rescName = getSqlResultByInx( genQueryOut, COL_D_RESC_NAME ) ) == NULL ) {
254  "printLsLong: getSqlResultByInx for COL_D_RESC_NAME failed" );
255  return UNMATCHED_KEY_OR_INDEX;
256  }
257 
258  if ( ( rescHier = getSqlResultByInx( genQueryOut, COL_D_RESC_HIER ) ) == NULL ) {
259  // If the index is not found then COL_D_RESC_HIER was most likely stripped
260  // from the query input to talk to an older zone.
261  // use resource name instead
262  rescHier = rescName;
263  }
264 
265  if ( ( replStatus = getSqlResultByInx( genQueryOut, COL_D_REPL_STATUS ) ) ==
266  NULL ) {
268  "printLsLong: getSqlResultByInx for COL_D_REPL_STATUS failed" );
269  return UNMATCHED_KEY_OR_INDEX;
270  }
271 
272  if ( ( dataModify = getSqlResultByInx( genQueryOut, COL_D_MODIFY_TIME ) ) ==
273  NULL ) {
275  "printLsLong: getSqlResultByInx for COL_D_MODIFY_TIME failed" );
276  return UNMATCHED_KEY_OR_INDEX;
277  }
278 
279  if ( ( dataOwnerName = getSqlResultByInx( genQueryOut, COL_D_OWNER_NAME ) ) ==
280  NULL ) {
282  "printLsLong: getSqlResultByInx for COL_D_OWNER_NAME failed" );
283  return UNMATCHED_KEY_OR_INDEX;
284  }
285 
286  queryHandle_t query_handle;
287  rclInitQueryHandle( &query_handle, conn );
288  for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
289  collEnt_t collEnt;
290 
291  bzero( &collEnt, sizeof( collEnt ) );
292 
293  collEnt.dataName = &dataName->value[dataName->len * i];
294  collEnt.replNum = atoi( &replNum->value[replNum->len * i] );
295  collEnt.dataSize = strtoll( &dataSize->value[dataSize->len * i], 0, 0 );
296  collEnt.resource = &rescName->value[rescName->len * i];
297  collEnt.ownerName = &dataOwnerName->value[dataOwnerName->len * i];
298  collEnt.replStatus = atoi( &replStatus->value[replStatus->len * i] );
299  collEnt.modifyTime = &dataModify->value[dataModify->len * i];
300  collEnt.resc_hier = &rescHier->value[rescHier->len * i];
301 
302  if ( rodsArgs->veryLongOption == True ) {
303  collEnt.chksum = &chksumStr->value[chksumStr->len * i];
304  collEnt.phyPath = &dataPath->value[dataPath->len * i];
305  collEnt.dataType = &dataType->value[dataType->len * i];
306  }
307 
308  printDataCollEntLong( &collEnt, queryFlags );
309 
310  if ( rodsArgs->accessControl == True ) {
311  tmpDataId = &dataId->value[dataId->len * i];
312  printDataAcl( conn, tmpDataId );
313  }
314  }
315 
316  return 0;
317 }
318 
319 int
321  char sizeStr[NAME_LEN];
322  int status;
324 
325  snprintf( sizeStr, NAME_LEN, "%lld", rodsObjStat->objSize );
328  rodsArgs );
329 
330  return status;
331 }
332 
333 
334 int
336  genQueryOut_t *genQueryOut ) {
337  int i;
338 
339  sqlResult_t *dataName, *dataId;
340  char *tmpDataName, *tmpDataId;
341 
342  if ( genQueryOut == NULL ) {
343  return USER__NULL_INPUT_ERR;
344  }
345 
346  if ( ( dataId = getSqlResultByInx( genQueryOut, COL_D_DATA_ID ) ) == NULL ) {
348  "printLsShort: getSqlResultByInx for COL_D_DATA_ID failed" );
349  return UNMATCHED_KEY_OR_INDEX;
350  }
351 
352  if ( ( dataName = getSqlResultByInx( genQueryOut, COL_DATA_NAME ) ) == NULL ) {
354  "printLsShort: getSqlResultByInx for COL_DATA_NAME failed" );
355  return UNMATCHED_KEY_OR_INDEX;
356  }
357 
358  for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
359  tmpDataName = &dataName->value[dataName->len * i];
360  printLsStrShort( tmpDataName );
361 
362  if ( rodsArgs->accessControl == True ) {
363  tmpDataId = &dataId->value[dataId->len * i];
364  printDataAcl( conn, tmpDataId );
365  }
366  }
367 
368  return 0;
369 }
370 
371 int
372 initCondForLs( genQueryInp_t *genQueryInp ) {
373  if ( genQueryInp == NULL ) {
375  "initCondForLs: NULL genQueryInp input" );
376  return USER__NULL_INPUT_ERR;
377  }
378 
379  memset( genQueryInp, 0, sizeof( genQueryInp_t ) );
380 
381  return 0;
382 }
383 
384 int
385 lsCollUtil( rcComm_t *conn, rodsPath_t *srcPath, rodsEnv *myRodsEnv,
386  rodsArguments_t *rodsArgs ) {
387  int savedStatus = 0;
388  char *srcColl;
389  int status;
390  int queryFlags;
391  collHandle_t collHandle;
392  collEnt_t collEnt;
393 
394  if ( srcPath == NULL ) {
396  "lsCollUtil: NULL srcPath input" );
397  return USER__NULL_INPUT_ERR;
398  }
399 
400  srcColl = srcPath->outPath;
401 
402  /* print this collection */
403  printf( "%s:\n", srcColl );
404 
405  if ( rodsArgs->accessControl == True ) {
406  printCollAcl( conn, srcColl );
407  printCollInheritance( conn, srcColl );
408  }
409 
410  queryFlags = DATA_QUERY_FIRST_FG;
411  if ( rodsArgs->veryLongOption == True ) {
412  /* need to check veryLongOption first since it will have both
413  * veryLongOption and longOption flags on. */
414  queryFlags = queryFlags | VERY_LONG_METADATA_FG | NO_TRIM_REPL_FG;
415  }
416  else if ( rodsArgs->longOption == True ) {
417  queryFlags |= LONG_METADATA_FG | NO_TRIM_REPL_FG;;
418  }
419 
420  status = rclOpenCollection( conn, srcColl, queryFlags,
421  &collHandle );
422 
423  if ( status < 0 ) {
425  "lsCollUtil: rclOpenCollection of %s error. status = %d",
426  srcColl, status );
427  return status;
428  }
429  while ( ( status = rclReadCollection( conn, &collHandle, &collEnt ) ) >= 0 ) {
430  if ( collEnt.objType == DATA_OBJ_T ) {
431  if ( rodsArgs->bundle == True ) {
432  char myPath[MAX_NAME_LEN];
433  snprintf( myPath, MAX_NAME_LEN, "%s/%s", collEnt.collName,
434  collEnt.dataName );
435  lsSubfilesInBundle( conn, myPath );
436  }
437  else {
438  printDataCollEnt( &collEnt, queryFlags );
439  if ( rodsArgs->accessControl == True ) {
440  printDataAcl( conn, collEnt.dataId );
441  }
442  }
443  }
444  else {
445  printCollCollEnt( &collEnt, queryFlags );
446  /* need to drill down */
447  if ( rodsArgs->recursive == True &&
448  strcmp( collEnt.collName, "/" ) != 0 ) {
449  rodsPath_t tmpPath;
450  memset( &tmpPath, 0, sizeof( tmpPath ) );
451  rstrcpy( tmpPath.outPath, collEnt.collName, MAX_NAME_LEN );
452  status = lsCollUtil( conn, &tmpPath, myRodsEnv, rodsArgs );
453  if ( status < 0 ) {
454  savedStatus = status;
455  }
456  }
457  }
458  }
459  rclCloseCollection( &collHandle );
460  if ( savedStatus < 0 && savedStatus != CAT_NO_ROWS_FOUND ) {
461  return savedStatus;
462  }
463  else {
464  return 0;
465  }
466 }
467 
468 int
469 printDataCollEnt( collEnt_t *collEnt, int flags ) {
470  if ( ( flags & ( LONG_METADATA_FG | VERY_LONG_METADATA_FG ) ) == 0 ) {
471  /* short */
472  printLsStrShort( collEnt->dataName );
473  }
474  else {
475  printDataCollEntLong( collEnt, flags );
476  }
477  return 0;
478 }
479 
480 int
481 printDataCollEntLong( collEnt_t *collEnt, int flags ) {
482  char *tmpReplStatus;
483  char localTimeModify[TIME_LEN];
484  char typeStr[NAME_LEN];
485 
486  if ( collEnt->replStatus == OLD_COPY ) {
487  tmpReplStatus = " ";
488  }
489  else {
490  tmpReplStatus = "&";
491  }
492 
493  getLocalTimeFromRodsTime( collEnt->modifyTime, localTimeModify );
494  if ( collEnt->specColl.collClass == NO_SPEC_COLL ||
495  collEnt->specColl.collClass == LINKED_COLL ) {
496  printf( " %-12.12s %6d %s %12lld %16.16s %s %s\n",
497  collEnt->ownerName, collEnt->replNum, collEnt->resc_hier,
498  collEnt->dataSize, localTimeModify, tmpReplStatus, collEnt->dataName );
499  }
500  else {
501  getSpecCollTypeStr( &collEnt->specColl, typeStr );
502  printf( " %-12.12s %6.6s %s %12lld %16.16s %s %s\n",
503  collEnt->ownerName, typeStr, collEnt->resc_hier,
504  collEnt->dataSize, localTimeModify, tmpReplStatus, collEnt->dataName );
505  }
506 
507 
508  if ( ( flags & VERY_LONG_METADATA_FG ) != 0 ) {
509  printf( " %s %s %s\n", collEnt->chksum, collEnt->dataType, collEnt->phyPath );
510 
511  }
512  return 0;
513 }
514 
515 int
516 printCollCollEnt( collEnt_t *collEnt, int flags ) {
517  char typeStr[NAME_LEN];
518 
519  typeStr[0] = '\0';
520  if ( collEnt->specColl.collClass != NO_SPEC_COLL ) {
521  getSpecCollTypeStr( &collEnt->specColl, typeStr );
522  }
523  if ( ( flags & LONG_METADATA_FG ) != 0 ) {
524  printf( " C- %s %s\n", collEnt->collName, typeStr );
525  }
526  else if ( ( flags & VERY_LONG_METADATA_FG ) != 0 ) {
527  if ( collEnt->specColl.collClass == NO_SPEC_COLL ) {
528  printf( " C- %s\n", collEnt->collName );
529  }
530  else {
531  if ( collEnt->specColl.collClass == MOUNTED_COLL ||
532  collEnt->specColl.collClass == LINKED_COLL ) {
533  printf( " C- %s %6.6s %s %s %s\n",
534  collEnt->collName, typeStr,
535  collEnt->specColl.objPath, collEnt->specColl.phyPath,
536  collEnt->specColl.rescHier );
537  }
538  else {
539  printf( " C- %s %6.6s %s %s;;;%s;;;%d\n",
540  collEnt->collName, typeStr,
541  collEnt->specColl.objPath, collEnt->specColl.cacheDir,
542  collEnt->specColl.rescHier, collEnt->specColl.cacheDirty );
543  }
544  }
545  }
546  else {
547  /* short */
548  printf( " C- %s\n", collEnt->collName );
549  }
550  return 0;
551 }
552 
553 int
554 printSpecLsLong( char *objPath, char *ownerName, char *objSize,
555  char *modifyTime, specColl_t *specColl, rodsArguments_t *rodsArgs ) {
556  collEnt_t collEnt;
557  int queryFlags;
558 
559  bzero( &collEnt, sizeof( collEnt ) );
560 
561  collEnt.dataName = objPath;
562  collEnt.ownerName = ownerName;
563  collEnt.dataSize = strtoll( objSize, 0, 0 );
564  collEnt.resource = specColl->resource;
565  collEnt.resc_hier = specColl->rescHier;
566  collEnt.modifyTime = modifyTime;
567  collEnt.specColl = *specColl;
568  collEnt.objType = DATA_OBJ_T;
569  queryFlags = setQueryFlag( rodsArgs );
570 
571  printDataCollEntLong( &collEnt, queryFlags );
572  return 0;
573 }
574 
575 int
576 printDataAcl( rcComm_t *conn, char *dataId ) {
577  genQueryOut_t *genQueryOut = NULL;
578  int status;
579  int i;
580  sqlResult_t *userName, *userZone, *dataAccess;
581  char *userNameStr, *userZoneStr, *dataAccessStr;
582 
583  status = queryDataObjAcl( conn, dataId, zoneHint, &genQueryOut );
584 
585  printf( " ACL - " );
586 
587  if ( status < 0 ) {
588  printf( "\n" );
589  return status;
590  }
591 
592  if ( ( userName = getSqlResultByInx( genQueryOut, COL_USER_NAME ) ) == NULL ) {
594  "printDataAcl: getSqlResultByInx for COL_USER_NAME failed" );
595  return UNMATCHED_KEY_OR_INDEX;
596  }
597 
598  if ( ( userZone = getSqlResultByInx( genQueryOut, COL_USER_ZONE ) ) == NULL ) {
600  "printDataAcl: getSqlResultByInx for COL_USER_ZONE failed" );
601  return UNMATCHED_KEY_OR_INDEX;
602  }
603 
604  if ( ( dataAccess = getSqlResultByInx( genQueryOut, COL_DATA_ACCESS_NAME ) )
605  == NULL ) {
607  "printDataAcl: getSqlResultByInx for COL_DATA_ACCESS_NAME failed" );
608  return UNMATCHED_KEY_OR_INDEX;
609  }
610 
611  for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
612  userNameStr = &userName->value[userName->len * i];
613  userZoneStr = &userZone->value[userZone->len * i];
614  dataAccessStr = &dataAccess->value[dataAccess->len * i];
615  printf( "%s#%s:%s ", userNameStr, userZoneStr, dataAccessStr );
616  }
617 
618  printf( "\n" );
619 
620  freeGenQueryOut( &genQueryOut );
621 
622  return status;
623 }
624 
625 int
626 printCollAcl( rcComm_t *conn, char *collName ) {
627  genQueryOut_t *genQueryOut = NULL;
628  int status;
629  int i;
630  sqlResult_t *userName, *userZone, *dataAccess ;
631  char *userNameStr, *userZoneStr, *dataAccessStr;
632 
633  printf( " ACL - " );
634  /* First try a specific-query. If this is defined, it should be
635  used as it returns the group names without expanding them to
636  individual users and this is important to some sites (iPlant,
637  in particular). If this fails, go on the the general-query.
638  */
639  status = queryCollAclSpecific( conn, collName, zoneHint, &genQueryOut );
640  if ( status >= 0 ) {
641  int i, j;
642  for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
643  char *tResult[10];
644  char empty = 0;
645  char typeStr[8];
646  tResult[3] = 0;
647 
648  for ( j = 0; j < 10; j++ ) {
649  tResult[j] = &empty;
650  if ( j < genQueryOut->attriCnt ) {
651  tResult[j] = genQueryOut->sqlResult[j].value;
652  tResult[j] += i * genQueryOut->sqlResult[j].len;
653  }
654  }
655  typeStr[0] = '\0';
656  if ( tResult[3] != 0 && strncmp( tResult[3], "rodsgroup", 9 ) == 0 ) {
657  strncpy( typeStr, "g:", 3 );
658  }
659  printf( "%s%s#%s:%s ", typeStr, tResult[0], tResult[1], tResult[2] );
660 
661  }
662  printf( "\n" );
663  freeGenQueryOut( &genQueryOut );
664  return status;
665  }
666 
667  status = queryCollAcl( conn, collName, zoneHint, &genQueryOut );
668 
669  if ( status < 0 ) {
670  printf( "\n" );
671  freeGenQueryOut( &genQueryOut );
672  return status;
673  }
674 
675  if ( ( userName = getSqlResultByInx( genQueryOut, COL_COLL_USER_NAME ) ) == NULL ) {
677  "printCollAcl: getSqlResultByInx for COL_COLL_USER_NAME failed" );
678  freeGenQueryOut( &genQueryOut );
679  return UNMATCHED_KEY_OR_INDEX;
680  }
681  if ( ( userZone = getSqlResultByInx( genQueryOut, COL_COLL_USER_ZONE ) ) == NULL ) {
683  "printCollAcl: getSqlResultByInx for COL_COLL_USER_ZONE failed" );
684  freeGenQueryOut( &genQueryOut );
685  return UNMATCHED_KEY_OR_INDEX;
686  }
687 
688  if ( ( dataAccess = getSqlResultByInx( genQueryOut, COL_COLL_ACCESS_NAME ) ) == NULL ) {
690  "printCollAcl: getSqlResultByInx for COL_COLL_ACCESS_NAME failed" );
691  freeGenQueryOut( &genQueryOut );
692  return UNMATCHED_KEY_OR_INDEX;
693  }
694 
695  for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
696  userNameStr = &userName->value[userName->len * i];
697  userZoneStr = &userZone->value[userZone->len * i];
698  dataAccessStr = &dataAccess->value[dataAccess->len * i];
699  printf( "%s#%s:%s ", userNameStr, userZoneStr, dataAccessStr );
700  }
701 
702  printf( "\n" );
703 
704  freeGenQueryOut( &genQueryOut );
705 
706  return status;
707 }
708 
709 int
710 printCollInheritance( rcComm_t *conn, char *collName ) {
711  genQueryOut_t *genQueryOut = NULL;
712  int status;
713  sqlResult_t *inheritResult;
714  char *inheritStr;
715 
716  status = queryCollInheritance( conn, collName, &genQueryOut );
717 
718  if ( status < 0 ) {
719  freeGenQueryOut( &genQueryOut );
720  return status;
721  }
722 
723  if ( ( inheritResult = getSqlResultByInx( genQueryOut, COL_COLL_INHERITANCE ) ) == NULL ) {
725  "printCollInheritance: getSqlResultByInx for COL_COLL_INHERITANCE failed" );
726  freeGenQueryOut( &genQueryOut );
727  return UNMATCHED_KEY_OR_INDEX;
728  }
729 
730  inheritStr = &inheritResult->value[0];
731  printf( " Inheritance - " );
732  if ( *inheritStr == '1' ) {
733  printf( "Enabled\n" );
734  }
735  else {
736  printf( "Disabled\n" );
737  }
738 
739  freeGenQueryOut( &genQueryOut );
740 
741  return status;
742 }
743 
744 void
745 printCollOrDir( char *myName, objType_t myType, rodsArguments_t *rodsArgs,
746  specColl_t *specColl ) {
747  char *typeStr;
748 
749  if ( rodsArgs->verbose == False ) {
750  return;
751  }
752 
753  if ( myType == COLL_OBJ_T ) {
754  typeStr = "C";
755  }
756  else {
757  typeStr = "D";
758  }
759 
760  if ( specColl != NULL ) {
761  char objType[NAME_LEN];
762  int status;
763  status = getSpecCollTypeStr( specColl, objType );
764  if ( status < 0 ) {
765  objType[0] = '\0';
766  }
767  fprintf( stdout, "%s- %s %-5.5s :\n", typeStr, myName, objType );
768  }
769  else {
770  fprintf( stdout, "%s- %s :\n", typeStr, myName );
771  }
772 }
773 
774 int
775 lsSubfilesInBundle( rcComm_t *conn, char *srcPath ) {
776  int i, status;
777  genQueryOut_t *genQueryOut = NULL;
778  genQueryInp_t genQueryInp;
779  char condStr[MAX_NAME_LEN];
780  sqlResult_t *dataName, *collection, *dataSize;
781  char *dataNameStr, *collectionStr, *dataSizeStr;
782  int continueInx = 1;
783 
784 
785  fprintf( stdout, "Bundle file: %s\n", srcPath );
786  fprintf( stdout, "Subfiles:\n" );
787  bzero( &genQueryInp, sizeof( genQueryInp ) );
788  genQueryInp.maxRows = MAX_SQL_ROWS;
789 
790  snprintf( condStr, MAX_NAME_LEN, "='%s'", srcPath );
791  addInxVal( &genQueryInp.sqlCondInp, COL_D_DATA_PATH, condStr );
792  snprintf( condStr, MAX_NAME_LEN, "='%s'", BUNDLE_RESC_CLASS );
793  addInxVal( &genQueryInp.sqlCondInp, COL_R_CLASS_NAME, condStr );
794  addKeyVal( &genQueryInp.condInput, ZONE_KW, srcPath );
795 
796  addInxIval( &genQueryInp.selectInp, COL_COLL_NAME, 1 );
797  addInxIval( &genQueryInp.selectInp, COL_DATA_NAME, 1 );
798  addInxIval( &genQueryInp.selectInp, COL_DATA_SIZE, 1 );
799 
800  while ( continueInx > 0 ) {
801  status = rcGenQuery( conn, &genQueryInp, &genQueryOut );
802 
803  if ( status < 0 ) {
804  if ( status != CAT_NO_ROWS_FOUND ) {
806  "lsSubfilesInBundle: rsGenQuery error for %s",
807  srcPath );
808  }
809  clearGenQueryInp( &genQueryInp );
810  return status;
811  }
812 
813  if ( ( collection = getSqlResultByInx( genQueryOut, COL_COLL_NAME ) ) ==
814  NULL ) {
816  "lsSubfilesInBundle: getSqlResultByInx for COL_COLL_NAME failed" );
817  return UNMATCHED_KEY_OR_INDEX;
818  }
819  if ( ( dataName = getSqlResultByInx( genQueryOut, COL_DATA_NAME ) ) ==
820  NULL ) {
822  "lsSubfilesInBundle: getSqlResultByInx for COL_DATA_NAME failed" );
823  return UNMATCHED_KEY_OR_INDEX;
824  }
825  if ( ( dataSize = getSqlResultByInx( genQueryOut, COL_DATA_SIZE ) ) ==
826  NULL ) {
828  "lsSubfilesInBundle: getSqlResultByInx for COL_DATA_SIZE failed" );
829  return UNMATCHED_KEY_OR_INDEX;
830  }
831 
832  for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
833  collectionStr = &collection->value[collection->len * i];
834  dataNameStr = &dataName->value[dataName->len * i];
835  dataSizeStr = &dataSize->value[dataSize->len * i];
836  fprintf( stdout, " %s/%s %s\n",
837  collectionStr, dataNameStr, dataSizeStr );
838  }
839 
840  continueInx = genQueryInp.continueInx =
841  genQueryOut->continueInx;
842  freeGenQueryOut( &genQueryOut );
843  }
844  clearGenQueryInp( &genQueryInp );
845  return status;
846 }
847 
848 
849 
850 
COL_DATA_TYPE_NAME
#define COL_DATA_TYPE_NAME
Definition: rodsGenQuery.h:168
QueryHandle
Definition: miscUtil.h:81
COL_USER_ZONE
#define COL_USER_ZONE
Definition: rodsGenQuery.h:134
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
MAX_SQL_ROWS
#define MAX_SQL_ROWS
Definition: rodsGenQuery.h:16
rcComm_t
Definition: rcConnect.h:95
LONG_METADATA_FG
#define LONG_METADATA_FG
Definition: miscUtil.h:90
NULL
#define NULL
Definition: rodsDef.h:70
RodsPath::rodsObjStat
rodsObjStat_t * rodsObjStat
Definition: rodsPath.h:27
True
#define True
Definition: parseCommandLine.h:11
irods::experimental::filesystem::client::is_collection
auto is_collection(object_status _s) noexcept -> bool
Definition: filesystem.cpp:600
COL_DATA_REPL_NUM
#define COL_DATA_REPL_NUM
Definition: rodsGenQuery.h:166
irods.pyparsing.empty
empty
Definition: pyparsing.py:3430
addKeyVal
int addKeyVal(keyValPair_t *condInput, const char *keyWord, const char *value)
Definition: rcMisc.cpp:789
COL_COLL_USER_ZONE
#define COL_COLL_USER_ZONE
Definition: rodsGenQuery.h:357
COL_D_REPL_STATUS
#define COL_D_REPL_STATUS
Definition: rodsGenQuery.h:175
rodsPath.h
rodsArguments_t::bundle
int bundle
Definition: parseCommandLine.h:79
getSpecCollTypeStr
int getSpecCollTypeStr(specColl_t *specColl, char *outStr)
Definition: rcMisc.cpp:3099
rclOpenCollection
int rclOpenCollection(rcComm_t *conn, char *collection, int flag, collHandle_t *collHandle)
Definition: miscUtil.cpp:1057
GenQueryInp::continueInx
int continueInx
Definition: rodsGenQuery.h:28
rodsArguments_t::ticketString
char * ticketString
Definition: parseCommandLine.h:99
CollEnt::resource
char * resource
Definition: miscUtil.h:125
COL_COLL_INHERITANCE
#define COL_COLL_INHERITANCE
Definition: rodsGenQuery.h:194
rodsArguments_t
Definition: parseCommandLine.h:14
COL_D_RESC_HIER
#define COL_D_RESC_HIER
Definition: rodsGenQuery.h:184
UNMATCHED_KEY_OR_INDEX
@ UNMATCHED_KEY_OR_INDEX
Definition: rodsErrorTable.h:244
printDataCollEnt
int printDataCollEnt(collEnt_t *collEnt, int flags)
Definition: lsUtil.cpp:469
SpecColl::resource
char resource[64]
Definition: objInfo.h:83
irods::experimental::filesystem::client::is_data_object
auto is_data_object(object_status _s) noexcept -> bool
Definition: filesystem.cpp:635
CollEnt::replNum
int replNum
Definition: miscUtil.h:115
queryCollInheritance
int queryCollInheritance(rcComm_t *conn, char *collName, genQueryOut_t **genQueryOut)
Definition: miscUtil.cpp:625
RodsPathInp
Definition: rodsPath.h:33
collHandle_t
Definition: miscUtil.h:97
printCollOrDir
void printCollOrDir(char *myName, objType_t myType, rodsArguments_t *rodsArgs, specColl_t *specColl)
Definition: lsUtil.cpp:745
rodsArguments_t::verbose
int verbose
Definition: parseCommandLine.h:107
queryCollAclSpecific
int queryCollAclSpecific(rcComm_t *conn, char *collName, char *zoneHint, genQueryOut_t **genQueryOut)
Definition: miscUtil.cpp:552
printCollAcl
int printCollAcl(rcComm_t *conn, char *collName)
Definition: lsUtil.cpp:626
setQueryInpForData
int setQueryInpForData(int flags, genQueryInp_t *genQueryInp)
Definition: miscUtil.cpp:364
CollEnt::collName
char * collName
Definition: miscUtil.h:119
lsUtil.h
SYS_SPEC_COLL_OBJ_NOT_EXIST
@ SYS_SPEC_COLL_OBJ_NOT_EXIST
Definition: rodsErrorTable.h:123
GenQueryInp
Definition: rodsGenQuery.h:24
SpecColl::cacheDirty
int cacheDirty
Definition: objInfo.h:92
SpecColl::phyPath
char phyPath[(1024+64)]
Definition: objInfo.h:85
irods::experimental::administration::client::v1::exists
auto exists(rcComm_t &conn, const user &user) -> bool
Definition: user_administration.cpp:359
rodsArguments_t::accessControl
int accessControl
Definition: parseCommandLine.h:19
SpecColl::cacheDir
char cacheDir[(1024+64)]
Definition: objInfo.h:89
CollEnt::dataSize
rodsLong_t dataSize
Definition: miscUtil.h:118
rodsObjStat::ownerName
char ownerName[64]
Definition: objStat.h:14
filesystem.hpp
NO_TRIM_REPL_FG
#define NO_TRIM_REPL_FG
Definition: miscUtil.h:94
DATA_QUERY_FIRST_FG
#define DATA_QUERY_FIRST_FG
Definition: miscUtil.h:93
SpecColl
Definition: objInfo.h:76
printDataCollEntLong
int printDataCollEntLong(collEnt_t *collEnt, int flags)
Definition: lsUtil.cpp:481
rcGlobalExtern.h
RodsPathInp::srcPath
rodsPath_t * srcPath
Definition: rodsPath.h:35
addInxVal
int addInxVal(inxValPair_t *inxValPair, int inx, const char *value)
Definition: rcMisc.cpp:921
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
RodsPath::objType
objType_t objType
Definition: rodsPath.h:19
COL_D_DATA_CHECKSUM
#define COL_D_DATA_CHECKSUM
Definition: rodsGenQuery.h:177
GenQueryInp::selectInp
inxIvalPair_t selectInp
Definition: rodsGenQuery.h:53
GenQueryInp::maxRows
int maxRows
Definition: rodsGenQuery.h:25
queryCollAcl
int queryCollAcl(rcComm_t *conn, char *collName, char *zoneHint, genQueryOut_t **genQueryOut)
Definition: miscUtil.cpp:581
GenQueryOut::sqlResult
sqlResult_t sqlResult[50]
Definition: rodsGenQuery.h:72
CollEnt::dataId
char * dataId
Definition: miscUtil.h:121
COL_D_OWNER_NAME
#define COL_D_OWNER_NAME
Definition: rodsGenQuery.h:173
CollEnt::replStatus
int replStatus
Definition: miscUtil.h:116
COL_COLL_USER_NAME
#define COL_COLL_USER_NAME
Definition: rodsGenQuery.h:356
rclInitQueryHandle
int rclInitQueryHandle(queryHandle_t *queryHandle, rcComm_t *conn)
Definition: miscUtil.cpp:1744
RodsPath::dataId
char dataId[64]
Definition: rodsPath.h:25
irods_query.hpp
COLL_OBJ_T
@ COLL_OBJ_T
Definition: rodsType.h:39
COL_DATA_NAME
#define COL_DATA_NAME
Definition: rodsGenQuery.h:165
rodsArguments_t::ticket
int ticket
Definition: parseCommandLine.h:98
COL_DATA_ACCESS_NAME
#define COL_DATA_ACCESS_NAME
Definition: rodsGenQuery.h:273
lsCollUtil
int lsCollUtil(rcComm_t *conn, rodsPath_t *srcPath, rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs)
Definition: lsUtil.cpp:385
LINKED_COLL
@ LINKED_COLL
Definition: objInfo.h:49
getLocalTimeFromRodsTime
int getLocalTimeFromRodsTime(const char *timeStrIn, char *timeStrOut)
Definition: rcMisc.cpp:1602
COL_D_RESC_NAME
#define COL_D_RESC_NAME
Definition: rodsGenQuery.h:171
rodsObjStat::modifyTime
char modifyTime[32]
Definition: objStat.h:17
getSqlResultByInx
sqlResult_t * getSqlResultByInx(genQueryOut_t *genQueryOut, int attriInx)
Definition: rcMisc.cpp:1387
irods::experimental::filesystem
Definition: collection_entry.hpp:12
GenQueryOut::continueInx
int continueInx
Definition: rodsGenQuery.h:70
lsDataObjUtil
int lsDataObjUtil(rcComm_t *conn, rodsPath_t *srcPath, rodsArguments_t *rodsArgs, genQueryInp_t *genQueryInp)
Definition: lsUtil.cpp:93
printDataAcl
int printDataAcl(rcComm_t *conn, char *dataId)
Definition: lsUtil.cpp:576
lsUtil
int lsUtil(rcComm_t *conn, rodsEnv *myRodsEnv, rodsArguments_t *myRodsArgs, rodsPathInp_t *rodsPathInp)
Definition: lsUtil.cpp:16
CollEnt::phyPath
char * phyPath
Definition: miscUtil.h:127
COL_D_MODIFY_TIME
#define COL_D_MODIFY_TIME
Definition: rodsGenQuery.h:182
rclCloseCollection
int rclCloseCollection(collHandle_t *collHandle)
Definition: miscUtil.cpp:1354
TIME_LEN
#define TIME_LEN
Definition: rodsDef.h:54
GenQueryInp::condInput
keyValPair_t condInput
Definition: rodsGenQuery.h:52
printLsLong
int printLsLong(rcComm_t *conn, rodsArguments_t *rodsArgs, genQueryOut_t *genQueryOut)
Definition: lsUtil.cpp:188
rcGenQuery
int rcGenQuery(rcComm_t *conn, genQueryInp_t *genQueryInp, genQueryOut_t **genQueryOut)
Definition: rcGenQuery.cpp:89
COL_USER_NAME
#define COL_USER_NAME
Definition: rodsGenQuery.h:132
printCollInheritance
int printCollInheritance(rcComm_t *conn, char *collName)
Definition: lsUtil.cpp:710
CollEnt
Definition: miscUtil.h:113
CollEnt::specColl
specColl_t specColl
Definition: miscUtil.h:130
GenQueryInp::sqlCondInp
inxValPair_t sqlCondInp
Definition: rodsGenQuery.h:56
rodsObjStat::objSize
rodsLong_t objSize
Definition: objStat.h:9
printSpecLsLong
int printSpecLsLong(char *objPath, char *ownerName, char *objSize, char *modifyTime, specColl_t *specColl, rodsArguments_t *rodsArgs)
Definition: lsUtil.cpp:554
printLsStrShort
int printLsStrShort(char *srcPath)
Definition: lsUtil.cpp:133
MAX_NAME_LEN
#define MAX_NAME_LEN
Definition: rodsDef.h:61
addInxIval
int addInxIval(inxIvalPair_t *inxIvalPair, int inx, int value)
Definition: rcMisc.cpp:883
GenQueryOut
Definition: rodsGenQuery.h:67
OLD_COPY
#define OLD_COPY
Definition: objInfo.h:114
CollEnt::modifyTime
char * modifyTime
Definition: miscUtil.h:123
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
SpecColl::rescHier
char rescHier[(1024+64)]
Definition: objInfo.h:84
NO_SPEC_COLL
@ NO_SPEC_COLL
Definition: objInfo.h:46
setQueryFlag
int setQueryFlag(rodsArguments_t *rodsArgs)
Definition: miscUtil.cpp:1727
zoneHint
char zoneHint[(1024+64)]
Definition: lsUtil.cpp:13
splitPathByKey
int splitPathByKey(const char *srcPath, char *dir, size_t maxDirLen, char *file, size_t maxFileLen, char key)
Definition: stringOpr.cpp:222
rodsLog.h
GenQueryOut::rowCnt
int rowCnt
Definition: rodsGenQuery.h:68
printLsShort
int printLsShort(rcComm_t *conn, rodsArguments_t *rodsArgs, genQueryOut_t *genQueryOut)
Definition: lsUtil.cpp:335
DATA_OBJ_T
@ DATA_OBJ_T
Definition: rodsType.h:38
setSessionTicket
int setSessionTicket(rcComm_t *myConn, char *ticket)
Definition: getUtil.cpp:17
CollEnt::dataName
char * dataName
Definition: miscUtil.h:120
RodsPath::outPath
char outPath[(1024+64)]
Definition: rodsPath.h:24
SqlResult::value
char * value
Definition: rodsGenQuery.h:64
rodsArguments_t::recursive
int recursive
Definition: parseCommandLine.h:85
CAT_NO_ROWS_FOUND
@ CAT_NO_ROWS_FOUND
Definition: rodsErrorTable.h:423
SqlResult
Definition: rodsGenQuery.h:61
rodsArguments_t::veryLongOption
int veryLongOption
Definition: parseCommandLine.h:60
VERY_LONG_METADATA_FG
#define VERY_LONG_METADATA_FG
Definition: miscUtil.h:91
printCollCollEnt
int printCollCollEnt(collEnt_t *collEnt, int flags)
Definition: lsUtil.cpp:516
lsSubfilesInBundle
int lsSubfilesInBundle(rcComm_t *conn, char *srcPath)
Definition: lsUtil.cpp:775
COL_COLL_NAME
#define COL_COLL_NAME
Definition: rodsGenQuery.h:189
lsDataObjUtilLong
int lsDataObjUtilLong(rcComm_t *conn, char *srcPath, rodsArguments_t *rodsArgs, genQueryInp_t *genQueryInp)
Definition: lsUtil.cpp:139
rodsLogError
void rodsLogError(int level, int errCode, char *formatStr,...)
Definition: rodsLog.cpp:422
MOUNTED_COLL
@ MOUNTED_COLL
Definition: objInfo.h:48
clearInxVal
int clearInxVal(inxValPair_t *inxValPair)
Definition: rcMisc.cpp:1082
RodsPathInp::numSrc
int numSrc
Definition: rodsPath.h:34
CollEnt::dataType
char * dataType
Definition: miscUtil.h:129
SqlResult::len
int len
Definition: rodsGenQuery.h:63
rodsArguments_t::longOption
int longOption
Definition: parseCommandLine.h:56
BUNDLE_RESC_CLASS
#define BUNDLE_RESC_CLASS
Definition: phyBundleColl.h:14
CollEnt::objType
objType_t objType
Definition: miscUtil.h:114
rclReadCollection
int rclReadCollection(rcComm_t *conn, collHandle_t *collHandle, collEnt_t *collEnt)
Definition: miscUtil.cpp:1108
rodsObjStat
Definition: objStat.h:8
ZONE_KW
#define ZONE_KW
Definition: rodsKeyWdDef.h:80
rodsErrorTable.h
False
#define False
Definition: parseCommandLine.h:12
rodsObjStat::specColl
specColl_t * specColl
Definition: objStat.h:18
RodsPath
Definition: rodsPath.h:18
COL_R_CLASS_NAME
#define COL_R_CLASS_NAME
Definition: rodsGenQuery.h:147
miscUtil.h
irods::query
Definition: irods_query.hpp:25
queryDataObjAcl
int queryDataObjAcl(rcComm_t *conn, char *dataId, char *zoneHint, genQueryOut_t **genQueryOut)
Definition: miscUtil.cpp:515
rstrcpy
char * rstrcpy(char *dest, const char *src, int maxLen)
Definition: stringOpr.cpp:51
COL_D_DATA_PATH
#define COL_D_DATA_PATH
Definition: rodsGenQuery.h:172
rodsEnv
Definition: getRodsEnv.h:8
freeGenQueryOut
int freeGenQueryOut(genQueryOut_t **genQueryOut)
Definition: rcMisc.cpp:1133
NAME_LEN
#define NAME_LEN
Definition: rodsDef.h:55
SpecColl::objPath
char objPath[(1024+64)]
Definition: objInfo.h:80
USER_INPUT_PATH_ERR
@ USER_INPUT_PATH_ERR
Definition: rodsErrorTable.h:248
COL_DATA_SIZE
#define COL_DATA_SIZE
Definition: rodsGenQuery.h:169
CollEnt::resc_hier
char * resc_hier
Definition: miscUtil.h:126
clearGenQueryInp
void clearGenQueryInp(void *voidInp)
Definition: rcMisc.cpp:1118
CollEnt::ownerName
char * ownerName
Definition: miscUtil.h:128
CollEnt::chksum
char * chksum
Definition: miscUtil.h:124
COL_COLL_ACCESS_NAME
#define COL_COLL_ACCESS_NAME
Definition: rodsGenQuery.h:279
objType_t
objType_t
Definition: rodsType.h:36
SpecColl::collClass
specCollClass_t collClass
Definition: objInfo.h:77
initCondForLs
int initCondForLs(genQueryInp_t *genQueryInp)
Definition: lsUtil.cpp:372
lsSpecDataObjUtilLong
int lsSpecDataObjUtilLong(rodsPath_t *srcPath, rodsArguments_t *rodsArgs)
Definition: lsUtil.cpp:320
COL_D_DATA_ID
#define COL_D_DATA_ID
Definition: rodsGenQuery.h:163
USER__NULL_INPUT_ERR
@ USER__NULL_INPUT_ERR
Definition: rodsErrorTable.h:247