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)  

nre.ruleAdminMS.cpp
Go to the documentation of this file.
1 
6 
9 //#include "reFuncDefs.hpp"
10 //#include "reGlobalsExtern.hpp"
11 //#include "rsGlobalExtern.hpp"
12 #include "dataObjCreate.h"
13 #include "objMetaOpr.hpp"
14 #include "regDataObj.h"
15 #include "miscServerFunct.hpp"
16 
17 #include "irods_re_structs.hpp"
18 
19 
56  int i;
57 
58  _writeString( "stdout", "----------------------------- DVM -----------------------------\n", rei );
59 
60  i = _admShowDVM( rei, &appRuleVarDef, 0 );
61  if ( i != 0 ) {
62  return i;
63  }
64  i = _admShowDVM( rei, &coreRuleVarDef, 1000 );
65  _writeString( "stdout", "----------------------------- DVM -----------------------------\n", rei );
66  return i;
67 }
68 
69 int _admShowDVM( ruleExecInfo_t *rei, rulevardef_t *inRuleVarDef, int inx ) {
70  int j;
71  char outStr[MAX_RULE_LENGTH];
72 
73  _writeString( "stdout", "---------------------------------------------------------------\n", rei );
74  for ( j = 0 ; j < inRuleVarDef->MaxNumOfDVars ; j++ ) {
75  sprintf( outStr, " %-5i %-15.15s %s ===> %s\n", j + inx, inRuleVarDef->action[j],
76  inRuleVarDef->varName[j], inRuleVarDef->var2CMap[j] );
77  _writeString( "stdout", outStr, rei );
78  }
79  _writeString( "stdout", "---------------------------------------------------------------\n", rei );
80  return 0;
81 }
82 
119  int i;
120 
121  _writeString( "stdout", "----------------------------- FNM -----------------------------\n", rei );
122  i = _admShowFNM( rei, &appRuleFuncMapDef, 0 );
123  if ( i != 0 ) {
124  return i;
125  }
126  i = _admShowFNM( rei, &coreRuleFuncMapDef, 1000 );
127  _writeString( "stdout", "----------------------------- FNM -----------------------------\n", rei );
128  return i;
129 }
130 
131 int _admShowFNM( ruleExecInfo_t *rei, rulefmapdef_t *inRuleFuncMapDef, int inx ) {
132 
133  int j;
134  char outStr[MAX_RULE_LENGTH];
135 
136  _writeString( "stdout", "---------------------------------------------------------------\n", rei );
137  for ( j = 0 ; j < inRuleFuncMapDef->MaxNumOfFMaps ; j++ ) {
138  sprintf( outStr, " %-5i %s ===> %s\n", j + inx, inRuleFuncMapDef->funcName[j], inRuleFuncMapDef->func2CMap[j] );
139  _writeString( "stdout", outStr, rei );
140  }
141  _writeString( "stdout", "---------------------------------------------------------------\n", rei );
142  return 0;
143 
144 }
145 
146 
183 int msiAdmReadDVMapsFromFileIntoStruct( msParam_t *inDvmFileNameParam, msParam_t *outCoreDVMapStruct, ruleExecInfo_t *rei ) {
184 
185  int i;
186  dvmStruct_t *coreDVMapStruct;
187 
188  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
189  return i;
190  }
191 
192  RE_TEST_MACRO( "Loopback on msiAdmReadDVMapsFromFileIntoStruct" );
193 
194 
195  if ( inDvmFileNameParam == NULL ||
196  strcmp( inDvmFileNameParam->type, STR_MS_T ) != 0 ||
197  inDvmFileNameParam->inOutStruct == NULL ||
198  strlen( ( char * ) inDvmFileNameParam->inOutStruct ) == 0 ) {
200  }
201  if ( outCoreDVMapStruct->type != NULL &&
202  strcmp( outCoreDVMapStruct->type, DVMapStruct_MS_T ) == 0 &&
203  outCoreDVMapStruct->inOutStruct != NULL ) {
204  coreDVMapStruct = ( dvmStruct_t * ) outCoreDVMapStruct->inOutStruct;
205  }
206  else {
207  coreDVMapStruct = ( dvmStruct_t * ) malloc( sizeof( dvmStruct_t ) );
208  coreDVMapStruct->MaxNumOfDVars = 0;
209  }
210  i = readDVarStructFromFile( ( char* ) inDvmFileNameParam->inOutStruct, coreDVMapStruct );
211  if ( i != 0 ) {
212  free( coreDVMapStruct );
213  return i;
214  }
215 
216  outCoreDVMapStruct->inOutStruct = ( void * ) coreDVMapStruct;
217  if ( outCoreDVMapStruct->type == NULL ||
218  strcmp( outCoreDVMapStruct->type, DVMapStruct_MS_T ) != 0 ) {
219  free( outCoreDVMapStruct->type );
220  outCoreDVMapStruct->type = strdup( DVMapStruct_MS_T );
221  }
222  return 0;
223 }
224 
260 int msiAdmInsertDVMapsFromStructIntoDB( msParam_t *inDvmBaseNameParam, msParam_t *inCoreDVMapStruct, ruleExecInfo_t *rei ) {
261 
262  dvmStruct_t *coreDVMapStruct;
263  int i;
264 
265  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
266  return i;
267  }
268 
269  RE_TEST_MACRO( "Loopback on msiAdmInsertDVMapsFromStructIntoDB" );
270 
271  if ( inDvmBaseNameParam == NULL || inCoreDVMapStruct == NULL ||
272  strcmp( inDvmBaseNameParam->type, STR_MS_T ) != 0 ||
273  strcmp( inCoreDVMapStruct->type, DVMapStruct_MS_T ) != 0 ||
274  inDvmBaseNameParam->inOutStruct == NULL ||
275  inCoreDVMapStruct->inOutStruct == NULL ||
276  strlen( ( char * ) inDvmBaseNameParam->inOutStruct ) == 0 ) {
278  }
279 
280  coreDVMapStruct = ( dvmStruct_t * ) inCoreDVMapStruct->inOutStruct;
281  i = insertDVMapsIntoDB( ( char * ) inDvmBaseNameParam->inOutStruct, coreDVMapStruct, rei );
282  return i;
283 
284 }
285 
286 
322 int
323 msiGetDVMapsFromDBIntoStruct( msParam_t *inDvmBaseNameParam, msParam_t *inVersionParam, msParam_t *outCoreDVMapStruct, ruleExecInfo_t *rei ) {
324 
325  int i;
326  dvmStruct_t *coreDVMapStruct;
327 
328  RE_TEST_MACRO( "Loopback on msiGetDVMapsFromDBIntoStruct" );
329 
330  if ( inDvmBaseNameParam == NULL ||
331  strcmp( inDvmBaseNameParam->type, STR_MS_T ) != 0 ||
332  inDvmBaseNameParam->inOutStruct == NULL ||
333  strlen( ( char * ) inDvmBaseNameParam->inOutStruct ) == 0 ) {
335  }
336  if ( inVersionParam == NULL ||
337  strcmp( inVersionParam->type, STR_MS_T ) != 0 ||
338  inVersionParam->inOutStruct == NULL ||
339  strlen( ( char * ) inVersionParam->inOutStruct ) == 0 ) {
341  }
342  if ( outCoreDVMapStruct->type != NULL &&
343  strcmp( outCoreDVMapStruct->type, DVMapStruct_MS_T ) == 0 &&
344  outCoreDVMapStruct->inOutStruct != NULL ) {
345  coreDVMapStruct = ( dvmStruct_t * ) outCoreDVMapStruct->inOutStruct;
346  }
347  else {
348  coreDVMapStruct = ( dvmStruct_t * ) malloc( sizeof( dvmStruct_t ) );
349  coreDVMapStruct->MaxNumOfDVars = 0;
350  }
351  i = readDVMapStructFromDB( ( char* ) inDvmBaseNameParam->inOutStruct, ( char* ) inVersionParam->inOutStruct, coreDVMapStruct, rei );
352  if ( i != 0 ) {
353  if ( strcmp( outCoreDVMapStruct->type, DVMapStruct_MS_T ) != 0 ) {
354  free( coreDVMapStruct );
355  }
356  return i;
357  }
358 
359  outCoreDVMapStruct->inOutStruct = ( void * ) coreDVMapStruct;
360  if ( outCoreDVMapStruct->type == NULL ||
361  strcmp( outCoreDVMapStruct->type, DVMapStruct_MS_T ) != 0 ) {
362  free( outCoreDVMapStruct->type );
363  outCoreDVMapStruct->type = strdup( DVMapStruct_MS_T );
364  }
365  return 0;
366 }
367 
403 int
404 msiAdmWriteDVMapsFromStructIntoFile( msParam_t *inDvmFileNameParam, msParam_t *inCoreDVMapStruct, ruleExecInfo_t *rei ) {
405  int i;
406  dvmStruct_t *myDVMapStruct;
407 
408  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
409  return i;
410  }
411 
412  RE_TEST_MACRO( "Loopback on msiAdmWriteDVMapsFromStructIntoFile" );
413 
414  if ( inDvmFileNameParam == NULL || inCoreDVMapStruct == NULL ||
415  strcmp( inDvmFileNameParam->type, STR_MS_T ) != 0 ||
416  strcmp( inCoreDVMapStruct->type, DVMapStruct_MS_T ) != 0 ||
417  inDvmFileNameParam->inOutStruct == NULL ||
418  strlen( ( char * ) inDvmFileNameParam->inOutStruct ) == 0 ) {
420  }
421 
422  myDVMapStruct = ( dvmStruct_t * ) inCoreDVMapStruct->inOutStruct;
423  i = writeDVMapsIntoFile( ( char * ) inDvmFileNameParam->inOutStruct, myDVMapStruct, rei );
424  return i;
425 
426 }
427 
428 
465 int msiAdmReadFNMapsFromFileIntoStruct( msParam_t *inFnmFileNameParam, msParam_t *outCoreFNMapStruct, ruleExecInfo_t *rei ) {
466 
467  int i;
468  fnmapStruct_t *coreFNMapStrct;
469  fnmapStruct_t *coreFNMapStrctBuf = NULL;
470 
471  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
472  return i;
473  }
474 
475  RE_TEST_MACRO( "Loopback on msiAdmReadFNMapsFromFileIntoStruct" );
476 
477 
478  if ( inFnmFileNameParam == NULL ||
479  strcmp( inFnmFileNameParam->type, STR_MS_T ) != 0 ||
480  inFnmFileNameParam->inOutStruct == NULL ||
481  strlen( ( char * ) inFnmFileNameParam->inOutStruct ) == 0 ) {
483  }
484  if ( outCoreFNMapStruct->type != NULL &&
485  strcmp( outCoreFNMapStruct->type, FNMapStruct_MS_T ) == 0 &&
486  outCoreFNMapStruct->inOutStruct != NULL ) {
487  coreFNMapStrct = ( fnmapStruct_t * ) outCoreFNMapStruct->inOutStruct;
488  }
489  else {
490  coreFNMapStrct = coreFNMapStrctBuf = ( fnmapStruct_t * ) malloc( sizeof( fnmapStruct_t ) );
491  coreFNMapStrct->MaxNumOfFMaps = 0;
492  }
493  i = readFuncMapStructFromFile( ( char* ) inFnmFileNameParam->inOutStruct, coreFNMapStrct );
494  if ( i != 0 ) {
495  free( coreFNMapStrctBuf );
496  return i;
497  }
498 
499  if ( coreFNMapStrctBuf ) {
500  free( outCoreFNMapStruct->inOutStruct );
501  }
502  outCoreFNMapStruct->inOutStruct = ( void * ) coreFNMapStrctBuf;
503  if ( outCoreFNMapStruct->type == NULL ||
504  strcmp( outCoreFNMapStruct->type, FNMapStruct_MS_T ) != 0 ) {
505  free( outCoreFNMapStruct->type );
506  outCoreFNMapStruct->type = strdup( FNMapStruct_MS_T );
507  }
508  return 0;
509 }
510 
511 
547 int msiAdmInsertFNMapsFromStructIntoDB( msParam_t *inFnmBaseNameParam, msParam_t *inCoreFNMapStruct, ruleExecInfo_t *rei ) {
548 
549  fnmapStruct_t *coreFNMapStruct;
550  int i;
551 
552  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
553  return i;
554  }
555 
556  RE_TEST_MACRO( "Loopback on msiAdmInsertFNMapsFromStructIntoDB" );
557 
558  if ( inFnmBaseNameParam == NULL || inCoreFNMapStruct == NULL ||
559  strcmp( inFnmBaseNameParam->type, STR_MS_T ) != 0 ||
560  strcmp( inCoreFNMapStruct->type, FNMapStruct_MS_T ) != 0 ||
561  inFnmBaseNameParam->inOutStruct == NULL ||
562  inCoreFNMapStruct->inOutStruct == NULL ||
563  strlen( ( char * ) inFnmBaseNameParam->inOutStruct ) == 0 ) {
565  }
566 
567  coreFNMapStruct = ( fnmapStruct_t * ) inCoreFNMapStruct->inOutStruct;
568  i = insertFNMapsIntoDB( ( char * ) inFnmBaseNameParam->inOutStruct, coreFNMapStruct, rei );
569  return i;
570 
571 }
572 
573 
609 int
610 msiGetFNMapsFromDBIntoStruct( msParam_t *inFnmBaseNameParam, msParam_t *inVersionParam, msParam_t *outCoreFNMapStruct, ruleExecInfo_t *rei ) {
611 
612  int i;
613  fnmapStruct_t *coreFNMapStrct;
614 
615  RE_TEST_MACRO( "Loopback on msiGetFNMapsFromDBIntoStruct" );
616 
617  if ( inFnmBaseNameParam == NULL ||
618  strcmp( inFnmBaseNameParam->type, STR_MS_T ) != 0 ||
619  inFnmBaseNameParam->inOutStruct == NULL ||
620  strlen( ( char * ) inFnmBaseNameParam->inOutStruct ) == 0 ) {
622  }
623  if ( inVersionParam == NULL ||
624  strcmp( inVersionParam->type, STR_MS_T ) != 0 ||
625  inVersionParam->inOutStruct == NULL ||
626  strlen( ( char * ) inVersionParam->inOutStruct ) == 0 ) {
628  }
629  if ( outCoreFNMapStruct->type != NULL &&
630  strcmp( outCoreFNMapStruct->type, FNMapStruct_MS_T ) == 0 &&
631  outCoreFNMapStruct->inOutStruct != NULL ) {
632  coreFNMapStrct = ( fnmapStruct_t * ) outCoreFNMapStruct->inOutStruct;
633  }
634  else {
635  coreFNMapStrct = ( fnmapStruct_t * ) malloc( sizeof( fnmapStruct_t ) );
636  coreFNMapStrct->MaxNumOfFMaps = 0;
637  }
638  i = readFNMapStructFromDB( ( char* ) inFnmBaseNameParam->inOutStruct, ( char* ) inVersionParam->inOutStruct, coreFNMapStrct, rei );
639  if ( i != 0 ) {
640  if ( strcmp( outCoreFNMapStruct->type, FNMapStruct_MS_T ) != 0 ) {
641  free( coreFNMapStrct );
642  }
643  return i;
644  }
645 
646  outCoreFNMapStruct->inOutStruct = ( void * ) coreFNMapStrct;
647  if ( outCoreFNMapStruct->type == NULL ||
648  strcmp( outCoreFNMapStruct->type, FNMapStruct_MS_T ) != 0 ) {
649  free( outCoreFNMapStruct->type );
650  outCoreFNMapStruct->type = strdup( FNMapStruct_MS_T );
651  }
652  return 0;
653 }
654 
655 
691 int
692 msiAdmWriteFNMapsFromStructIntoFile( msParam_t *inFnmFileNameParam, msParam_t *inCoreFNMapStruct, ruleExecInfo_t *rei ) {
693  int i;
694  fnmapStruct_t *myFNMapStruct;
695 
696  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
697  return i;
698  }
699 
700  RE_TEST_MACRO( "Loopback on msiAdmWriteFNMapsFromStructIntoFile" );
701 
702  if ( inFnmFileNameParam == NULL || inCoreFNMapStruct == NULL ||
703  strcmp( inFnmFileNameParam->type, STR_MS_T ) != 0 ||
704  strcmp( inCoreFNMapStruct->type, FNMapStruct_MS_T ) != 0 ||
705  inFnmFileNameParam->inOutStruct == NULL ||
706  strlen( ( char * ) inFnmFileNameParam->inOutStruct ) == 0 ) {
708  }
709 
710  myFNMapStruct = ( fnmapStruct_t * ) inCoreFNMapStruct->inOutStruct;
711  i = writeFNMapsIntoFile( ( char * ) inFnmFileNameParam->inOutStruct, myFNMapStruct, rei );
712  return i;
713 
714 }
715 
716 
753 int msiAdmReadMSrvcsFromFileIntoStruct( msParam_t *inMsrvcFileNameParam, msParam_t *outCoreMsrvcStruct, ruleExecInfo_t *rei ) {
754 
755  int i;
756  msrvcStruct_t *coreMsrvcStrct;
757 
758  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
759  return i;
760  }
761 
762  RE_TEST_MACRO( "Loopback on msiAdmReadMSrvcsFromFileIntoStruct" );
763 
764 
765  if ( inMsrvcFileNameParam == NULL ||
766  strcmp( inMsrvcFileNameParam->type, STR_MS_T ) != 0 ||
767  inMsrvcFileNameParam->inOutStruct == NULL ||
768  strlen( ( char * ) inMsrvcFileNameParam->inOutStruct ) == 0 ) {
770  }
771  if ( outCoreMsrvcStruct->type != NULL &&
772  strcmp( outCoreMsrvcStruct->type, MsrvcStruct_MS_T ) == 0 &&
773  outCoreMsrvcStruct->inOutStruct != NULL ) {
774  coreMsrvcStrct = ( msrvcStruct_t * ) outCoreMsrvcStruct->inOutStruct;
775  }
776  else {
777  coreMsrvcStrct = ( msrvcStruct_t * ) malloc( sizeof( msrvcStruct_t ) );
778  coreMsrvcStrct->MaxNumOfMsrvcs = 0;
779  }
780  i = readMsrvcStructFromFile( ( char* ) inMsrvcFileNameParam->inOutStruct, coreMsrvcStrct );
781  if ( i != 0 ) {
782  free( coreMsrvcStrct );
783  return i;
784  }
785 
786  outCoreMsrvcStruct->inOutStruct = ( void * ) coreMsrvcStrct;
787  if ( outCoreMsrvcStruct->type == NULL ||
788  strcmp( outCoreMsrvcStruct->type, MsrvcStruct_MS_T ) != 0 ) {
789  free( outCoreMsrvcStruct->type );
790  outCoreMsrvcStruct->type = strdup( MsrvcStruct_MS_T );
791  }
792  return 0;
793 }
794 
795 
832 
834  int i;
835 
836  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
837  return i;
838  }
839 
840  RE_TEST_MACRO( "Loopback on msiAdmInsertMSrvcsFromStructIntoDB" );
841 
842  if ( inCoreMsrvcStruct == NULL ||
843  strcmp( inCoreMsrvcStruct->type, MsrvcStruct_MS_T ) != 0 ||
844  inCoreMsrvcStruct->inOutStruct == NULL ) {
846  }
847 
848  coreMsrvcStruct = ( msrvcStruct_t * ) inCoreMsrvcStruct->inOutStruct;
850  return i;
851 
852 }
853 
854 
889 int
890 msiGetMSrvcsFromDBIntoStruct( msParam_t *inStatus, msParam_t *outCoreMsrvcStruct, ruleExecInfo_t *rei ) {
891 
892  int i, stat;
893  msrvcStruct_t *coreMsrvcStrct;
894 
895  RE_TEST_MACRO( "Loopback on msiGetMSrvcsFromDBIntoStruct" );
896 
897  if ( outCoreMsrvcStruct->type != NULL &&
898  strcmp( outCoreMsrvcStruct->type, MsrvcStruct_MS_T ) == 0 &&
899  outCoreMsrvcStruct->inOutStruct != NULL ) {
900  coreMsrvcStrct = ( msrvcStruct_t * ) outCoreMsrvcStruct->inOutStruct;
901  }
902  else {
903  coreMsrvcStrct = ( msrvcStruct_t * ) malloc( sizeof( msrvcStruct_t ) );
904  coreMsrvcStrct->MaxNumOfMsrvcs = 0;
905  }
906  if ( inStatus != NULL && inStatus->type != NULL && inStatus->inOutStruct != NULL ) {
907  if ( strcmp( inStatus->type, INT_MS_T ) == 0 ) {
908  stat = *( int * )inStatus->inOutStruct;
909  }
910  else if ( strcmp( inStatus->type, STR_MS_T ) == 0 ) {
911  stat = atoi( ( char * ) inStatus->inOutStruct );
912  }
913  else {
914  free( coreMsrvcStrct ); // cppcheck - Memory leak: coreMsrvcStrct
915  return USER_PARAM_TYPE_ERR;
916  }
917  }
918  else {
919  free( coreMsrvcStrct ); // cppcheck - Memory leak: coreMsrvcStrct
921  }
922  i = readMsrvcStructFromDB( stat, coreMsrvcStrct, rei );
923  if ( i != 0 ) {
924  if ( strcmp( outCoreMsrvcStruct->type, MsrvcStruct_MS_T ) != 0 ) {
925  free( coreMsrvcStrct );
926  }
927  return i;
928  }
929 
930  outCoreMsrvcStruct->inOutStruct = ( void * ) coreMsrvcStrct;
931  if ( outCoreMsrvcStruct->type == NULL ||
932  strcmp( outCoreMsrvcStruct->type, MsrvcStruct_MS_T ) != 0 ) {
933  free( outCoreMsrvcStruct->type );
934  outCoreMsrvcStruct->type = strdup( MsrvcStruct_MS_T );
935  }
936  return 0;
937 }
938 
974 int
975 msiAdmWriteMSrvcsFromStructIntoFile( msParam_t *inMsrvcFileNameParam, msParam_t *inCoreMsrvcStruct, ruleExecInfo_t *rei ) {
976  int i;
977  msrvcStruct_t *myMsrvcStruct;
978 
979  if ( ( i = isUserPrivileged( rei->rsComm ) ) != 0 ) {
980  return i;
981  }
982 
983  RE_TEST_MACRO( "Loopback on msiAdmWriteMSrvcsFromStructIntoFile" );
984 
985  if ( inMsrvcFileNameParam == NULL || inCoreMsrvcStruct == NULL ||
986  strcmp( inMsrvcFileNameParam->type, STR_MS_T ) != 0 ||
987  strcmp( inCoreMsrvcStruct->type, MsrvcStruct_MS_T ) != 0 ||
988  inMsrvcFileNameParam->inOutStruct == NULL ||
989  strlen( ( char * ) inMsrvcFileNameParam->inOutStruct ) == 0 ) {
991  }
992 
993  myMsrvcStruct = ( msrvcStruct_t * ) inCoreMsrvcStruct->inOutStruct;
994  i = writeMSrvcsIntoFile( ( char * ) inMsrvcFileNameParam->inOutStruct, myMsrvcStruct, rei );
995  return i;
996 
997 }
998 
msiAdmWriteDVMapsFromStructIntoFile
int msiAdmWriteDVMapsFromStructIntoFile(msParam_t *inDvmFileNameParam, msParam_t *inCoreDVMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:404
msiAdmInsertMSrvcsFromStructIntoDB
int msiAdmInsertMSrvcsFromStructIntoDB(msParam_t *, msParam_t *inCoreMsrvcStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:831
readFNMapStructFromDB
int readFNMapStructFromDB(char *fnmBaseName, char *versionStr, fnmapStruct_t *inFnmStrct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:608
NULL
#define NULL
Definition: rodsDef.h:70
regDataObj.h
appRuleVarDef
rulevardef_t appRuleVarDef
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:51
msiAdmInsertFNMapsFromStructIntoDB
int msiAdmInsertFNMapsFromStructIntoDB(msParam_t *inFnmBaseNameParam, msParam_t *inCoreFNMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:547
coreRuleFuncMapDef
rulefmapdef_t coreRuleFuncMapDef
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:49
readDVMapStructFromDB
int readDVMapStructFromDB(char *dvmBaseName, char *versionStr, rulevardef_t *inDvmStrct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:556
rulefmapdef_t::MaxNumOfFMaps
int MaxNumOfFMaps
Definition: reGlobalsExtern.hpp:113
readDVarStructFromFile
int readDVarStructFromFile(char *dvarBaseName, rulevardef_t *inRuleVarDef)
Definition: nre.reLib1.cpp:799
_writeString
int _writeString(char *writeId, char *writeStr, ruleExecInfo_t *rei)
Definition: irods_re_structs.cpp:278
writeFNMapsIntoFile
int writeFNMapsIntoFile(char *inFileName, fnmapStruct_t *myFNMapStruct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:1423
coreRuleVarDef
rulevardef_t coreRuleVarDef
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:48
readFuncMapStructFromFile
int readFuncMapStructFromFile(char *fmapBaseName, rulefmapdef_t *inRuleFuncMapDef)
Definition: nre.reLib1.cpp:862
INT_MS_T
#define INT_MS_T
Definition: msParam.h:22
dataObjCreate.h
MsParam::type
char * type
Definition: msParam.h:78
STR_MS_T
#define STR_MS_T
Definition: msParam.h:21
msiGetMSrvcsFromDBIntoStruct
int msiGetMSrvcsFromDBIntoStruct(msParam_t *inStatus, msParam_t *outCoreMsrvcStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:890
RuleExecInfo::rsComm
rsComm_t * rsComm
Definition: irods_re_structs.hpp:22
msrvcStruct_t::MaxNumOfMsrvcs
int MaxNumOfMsrvcs
Definition: reGlobalsExtern.hpp:122
DVMapStruct_MS_T
#define DVMapStruct_MS_T
Definition: msParam.h:57
rulefmapdef_t::funcName
char * funcName[2048]
Definition: reGlobalsExtern.hpp:114
readMsrvcStructFromFile
int readMsrvcStructFromFile(char *msrvcFileName, msrvcStruct_t *inMsrvcStruct)
Definition: nre.reLib1.cpp:928
msiAdmInsertDVMapsFromStructIntoDB
int msiAdmInsertDVMapsFromStructIntoDB(msParam_t *inDvmBaseNameParam, msParam_t *inCoreDVMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:260
msiAdmShowDVM
int msiAdmShowDVM(msParam_t *, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:55
rulevardef_t
Definition: reGlobalsExtern.hpp:102
MAX_RULE_LENGTH
#define MAX_RULE_LENGTH
Definition: reDefines.h:19
insertMSrvcsIntoDB
int insertMSrvcsIntoDB(msrvcStruct_t *inMsrvcStruct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:1296
msiAdmReadMSrvcsFromFileIntoStruct
int msiAdmReadMSrvcsFromFileIntoStruct(msParam_t *inMsrvcFileNameParam, msParam_t *outCoreMsrvcStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:753
msiGetFNMapsFromDBIntoStruct
int msiGetFNMapsFromDBIntoStruct(msParam_t *inFnmBaseNameParam, msParam_t *inVersionParam, msParam_t *outCoreFNMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:610
MsParam
Definition: msParam.h:76
PARAOPR_EMPTY_IN_STRUCT_ERR
@ PARAOPR_EMPTY_IN_STRUCT_ERR
Definition: rodsErrorTable.h:647
msiGetDVMapsFromDBIntoStruct
int msiGetDVMapsFromDBIntoStruct(msParam_t *inDvmBaseNameParam, msParam_t *inVersionParam, msParam_t *outCoreDVMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:323
MsrvcStruct_MS_T
#define MsrvcStruct_MS_T
Definition: msParam.h:59
miscServerFunct.hpp
msiAdmWriteMSrvcsFromStructIntoFile
int msiAdmWriteMSrvcsFromStructIntoFile(msParam_t *inMsrvcFileNameParam, msParam_t *inCoreMsrvcStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:975
_admShowDVM
int _admShowDVM(ruleExecInfo_t *rei, rulevardef_t *inRuleVarDef, int inx)
Definition: nre.ruleAdminMS.cpp:69
rulevardef_t::MaxNumOfDVars
int MaxNumOfDVars
Definition: reGlobalsExtern.hpp:103
USER_PARAM_TYPE_ERR
@ USER_PARAM_TYPE_ERR
Definition: rodsErrorTable.h:254
insertFNMapsIntoDB
int insertFNMapsIntoDB(char *baseName, fnmapStruct_t *coreFNMStruct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:1251
msiAdmWriteFNMapsFromStructIntoFile
int msiAdmWriteFNMapsFromStructIntoFile(msParam_t *inFnmFileNameParam, msParam_t *inCoreFNMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:692
insertDVMapsIntoDB
int insertDVMapsIntoDB(char *baseName, dvmStruct_t *coreDVMStruct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:1207
RuleExecInfo
Definition: irods_re_structs.hpp:18
irods_re_structs.hpp
rulefmapdef_t
Definition: reGlobalsExtern.hpp:112
RE_TEST_MACRO
#define RE_TEST_MACRO(msg)
Definition: reDefines.h:58
rulevardef_t::action
char * action[2048]
Definition: reGlobalsExtern.hpp:105
msiAdmShowFNM
int msiAdmShowFNM(msParam_t *, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:118
writeMSrvcsIntoFile
int writeMSrvcsIntoFile(char *inFileName, msrvcStruct_t *myMsrvcStruct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:1463
appRuleFuncMapDef
rulefmapdef_t appRuleFuncMapDef
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:52
_admShowFNM
int _admShowFNM(ruleExecInfo_t *rei, rulefmapdef_t *inRuleFuncMapDef, int inx)
Definition: nre.ruleAdminMS.cpp:131
msrvcStruct_t
Definition: reGlobalsExtern.hpp:121
rulevardef_t::varName
char * varName[2048]
Definition: reGlobalsExtern.hpp:104
coreMsrvcStruct
msrvcStruct_t coreMsrvcStruct
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:53
MsParam::inOutStruct
void * inOutStruct
Definition: msParam.h:80
rulevardef_t::var2CMap
char * var2CMap[2048]
Definition: reGlobalsExtern.hpp:106
writeDVMapsIntoFile
int writeDVMapsIntoFile(char *inFileName, dvmStruct_t *myDVMapStruct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:1383
readMsrvcStructFromDB
int readMsrvcStructFromDB(int inStatus, msrvcStruct_t *outMsrvcStrct, ruleExecInfo_t *rei)
Definition: nre.reLib1.cpp:657
FNMapStruct_MS_T
#define FNMapStruct_MS_T
Definition: msParam.h:58
rulefmapdef_t::func2CMap
char * func2CMap[2048]
Definition: reGlobalsExtern.hpp:115
isUserPrivileged
int isUserPrivileged(rsComm_t *rsComm)
Definition: miscServerFunct.cpp:1995
msiAdmReadFNMapsFromFileIntoStruct
int msiAdmReadFNMapsFromFileIntoStruct(msParam_t *inFnmFileNameParam, msParam_t *outCoreFNMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:465
msiAdmReadDVMapsFromFileIntoStruct
int msiAdmReadDVMapsFromFileIntoStruct(msParam_t *inDvmFileNameParam, msParam_t *outCoreDVMapStruct, ruleExecInfo_t *rei)
Definition: nre.ruleAdminMS.cpp:183
objMetaOpr.hpp