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)  

msiHelper.cpp
Go to the documentation of this file.
1 
6 
8 /* reHelper.c */
9 
10 #include "rcMisc.h"
11 #include "msiHelper.hpp"
12 #include "reFuncDefs.hpp"
44 int
45 msiGetStdoutInExecCmdOut( msParam_t *inpExecCmdOut, msParam_t *outStr,
46  ruleExecInfo_t *rei ) {
47  char *strPtr;
48 
49  rei->status = getStdoutInExecCmdOut( inpExecCmdOut, &strPtr );
50 
51  if ( rei->status < 0 ) {
52  return rei->status;
53  }
54 
55  fillStrInMsParam( outStr, strPtr );
56  free( strPtr );
57 
58  return rei->status;
59 }
60 
92 int
93 msiGetStderrInExecCmdOut( msParam_t *inpExecCmdOut, msParam_t *outStr,
94  ruleExecInfo_t *rei ) {
95  char *strPtr = NULL;
96 
97  rei->status = getStderrInExecCmdOut( inpExecCmdOut, &strPtr );
98 
99  if ( rei->status < 0 ) {
100  if ( rei->status != SYS_INTERNAL_NULL_INPUT_ERR ) {
101  return rei->status;
102  }
103  else {
104  free( strPtr );
105  strPtr = NULL;
106  rei->status = 0;
107  }
108  }
109 
110  if ( strPtr != NULL ) {
111  fillStrInMsParam( outStr, strPtr );
112  free( strPtr );
113  }
114  else {
115  fillStrInMsParam( outStr, "" );
116  }
117 
118  return rei->status;
119 }
120 
156 int
157 msiWriteRodsLog( msParam_t *inpParam1, msParam_t *outParam, ruleExecInfo_t *rei ) {
158  rsComm_t *rsComm;
159 
160  RE_TEST_MACRO( " Calling msiWriteRodsLog" )
161 
162  if ( rei == NULL || rei->rsComm == NULL ) {
164  "msiWriteRodsLog: input rei or rsComm is NULL" );
166  }
167 
168  rsComm = rei->rsComm;
169 
170  if ( inpParam1 == NULL ) {
171  rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,
172  "msiWriteRodsLog: input Param1 is NULL" );
174  return rei->status;
175  }
176 
177  if ( strcmp( inpParam1->type, STR_MS_T ) == 0 ) {
179  "msiWriteRodsLog message: %s", inpParam1->inOutStruct );
180  }
181  else {
182  rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,
183  "msiWriteRodsLog: Unsupported input Param1 types %s",
184  inpParam1->type );
186  return rei->status;
187  }
188 
189  rei->status = 0;
190 
191  fillIntInMsParam( outParam, rei->status );
192 
193  return rei->status;
194 }
195 
230 int
232  msParam_t *msKeyValStr, ruleExecInfo_t *rei ) {
233  RE_TEST_MACRO( " Calling msiAddKeyValToMspStr" )
234 
235  if ( rei == NULL ) {
237  "msiAddKeyValToMspStr: input rei is NULL" );
238  // JMC cppcheck rei->status = SYS_INTERNAL_NULL_INPUT_ERR;
239  return SYS_INTERNAL_NULL_INPUT_ERR;//(rei->status);
240  }
241 
242  rei->status = addKeyValToMspStr( keyStr, valStr, msKeyValStr );
243 
244 
245  return rei->status;
246 }
247 
280 int
281 msiSplitPath( msParam_t *inpPath, msParam_t *outParentColl,
282  msParam_t *outChildName, ruleExecInfo_t *rei ) {
283  char parent[MAX_NAME_LEN], child[MAX_NAME_LEN];
284 
285  RE_TEST_MACRO( " Calling msiSplitPath" )
286 
287  if ( rei == NULL ) {
289  "msiSplitPath: input rei is NULL" );
290  // JMC cppcheck - rei->status = SYS_INTERNAL_NULL_INPUT_ERR;
291  return SYS_INTERNAL_NULL_INPUT_ERR;//(rei->status);
292  }
293 
294  if ( inpPath == NULL ) {
296  "msiSplitPath: input inpPath is NULL" );
298  return rei->status;
299  }
300 
301  if ( strcmp( inpPath->type, STR_MS_T ) == 0 ) {
302  if ( ( rei->status = splitPathByKey( ( char * ) inpPath->inOutStruct,
303  parent, MAX_NAME_LEN, child, MAX_NAME_LEN, '/' ) ) < 0 ) {
305  "msiSplitPath: splitPathByKey for %s error, status = %d",
306  ( char * ) inpPath->inOutStruct, rei->status );
307  }
308  else {
309  fillStrInMsParam( outParentColl, parent );
310  fillStrInMsParam( outChildName, child );
311  }
312  }
313  else {
315  "msiSplitPath: Unsupported input inpPath types %s",
316  inpPath->type );
318  }
319  return rei->status;
320 }
321 
358 int
360  char *inpVarStr, *outputModeStr;
361  char errMsg[ERR_MSG_LEN];
362  rsComm_t *rsComm;
363 
364  RE_TEST_MACRO( " Calling msiGetSessionVarValue" )
365 
366  if ( rei == NULL || rei->rsComm == NULL ) {
368  "msiGetSessionVar: input rei or rei->rsComm is NULL" );
369  // JMC cppcheck - rei->status = SYS_INTERNAL_NULL_INPUT_ERR;
370  return SYS_INTERNAL_NULL_INPUT_ERR;//(rei->status);
371  }
372 
373  if ( inpVar == NULL || outputMode == NULL ) {
375  "msiGetSessionVarValue: input inpVar or outputMode is NULL" );
377  return rei->status;
378  }
379 
380  if ( strcmp( inpVar->type, STR_MS_T ) != 0 ||
381  strcmp( outputMode->type, STR_MS_T ) != 0 ) {
383  "msiGetSessionVarValue: Unsupported *inpVar or outputMode type" );
385  return rei->status;
386  }
387  rsComm = rei->rsComm;
388  inpVarStr = ( char * ) inpVar->inOutStruct;
389  outputModeStr = ( char * ) outputMode->inOutStruct;
390 
391  if ( inpVarStr == NULL || outputModeStr == NULL ) {
393  "msiGetSessionVarValue: input inpVar or outputMode is NULL" );
395  return rei->status;
396  }
397 
398  if ( strcmp( inpVarStr, "all" ) == 0 ) {
399  keyValPair_t varKeyVal;
400  int i;
401  bzero( &varKeyVal, sizeof( varKeyVal ) );
402  rei->status = getAllSessionVarValue( rei, &varKeyVal );
403  if ( rei->status >= 0 ) {
404  if ( strcmp( outputModeStr, "server" ) == 0 ||
405  strcmp( outputModeStr, "all" ) == 0 ) {
406  for ( i = 0; i < varKeyVal.len; i++ ) {
407  printf( "msiGetSessionVar: %s=%s\n",
408  varKeyVal.keyWord[i], varKeyVal.value[i] );
409  }
410  }
411  if ( strcmp( outputModeStr, "client" ) == 0 ||
412  strcmp( outputModeStr, "all" ) == 0 ) {
413  for ( i = 0; i < varKeyVal.len; i++ ) {
414  snprintf( errMsg, ERR_MSG_LEN,
415  "msiGetSessionVarValue: %s=%s\n",
416  varKeyVal.keyWord[i], varKeyVal.value[i] );
417  addRErrorMsg( &rsComm->rError, 0, errMsg );
418  }
419  }
420  clearKeyVal( &varKeyVal );
421  }
422  }
423  else {
424  char *outStr = NULL;
425  rei->status = getSessionVarValue( "", inpVarStr, rei, &outStr );
426  if ( rei->status >= 0 && outStr ) { // cppcheck - Possible null pointer dereference: outStr
427  if ( strcmp( outputModeStr, "server" ) == 0 ||
428  strcmp( outputModeStr, "all" ) == 0 ) {
429  if ( NULL != outStr ) { // JMC cppcheck
430  printf( "msiGetSessionVarValue: %s=%s\n", inpVarStr, outStr );
431  }
432  }
433  if ( strcmp( outputModeStr, "client" ) == 0 ||
434  strcmp( outputModeStr, "all" ) == 0 ) {
435  snprintf( errMsg, ERR_MSG_LEN,
436  "msiGetSessionVarValue: %s=%s\n", inpVarStr, outStr );
437  addRErrorMsg( &rsComm->rError, 0, errMsg );
438  }
439  }
440  if ( outStr != NULL ) {
441  free( outStr );
442  }
443  }
444  return rei->status;
445 }
446 
478 int
479 msiStrlen( msParam_t *stringIn, msParam_t *lengthOut, ruleExecInfo_t *rei ) {
480  char len[NAME_LEN];
481 
482  RE_TEST_MACRO( " Calling msiStrlen" )
483 
484  if ( rei == NULL ) {
486  "msiStrlen: input rei is NULL" );
487  // JMC cppcheck - rei->status = SYS_INTERNAL_NULL_INPUT_ERR;
488  return SYS_INTERNAL_NULL_INPUT_ERR;//(rei->status);
489  }
490 
491  if ( stringIn == NULL ) {
493  "msiStrlen: input stringIn is NULL" );
495  return rei->status;
496  }
497 
498  if ( strcmp( stringIn->type, STR_MS_T ) == 0 ) {
499  if ( stringIn->inOutStruct != NULL ) {
500  rei->status = strlen( ( char * ) stringIn->inOutStruct );
501  }
502  else {
503  rei->status = 0;
504  }
505  }
506  else {
508  "msiStrlen: Unsupported input stringIn types %s",
509  stringIn->type );
511  }
512  snprintf( len, NAME_LEN, "%d", rei->status );
513  fillStrInMsParam( lengthOut, len );
514  return rei->status;
515 }
516 
548 int
549 msiStrchop( msParam_t *stringIn, msParam_t *stringOut, ruleExecInfo_t *rei ) {
550  RE_TEST_MACRO( " Calling msiStrchop" )
551 
552  if ( rei == NULL ) {
554  "msiStrchop: input rei is NULL" );
555  // JMC cppcheck - rei->status = SYS_INTERNAL_NULL_INPUT_ERR;
556  return SYS_INTERNAL_NULL_INPUT_ERR;//(rei->status);
557  }
558 
559  if ( stringIn == NULL ) {
561  "msiStrchop: input stringIn is NULL" );
563  return rei->status;
564  }
565 
566  if ( strcmp( stringIn->type, STR_MS_T ) == 0 ) {
567  if ( stringIn->inOutStruct != NULL ) {
568  fillStrInMsParam( stringOut, ( char * ) stringIn->inOutStruct );
569  rei->status = strlen( ( char * ) stringIn->inOutStruct );
570  if ( rei->status > 0 ) {
571  rei->status --;
572  *( ( char * ) stringOut->inOutStruct + rei->status ) = '\0';
573  }
574  }
575  else {
576  fillStrInMsParam( stringOut, "" );
577  rei->status = 0;
578  }
579  }
580  else {
582  "msiStrchop: Unsupported input stringIn types %s",
583  stringIn->type );
585  }
586  return rei->status;
587 }
588 
627 int
628 msiSubstr( msParam_t *stringIn, msParam_t *offset, msParam_t *length,
629  msParam_t *stringOut, ruleExecInfo_t *rei ) {
630  char *origStr, *strPtr;
631  int intLength, intOffset;
632  int origLen;
633  char savedChar;
634  char *savedPtr = NULL;
635 
636  RE_TEST_MACRO( " Calling msiSubstr" )
637 
638  if ( rei == NULL ) {
640  "msiSubstr: input rei is NULL" );
641  // JMC cppcheck - rei->status = SYS_INTERNAL_NULL_INPUT_ERR;
642  return SYS_INTERNAL_NULL_INPUT_ERR;// (rei->status);
643  }
644 
645  if ( stringIn == NULL || offset == NULL ) {
647  "msiSubstr: input stringIn or offset is NULL" );
649  return rei->status;
650  }
651 
652  if ( strcmp( stringIn->type, STR_MS_T ) != 0 ) {
654  "msiSubstr: Unsupported input stringIn types %s",
655  stringIn->type );
657  return rei->status;
658  }
659  else {
660  origStr = ( char * ) stringIn->inOutStruct;
661  }
662 
663  if ( strcmp( offset->type, STR_MS_T ) != 0 ) {
665  "msiSubstr: Unsupported input offset types %s",
666  offset->type );
668  return rei->status;
669  }
670  else {
671  intOffset = atoi( ( char * ) offset->inOutStruct );
672  }
673 
674  if ( length == NULL ) {
675  /* not defined */
676  intLength = -1;
677  }
678  else if ( strcmp( length->type, STR_MS_T ) != 0 ) {
680  "msiSubstr: Unsupported input length types %s",
681  length->type );
683  return rei->status;
684  }
685  else if ( strcmp( ( char * ) length->inOutStruct, "null" ) == 0 ) {
686  intLength = -1;
687  }
688  else {
689  intLength = atoi( ( char * ) length->inOutStruct );
690  }
691 
692  if ( intOffset >= 0 ) {
693  strPtr = origStr + intOffset;
694  }
695  else {
696  /* from the end. -1 is the last char */
697  origLen = strlen( origStr );
698  strPtr = origStr + origLen + intOffset;
699  }
700 
701  if ( intLength >= 0 && ( ( int ) strlen( strPtr ) ) > intLength ) {
702  /* put a null at the end of the sub str */
703  savedPtr = strPtr + intLength;
704  savedChar = *savedPtr;
705  *savedPtr = '\0';
706  }
707 
708  fillStrInMsParam( stringOut, strPtr );
709  if ( savedPtr != NULL ) {
710  /* restore */
711  *savedPtr = savedChar;
712  }
713 
714  rei->status = strlen( ( char * ) stringOut->inOutStruct );
715  return rei->status;
716 }
717 
753 int
754 msiExit( msParam_t *inpParam1, msParam_t *inpParam2, ruleExecInfo_t *rei ) {
755  char errMsg[ERR_MSG_LEN];
756  int status;
757  rsComm_t *rsComm;
758 
759  RE_TEST_MACRO( " Calling msiExit" )
760 
761  if ( rei == NULL || rei->rsComm == NULL ) {
763  "msiExit: input rei or rsComm is NULL" );
765  }
766 
767  rsComm = rei->rsComm;
768 
769  if ( inpParam1 == NULL ) {
770  rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,
771  "msiExit: input Param1 is NULL" );
773  return rei->status;
774  }
775 
776  if ( inpParam2 == NULL ) {
777  rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,
778  "msiExit: input Param2 is NULL" );
780  return rei->status;
781  }
782 
783  if ( strcmp( inpParam1->type, STR_MS_T ) == 0 && strcmp( inpParam2->type, STR_MS_T ) == 0 ) {
784  snprintf( errMsg, ERR_MSG_LEN, "%s\n", ( char * ) inpParam2->inOutStruct );
785  status = atoi( ( char * ) inpParam1->inOutStruct );
786  addRErrorMsg( &rsComm->rError, status, errMsg );
787  return status;
788  }
789  else {
790  rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,
791  "msiExit: Unsupported input Param1 types %s",
792  inpParam1->type );
794  return rei->status;
795  }
796 
797  /* return (rei->status); */
798 }
799 
800 int
801 msiStrCat( msParam_t *targParam, msParam_t *srcParam, ruleExecInfo_t *rei ) {
802  char *targ, *src, *newTarg;
803  int targLen, srcLen;
804 
805  RE_TEST_MACRO( " Calling msiStrCat" )
806 
807  if ( targParam == NULL || srcParam == NULL ) {
808  return USER__NULL_INPUT_ERR;
809  }
810 
811  if ( strcmp( targParam->type, STR_MS_T ) != 0 ||
812  strcmp( srcParam->type, STR_MS_T ) != 0 ) {
814  "msiStrCat: targParam and srcParam must be STR_MS_T. targ %s, src %s",
815  targParam->type, srcParam->type );
816  return USER_PARAM_TYPE_ERR;
817  }
818  else {
819  targ = ( char* ) targParam->inOutStruct;
820  src = ( char* ) srcParam->inOutStruct;
821  }
822 
823  targLen = strlen( targ );
824  srcLen = strlen( src );
825  newTarg = ( char * ) calloc( 1, targLen + srcLen + 10 );
826  if ( targLen > 0 ) {
827  rstrcpy( newTarg, targ, targLen + 1 );
828  }
829  if ( srcLen > 0 ) {
830  rstrcpy( newTarg + targLen, src, srcLen + 1 );
831  }
832  free( targParam->inOutStruct );
833  targParam->inOutStruct = newTarg;
834 
835  return 0;
836 }
837 int
838 msiSplitPathByKey( msParam_t *inpPath, msParam_t *inpKey, msParam_t *outParentColl,
839  msParam_t *outChildName, ruleExecInfo_t *rei ) {
840  char parent[MAX_NAME_LEN], child[MAX_NAME_LEN];
841 
842  RE_TEST_MACRO( " Calling msiSplitPathByKey" )
843 
844  if ( rei == NULL ) {
846  "msiSplitPathByKey: input rei is NULL" );
848  }
849 
850  if ( inpPath == NULL ) {
852  "msiSplitPathByKey: input inpPath is NULL" );
854  return rei->status;
855  }
856 
857  if ( strcmp( inpPath->type, STR_MS_T ) == 0 ) {
858  if ( ( rei->status = splitPathByKey( ( char * ) inpPath->inOutStruct,
859  parent, MAX_NAME_LEN, child, MAX_NAME_LEN, *( char * ) inpKey->inOutStruct ) ) < 0 ) {
861  "msiSplitPathByKey: splitPathByKey for %s error, status = %d",
862  ( char * ) inpPath->inOutStruct, rei->status );
863  }
864  else {
865  fillStrInMsParam( outParentColl, parent );
866  fillStrInMsParam( outChildName, child );
867  }
868  }
869  else {
871  "msiSplitPathByKey: Unsupported input inpPath types %s",
872  inpPath->type );
874  }
875  return rei->status;
876 }
877 
878 
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
msiSplitPathByKey
int msiSplitPathByKey(msParam_t *inpPath, msParam_t *inpKey, msParam_t *outParentColl, msParam_t *outChildName, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:838
NULL
#define NULL
Definition: rodsDef.h:70
msiStrCat
int msiStrCat(msParam_t *targParam, msParam_t *srcParam, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:801
rsComm_t
Definition: rcConnect.h:145
SYS_INTERNAL_NULL_INPUT_ERR
@ SYS_INTERNAL_NULL_INPUT_ERR
Definition: rodsErrorTable.h:92
getAllSessionVarValue
int getAllSessionVarValue(ruleExecInfo_t *rei, keyValPair_t *varValues)
Definition: reVariableMap.cpp:379
msiSplitPath
int msiSplitPath(msParam_t *inpPath, msParam_t *outParentColl, msParam_t *outChildName, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:281
msiGetStdoutInExecCmdOut
int msiGetStdoutInExecCmdOut(msParam_t *inpExecCmdOut, msParam_t *outStr, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:45
RuleExecInfo::status
int status
Definition: irods_re_structs.hpp:19
rcMisc.h
msiExit
int msiExit(msParam_t *inpParam1, msParam_t *inpParam2, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:754
addKeyValToMspStr
int addKeyValToMspStr(msParam_t *keyStr, msParam_t *valStr, msParam_t *msKeyValStr)
Definition: msParam.cpp:1389
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
MsParam::type
char * type
Definition: msParam.h:78
STR_MS_T
#define STR_MS_T
Definition: msParam.h:21
RuleExecInfo::rsComm
rsComm_t * rsComm
Definition: irods_re_structs.hpp:22
KeyValPair::value
char ** value
Definition: objInfo.h:123
rsComm_t::rError
rError_t rError
Definition: rcConnect.h:158
rodsLogAndErrorMsg
void rodsLogAndErrorMsg(int level, rError_t *myError, int status, const char *formatStr,...)
Definition: rodsLog.cpp:231
msiGetSessionVarValue
int msiGetSessionVarValue(msParam_t *inpVar, msParam_t *outputMode, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:359
KeyValPair::keyWord
char ** keyWord
Definition: objInfo.h:122
getStderrInExecCmdOut
int getStderrInExecCmdOut(msParam_t *inpExecCmdOut, char **outStr)
Definition: msParam.cpp:1028
msiGetStderrInExecCmdOut
int msiGetStderrInExecCmdOut(msParam_t *inpExecCmdOut, msParam_t *outStr, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:93
MAX_NAME_LEN
#define MAX_NAME_LEN
Definition: rodsDef.h:61
addRErrorMsg
int addRErrorMsg(rError_t *myError, int status, const char *msg)
Definition: rcMisc.cpp:121
getSessionVarValue
int getSessionVarValue(char *action, char *varName, ruleExecInfo_t *rei, char **varValue)
Definition: reVariableMap.cpp:405
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
MsParam
Definition: msParam.h:76
splitPathByKey
int splitPathByKey(const char *srcPath, char *dir, size_t maxDirLen, char *file, size_t maxFileLen, char key)
Definition: stringOpr.cpp:222
msiAddKeyValToMspStr
int msiAddKeyValToMspStr(msParam_t *keyStr, msParam_t *valStr, msParam_t *msKeyValStr, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:231
LOG_NOTICE
#define LOG_NOTICE
Definition: rodsLog.h:33
getStdoutInExecCmdOut
int getStdoutInExecCmdOut(msParam_t *inpExecCmdOut, char **outStr)
Definition: msParam.cpp:1000
USER_PARAM_TYPE_ERR
@ USER_PARAM_TYPE_ERR
Definition: rodsErrorTable.h:254
msiHelper.hpp
UNKNOWN_PARAM_IN_RULE_ERR
@ UNKNOWN_PARAM_IN_RULE_ERR
Definition: rodsErrorTable.h:599
fillStrInMsParam
void fillStrInMsParam(msParam_t *msParam, const char *myStr)
Definition: msParam.cpp:278
msiStrchop
int msiStrchop(msParam_t *stringIn, msParam_t *stringOut, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:549
RuleExecInfo
Definition: irods_re_structs.hpp:18
RE_TEST_MACRO
#define RE_TEST_MACRO(msg)
Definition: reDefines.h:58
KeyValPair::len
int len
Definition: objInfo.h:121
fillIntInMsParam
void fillIntInMsParam(msParam_t *msParam, const int myInt)
Definition: msParam.cpp:242
MsParam::inOutStruct
void * inOutStruct
Definition: msParam.h:80
msiSubstr
int msiSubstr(msParam_t *stringIn, msParam_t *offset, msParam_t *length, msParam_t *stringOut, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:628
rstrcpy
char * rstrcpy(char *dest, const char *src, int maxLen)
Definition: stringOpr.cpp:51
msiStrlen
int msiStrlen(msParam_t *stringIn, msParam_t *lengthOut, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:479
NAME_LEN
#define NAME_LEN
Definition: rodsDef.h:55
KeyValPair
Definition: objInfo.h:120
reFuncDefs.hpp
clearKeyVal
int clearKeyVal(keyValPair_t *condInput)
Definition: rcMisc.cpp:1047
msiWriteRodsLog
int msiWriteRodsLog(msParam_t *inpParam1, msParam_t *outParam, ruleExecInfo_t *rei)
Definition: msiHelper.cpp:157
ERR_MSG_LEN
#define ERR_MSG_LEN
Definition: rodsError.h:16
USER__NULL_INPUT_ERR
@ USER__NULL_INPUT_ERR
Definition: rodsErrorTable.h:247