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.reHelpers1.cpp
Go to the documentation of this file.
1 
4 #include "reHelpers1.hpp"
5 
6 #include "reFuncDefs.hpp"
7 #include "index.hpp"
8 #include "parser.hpp"
9 #include "filesystem.hpp"
10 #include "configuration.hpp"
11 
12 #include "rcMisc.h"
13 #include "irods_log.hpp"
14 
15 
16 struct Breakpoint {
17  char *actionName;
18  char *base;
19  int pending;
20  int row;
21  int line;
23  rodsLong_t finish; /* exclusive */
24 } breakPoints[100];
25 
27 
30 
31 
32 void disableReDebugger( int grdf[2] ) {
33  grdf[0] = GlobalREAuditFlag;
34  grdf[1] = GlobalREDebugFlag;
37 
38 }
39 
40 void enableReDebugger( int grdf[2] ) {
41  GlobalREAuditFlag = grdf[0];
42  GlobalREDebugFlag = grdf[1];
43 
44 }
48 int myPID;
49 
50 int initializeReDebug( rsComm_t *svrComm ) {
51  char condRead[NAME_LEN];
52  int i, s, m, status;
53  char *readhdr = NULL;
54  char *readmsg = NULL;
55  char *user = NULL;
56  char *addr = NULL;
57 
58  if ( svrComm == NULL ) {
59  return 0;
60  }
61  if ( GlobalREDebugFlag != 4 ) {
62  return 0;
63  }
64 
65  s = 0;
66  m = 0;
67  myPID = ( int ) getpid();
68  myHostName[0] = '\0';
69  gethostname( myHostName, MAX_NAME_LEN );
70  sprintf( condRead, "(*XUSER == \"%s@%s\") && (*XHDR == \"STARTDEBUG\")",
71  svrComm->clientUser.userName, svrComm->clientUser.rodsZone );
72  status = _readXMsg( GlobalREDebugFlag, condRead, &m, &s, &readhdr, &readmsg, &user, &addr );
73  if ( status >= 0 ) {
74  if ( ( readmsg != NULL ) && strlen( readmsg ) > 0 ) {
75  GlobalREDebugFlag = atoi( readmsg );
76  }
77  if ( readhdr != NULL ) {
78  free( readhdr );
79  }
80  if ( readmsg != NULL ) {
81  free( readmsg );
82  }
83  if ( user != NULL ) {
84  free( user );
85  }
86  if ( addr != NULL ) {
87  free( addr );
88  }
89  /* initialize reDebug stack space*/
90  for ( i = 0; i < REDEBUG_STACK_SIZE_FULL; i++ ) {
92  }
93  for ( i = 0; i < REDEBUG_STACK_SIZE_CURR; i++ ) {
94  reDebugStackCurr[i].label = -1;
96  }
97  memset( breakPoints, 0, sizeof( struct Breakpoint ) * 100 );
98 
101  snprintf( waitHdr, HEADER_TYPE_LEN - 1, "idbug:" );
102 
103  rodsLog( LOG_NOTICE, "reDebugInitialization: Got Debug StreamId:%i\n", GlobalREDebugFlag );
104  snprintf( waitMsg, MAX_NAME_LEN, "PROCESS BEGIN at %s:%i. Client connected from %s at port %i\n",
105  myHostName, myPID, svrComm->clientAddr, ntohs( svrComm->localAddr.sin_port ) );
106  _writeXMsg( GlobalREDebugFlag, "idbug", waitMsg );
107  snprintf( waitMsg, MAX_NAME_LEN, "%s:%i is waiting\n", myHostName, myPID );
108  }
109  return 0;
110 }
111 
112 
113 int processXMsg( int streamId, char *readmsg,
114  RuleEngineEventParam *param, Node *node,
115  Env *env, ruleExecInfo_t *rei ) {
116 
117  char myhdr[HEADER_TYPE_LEN];
118  char mymsg[MAX_NAME_LEN];
119  char *outStr = NULL;
120  int i, n;
121  int iLevel, wCnt;
122  int ruleInx = 0;
123  Region *r;
124  Res *res;
125  rError_t errmsg;
126  errmsg.len = 0;
127  errmsg.errMsg = NULL;
128  r = make_region( 0, NULL );
129  ParserContext *context = newParserContext( &errmsg, r );
130  Pointer *e = newPointer2( readmsg );
131  int rulegen = 1;
132  int found;
133  int grdf[2];
134  int cmd = 0;
135  int smallW;
136 
137  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug:%s", param->actionName );
138  memset( mymsg, 0, sizeof( mymsg ) );
139 
140  PARSER_BEGIN( DbgCmd )
141  TRY( DbgCmd )
142  TTEXT2( "n", "next" );
144  OR( DbgCmd )
145  TTEXT2( "s", "step" );
146  cmd = REDEBUG_NEXT;
147  OR( DbgCmd )
148  TTEXT2( "f", "finish" );
150  OR( DbgCmd )
151  TTEXT2( "b", "break" );
152  TRY( Param )
153  TTYPE( TK_TEXT );
154  int breakPointsInx2;
155  for ( breakPointsInx2 = 0; breakPointsInx2 < 100; breakPointsInx2++ ) {
156  if ( breakPoints[breakPointsInx2].actionName == NULL ) {
157  break;
158  }
159  }
160  if ( breakPointsInx2 == 100 ) {
161  _writeXMsg( streamId, myhdr, "Maximum breakpoint count reached. Breakpoint not set.\n" );
162  cmd = REDEBUG_WAIT;
163  }
164  else {
165  breakPoints[breakPointsInx2].actionName = strdup( token->text );
166  char * base_ptr = NULL;
167  TRY( loc )
168  TTYPE( TK_TEXT );
169  base_ptr = ( char * ) malloc( sizeof( token->text ) + 2 );
170  base_ptr[0] = 'f';
171  strcpy( base_ptr + 1, token->text );
172  TTEXT( ":" );
173  TTYPE( TK_INT );
174  breakPoints[breakPointsInx2].base = strdup( base_ptr );
175  breakPoints[breakPointsInx2].line = atoi( token->text );
176  rodsLong_t range[2];
177  char rulesFileName[MAX_NAME_LEN];
178  getRuleBasePath( base_ptr, rulesFileName );
179 
180  FILE *file;
181  /* char errbuf[ERR_MSG_LEN]; */
182  file = fopen( rulesFileName, "r" );
183  if ( file == NULL ) {
184  free( context );
185  deletePointer( e );
186  free( base_ptr );
187  return RULES_FILE_READ_ERROR;
188  }
189  Pointer *p = newPointer( file, base_ptr );
190 
191 
192  if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) {
193  breakPoints[breakPointsInx2].start = range[0];
194  breakPoints[breakPointsInx2].finish = range[1];
195  }
196  else {
197  breakPoints[breakPointsInx2].actionName = NULL;
198  }
199  deletePointer( p );
200  OR( loc )
201  TTYPE( TK_INT );
202  if ( node != NULL ) {
203  breakPoints[breakPointsInx2].base = strdup( node->base );
204  breakPoints[breakPointsInx2].line = atoi( token->text );
205  rodsLong_t range[2];
206  Pointer *p = newPointer2( breakPoints[breakPointsInx2].base );
207  if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) {
208  breakPoints[breakPointsInx2].start = range[0];
209  breakPoints[breakPointsInx2].finish = range[1];
210  }
211  else {
212  breakPoints[breakPointsInx2].actionName = NULL;
213  }
214  deletePointer( p );
215  }
216  else {
217  breakPoints[breakPointsInx2].actionName = NULL;
218  }
219  OR( loc )
220  /* breakPoints[breakPointsInx].base = NULL; */
221  END_TRY( loc )
222 
223  free( base_ptr );
224  if ( breakPoints[breakPointsInx2].actionName != NULL )
225  snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i set at %s\n", breakPointsInx2,
226  breakPoints[breakPointsInx2].actionName );
227  else {
228  snprintf( mymsg, MAX_NAME_LEN, "Cannot set breakpoint, source not available\n" );
229  }
230  _writeXMsg( streamId, myhdr, mymsg );
231  if ( breakPointsInx <= breakPointsInx2 ) {
232  breakPointsInx = breakPointsInx2 + 1;
233  }
234  cmd = REDEBUG_WAIT;
235  }
236  OR( Param )
238  _writeXMsg( streamId, myhdr, "Unknown parameter type.\n" );
239  cmd = REDEBUG_WAIT;
240  OR( Param )
241  _writeXMsg( streamId, myhdr, "Debugger command \'break\' requires at least one argument.\n" );
242  cmd = REDEBUG_WAIT;
243  END_TRY( Param )
244 
245  OR( DbgCmd )
246  TRY( Where )
247  TTEXT2( "w", "where" );
248  smallW = 1;
249  OR( Where )
250  TTEXT2( "W", "Where" );
251  smallW = 0;
252  END_TRY( Where )
253  wCnt = 20;
254  OPTIONAL_BEGIN( Param )
255  TTYPE( TK_INT );
256  wCnt = atoi( token->text );
257  OPTIONAL_END( Param )
258  iLevel = 0;
259 
260  i = reDebugStackCurrPtr - 1;
261  while ( i >= 0 && wCnt > 0 ) {
262  if ( !smallW || ( reDebugPCType( ( RuleEngineEvent ) reDebugStackCurr[i].label ) & 1 ) != 0 ) {
263  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i", iLevel );
264  char msg[HEADER_TYPE_LEN - 1];
265  RuleEngineEventParam param;
266  param.ruleIndex = 0;
267  param.actionName = reDebugStackCurr[i].step;
269  _writeXMsg( streamId, myhdr, msg );
271  iLevel++;
272  }
273  wCnt--;
274  }
275  i--;
276  }
277  OR( DbgCmd )
278  TTEXT2( "l", "list" );
279  TRY( Param )
280  TTEXT2( "r", "rule" );
281  TRY( ParamParam )
282  TTYPE( TK_TEXT );
283 
284  mymsg[0] = '\n';
285  mymsg[1] = '\0';
286  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
288  found = 0;
289  while ( findNextRule2( token->text, ruleInx, &node ) != NO_MORE_RULES_ERR ) {
290  found = 1;
291  if ( node->secondaryIndex ) {
292  n = node->condIndex->valIndex->len;
293  int i;
294  for ( i = 0; i < n; i++ ) {
295  Bucket *b = node->condIndex->valIndex->buckets[i];
296  while ( b != NULL ) {
297  RuleDesc *rd = getRuleDesc( *( int * )b->value );
298  char buf[MAX_RULE_LEN];
299  ruleToString( buf, MAX_RULE_LEN, rd );
300  snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf );
301  b = b->next;
302  }
303  }
304  }
305  else {
306  RuleDesc *rd = getRuleDesc( node->ruleIndex );
307  char buf[MAX_RULE_LEN];
308  ruleToString( buf, MAX_RULE_LEN, rd );
309  snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "\n %i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf );
310  }
311  ruleInx ++;
312  }
313  if ( !found ) {
314  snprintf( mymsg, MAX_NAME_LEN, "Rule %s not found\n", token->text );
315  }
316  _writeXMsg( streamId, myhdr, mymsg );
317  cmd = REDEBUG_WAIT;
318  OR( ParamParam )
319  _writeXMsg( streamId, myhdr, "Debugger command \'list rule\' requires one argument.\n" );
320  cmd = REDEBUG_WAIT;
321  END_TRY( ParamParam )
322  OR( Param )
323  TTEXT2( "b", "breakpoints" );
324  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
325  mymsg[0] = '\n';
326  mymsg[1] = '\0';
327  for ( i = 0; i < breakPointsInx; i++ ) {
328  if ( breakPoints[i].actionName != NULL ) {
329  if ( breakPoints[i].base != NULL ) {
330  snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s %s:%d\n", i , breakPoints[i].actionName, breakPoints[i].base[0] == 's' ? "<source>" : breakPoints[i].base + 1, breakPoints[i].line );
331  }
332  else {
333  snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName );
334  }
335  }
336  }
337  _writeXMsg( streamId, myhdr, mymsg );
338  cmd = REDEBUG_WAIT;
339  OR( Param )
340  TTEXT( "*" );
341  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
342  Env *cenv = env;
343  mymsg[0] = '\n';
344  mymsg[1] = '\0';
345  found = 0;
346  while ( cenv != NULL ) {
347  n = cenv->current->size;
348  for ( i = 0; i < n; i++ ) {
349  Bucket *b = cenv->current->buckets[i];
350  while ( b != NULL ) {
351  if ( b->key[0] == '*' ) { /* skip none * variables */
352  found = 1;
353  char typeString[128];
354  typeToString( ( ( Res * )b->value )->exprType, NULL, typeString, 128 );
355  snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%s of type %s\n", b->key, typeString );
356  }
357  b = b->next;
358  }
359  }
360  cenv = cenv->previous;
361  }
362  if ( !found ) {
363  snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "<empty>\n" );
364  }
365  _writeXMsg( streamId, myhdr, mymsg );
366  cmd = REDEBUG_WAIT;
367  OR( Param )
368  syncTokenQueue( e, context );
369  skipWhitespace( e );
370  ABORT( lookAhead( e, 0 ) != '$' );
371  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
372  mymsg[0] = '\n';
373  mymsg[1] = '\0';
374  Hashtable *vars = newHashTable( 100 );
375  for ( i = 0; i < coreRuleVarDef .MaxNumOfDVars; i++ ) {
376  if ( lookupFromHashTable( vars, coreRuleVarDef.varName[i] ) == NULL ) {
377  snprintf( &mymsg[strlen( mymsg )], MAX_NAME_LEN - strlen( mymsg ), "$%s\n", coreRuleVarDef.varName[i] );
379  }
380  }
381  deleteHashTable( vars, NULL );
382  _writeXMsg( streamId, myhdr, mymsg );
383  cmd = REDEBUG_WAIT;
384  OR( Param )
386  _writeXMsg( streamId, myhdr, "Unknown parameter type.\n" );
387  cmd = REDEBUG_WAIT;
388  OR( Param )
389  _writeXMsg( streamId, myhdr, "Debugger command \'list\' requires at least one argument.\n" );
390  cmd = REDEBUG_WAIT;
391  END_TRY( Param )
392  OR( DbgCmd )
393  TTEXT2( "c", "continue" );
395  OR( DbgCmd )
396  TTEXT2( "C", "Continue" );
398  OR( DbgCmd )
399  TTEXT2( "del", "delete" );
400  TRY( Param )
401  TTYPE( TK_INT );
402  n = atoi( token->text );
403  if ( breakPoints[n].actionName != NULL ) {
404  free( breakPoints[n].actionName );
405  if ( breakPoints[n].base != NULL ) {
406  free( breakPoints[n].base );
407  }
409  breakPoints[n].base = NULL;
410  snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i deleted\n", n );
411  }
412  else {
413  snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i has not been defined\n", n );
414  }
415  _writeXMsg( streamId, myhdr, mymsg );
416  cmd = REDEBUG_WAIT;
417  OR( Param )
418  _writeXMsg( streamId, myhdr, "Debugger command \'delete\' requires one argument.\n" );
419  cmd = REDEBUG_WAIT;
420  END_TRY( Param )
421  OR( DbgCmd )
422  TTEXT2( "p", "print" );
423  Node *n = parseTermRuleGen( e, 1, context );
424  if ( getNodeType( n ) == N_ERROR ) {
425  errMsgToString( context->errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) );
426  }
427  else {
428  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Printing " );
429  char * ptr = myhdr + strlen( myhdr );
430  i = HEADER_TYPE_LEN - 1 - strlen( myhdr );
431  termToString( &ptr, &i, 0, MIN_PREC, n, 0 );
432  snprintf( ptr, i, "\n" );
433  if ( env != NULL ) {
434  disableReDebugger( grdf );
435  res = computeNode( n, NULL, regionRegionCpEnv( env, r, ( RegionRegionCopyFuncType * ) regionRegionCpNode ), rei, 0, &errmsg, r );
436  enableReDebugger( grdf );
437  outStr = convertResToString( res );
438  snprintf( mymsg, MAX_NAME_LEN, "%s\n", outStr );
439  free( outStr );
440  if ( getNodeType( res ) == N_ERROR ) {
441  errMsgToString( &errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) );
442  }
443  }
444  else {
445  snprintf( mymsg, MAX_NAME_LEN, "Runtime environment: <empty>\n" );
446  }
447  }
448  _writeXMsg( streamId, myhdr, mymsg );
449 
450  cmd = REDEBUG_WAIT;
451  OR( DbgCmd )
452  TTEXT2( "d", "discontinue" );
453  cmd = REDEBUG_WAIT;
454  OR( DbgCmd )
455  snprintf( mymsg, MAX_NAME_LEN, "Unknown Action: %s", readmsg );
456  _writeXMsg( streamId, myhdr, mymsg );
457  cmd = REDEBUG_WAIT;
458  END_TRY( DbgCmd )
459  PARSER_END( DbgCmd )
460  freeRErrorContent( &errmsg );
461  region_free( r );
462  deletePointer( e );
463  free( context );
464  return cmd;
465 }
466 
467 int
469  Node *node, int curStat ) {
470 
471  char myhdr[HEADER_TYPE_LEN];
472  snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug:%s", param->actionName );
473 
474  if ( breakPointsInx > 0 && node != NULL ) {
475  for ( int i = 0; i < breakPointsInx; i++ ) {
476  if ( breakPoints[i].base != NULL && breakPoints[i].actionName != NULL &&
477  node->expr >= breakPoints[i].start && node->expr < breakPoints[i].finish &&
478  strcmp( node->base, breakPoints[i].base ) == 0 &&
479  strncmp( param->actionName, breakPoints[i].actionName, strlen( breakPoints[i].actionName ) ) == 0 ) {
480  char buf[MAX_NAME_LEN];
481  snprintf( buf, MAX_NAME_LEN, "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName );
482  char mymsg[MAX_NAME_LEN];
483  generateErrMsg( buf, node->expr, node->base, mymsg );
484  _writeXMsg( streamId, myhdr, mymsg );
485  snprintf( mymsg, MAX_NAME_LEN, "%s\n", param->actionName );
486  _writeXMsg( streamId, myhdr, mymsg );
487  return REDEBUG_WAIT;
488  }
489  }
490  }
491  return curStat;
492 }
493 
494 
495 /* char *stackStr;
496 char *stackStr2;
497 char *s; */
498 
499 
500 /*stackStr = (char *) malloc(strlen(hdr) + strlen(step) + 5);
501 sprintf(stackStr,"%s: %s\n", hdr, step);
502 
503 
504 i = reDebugStackFullPtr;
505 if (reDebugStackFull[i] != NULL) {
506  free(reDebugStackFull[i]);
507 }
508 reDebugStackFull[i] = stackStr;
509 reDebugStackFullPtr = (i + 1 ) % REDEBUG_STACK_SIZE_FULL;
510 i = reDebugStackFullPtr;
511 if (reDebugStackFull[i] != NULL) {
512  free(reDebugStackFull[i]);
513  reDebugStackFull[i] = NULL;
514 }*/
515 int
517 
518  int i;
519  i = reDebugStackCurrPtr - 1;
520  while ( i >= 0 && ( reDebugStackCurr[i].label != label || strcmp( reDebugStackCurr[i].step, step ) != 0 ) ) {
521  free( reDebugStackCurr[i].step );
523  reDebugStackCurr[i].label = -1;
524  i = i - 1;
525  }
527  return 0;
528 }
529 
530 int
532 
533  int i;
535  if ( i < REDEBUG_STACK_SIZE_CURR ) {
537  reDebugStackCurr[i].step = strdup( step );
538  reDebugStackCurrPtr = i + 1;
539  }
540  return 0;
541 }
542 
543 
544 int sendWaitXMsg( int streamId ) {
545  _writeXMsg( streamId, waitHdr, waitMsg );
546  return 0;
547 }
549  int i;
550  for ( i = 0 ; i < REDEBUG_STACK_SIZE_CURR; i++ ) {
551  if ( reDebugStackCurr[i].step != NULL ) {
552  free( reDebugStackCurr[i].step );
554  reDebugStackCurr[i].label = -1;
555  }
556  }
557  for ( i = 0 ; i < REDEBUG_STACK_SIZE_FULL; i++ ) {
558  if ( reDebugStackFull[i] != NULL ) {
559  free( reDebugStackFull[i] );
560  reDebugStackFull[i] = NULL;
561  }
562  }
565  GlobalREDebugFlag = -1;
566  return 0;
567 }
568 
570  switch ( label ) {
571  case EXEC_RULE_BEGIN:
572  snprintf( buf, n, "ExecRule:%s", param->actionName );
573  break;
574  case EXEC_RULE_END:
575  snprintf( buf, n, "ExecRule Done:%s", param->actionName );
576  break;
577  case EXEC_ACTION_BEGIN:
578  snprintf( buf, n, "ExecAction:%s", param->actionName );
579  break;
580  case EXEC_ACTION_END:
581  snprintf( buf, n, "ExecAction Done:%s", param->actionName );
582  break;
584  snprintf( buf, n, "ExecMicroSvrc:%s", param->actionName );
585  break;
587  snprintf( buf, n, "ExecMicroSvrc Done:%s", param->actionName );
588  break;
589  case GOT_RULE:
590  snprintf( buf, n, "GotRule:%s:%d", param->actionName, param->ruleIndex );
591  break;
592  case APPLY_RULE_BEGIN:
593  snprintf( buf, n, "ApplyRule:%s", param->actionName );
594  break;
595  case APPLY_RULE_END:
596  snprintf( buf, n, "ApplyRule Done:%s", param->actionName );
597  break;
599  snprintf( buf, n, "ApplyAllRules:%s", param->actionName );
600  break;
601  case APPLY_ALL_RULES_END:
602  snprintf( buf, n, "ApplyAllRules Done:%s", param->actionName );
603  break;
604  case EXEC_MY_RULE_BEGIN:
605  snprintf( buf, n, "ExecMyRule:%s", param->actionName );
606  break;
607  case EXEC_MY_RULE_END:
608  snprintf( buf, n, "ExecMyRule Done:%s", param->actionName );
609  break;
610  }
611 }
613  switch ( label ) {
614  case EXEC_RULE_BEGIN:
615  case EXEC_ACTION_BEGIN:
617  case APPLY_RULE_BEGIN:
619  case EXEC_MY_RULE_BEGIN:
620  return 1;
621  case EXEC_RULE_END:
622  case EXEC_ACTION_END:
624  case APPLY_RULE_END:
625  case APPLY_ALL_RULES_END:
626  case EXEC_MY_RULE_END:
627  return 2;
628  case GOT_RULE:
629  return 0;
630  }
631  return -1;
632 }
633 /*
634  * label type of rule engine event
635  * flag -4 log rei
636  * otherwise do not log rei
637  * action
638  *
639  */
640 int
642  /* do not log anything if logging is turned off */
643  if ( ruleEngineConfig.logging == 0 ) {
644  return 0;
645  }
646  int i, m, s, status, sleepT, j;
647  int processedBreakPoint = 0;
648  char hdr[HEADER_TYPE_LEN];
649  char *readhdr = NULL;
650  char *readmsg = NULL;
651  char *user = NULL;
652  char *addr = NULL;
653  static int mNum = 0;
654  static int sNum = 0;
655  static int curStat = 0;
656  static int reDebugStackPtr = -1;
657  static int reDebugStopAt = 1;
658  char condRead[MAX_NAME_LEN];
659  char myActionStr[10][MAX_NAME_LEN + 10];
660  int aNum = 0;
661  char seActionStr[10 * MAX_NAME_LEN + 100];
662  char timestamp[TIME_LEN];
663  rsComm_t *svrComm;
664  int waitCnt = 0;
665  sleepT = 1;
666  char buf[HEADER_TYPE_LEN - 1];
667 
668  svrComm = rei->rsComm;
669 
670  if ( svrComm == NULL ) {
671  rodsLog( LOG_ERROR, "Empty svrComm in REI structure for actionStr=%s\n",
672  param->actionName );
673  return 0;
674  }
675 
676  generateLogTimestamp( timestamp, TIME_LEN );
678  snprintf( hdr, HEADER_TYPE_LEN - 1, "iaudit:%s", timestamp );
679  condRead[0] = '\0';
680  /* rodsLog (LOG_NOTICE,"PPP:%s\n",hdr); */
681  snprintf( seActionStr, MAX_NAME_LEN + 10, "%s", buf );
682  if ( GlobalREAuditFlag > 0 ) {
683  if ( flag == -4 ) {
684  if ( rei->uoic != NULL && strlen( rei->uoic->userName ) > 0 && strlen( rei->uoic->rodsZone ) > 0 ) {
685  snprintf( myActionStr[aNum], MAX_NAME_LEN + 10 , " USER:%s@%s", rei->uoic->userName, rei->uoic->rodsZone );
686  aNum++;
687  }
688  if ( rei->doi != NULL && strlen( rei->doi->objPath ) > 0 ) {
689  snprintf( myActionStr[aNum], MAX_NAME_LEN + 10 , " DATA:%s", rei->doi->objPath );
690  aNum++;
691  }
692  if ( rei->doi != NULL && strlen( rei->doi->filePath ) > 0 ) {
693  snprintf( myActionStr[aNum], MAX_NAME_LEN + 10 , " FILE:%s", rei->doi->filePath );
694  aNum++;
695  }
696  if ( rei->doinp != NULL && strlen( rei->doinp->objPath ) > 0 ) {
697  snprintf( myActionStr[aNum], MAX_NAME_LEN + 10 , " DATAIN:%s", rei->doinp->objPath );
698  aNum++;
699  }
700  if ( rei->doi != NULL && strlen( rei->doi->rescName ) > 0 ) {
701  snprintf( myActionStr[aNum], MAX_NAME_LEN + 10 , " RESC:%s", rei->doi->rescName );
702  aNum++;
703  }
704  if ( rei->coi != NULL && strlen( rei->coi->collName ) > 0 ) {
705  snprintf( myActionStr[aNum], MAX_NAME_LEN + 10 , " COLL:%s", rei->coi->collName );
706  aNum++;
707  }
708  for ( j = 0; j < aNum; j++ ) {
709  strncat( seActionStr, myActionStr[j], 10 * MAX_NAME_LEN + 100 - strlen( seActionStr ) );
710  }
711  }
712  }
713 
714  /* Write audit trail */
715  if ( GlobalREAuditFlag == 3 ) {
716  i = _writeXMsg( GlobalREAuditFlag, hdr, seActionStr );
717  if ( i < 0 ) {
718  irods::log( ERROR( i, "_writeXMsg failed." ) );
719  }
720  }
721 
722 
723  /* Send current position for debugging */
724  if ( GlobalREDebugFlag > 5 ) {
725  /* modify stack */
726  int pcType = reDebugPCType( label );
727  if ( ( pcType & 1 ) != 0 ) {
728  pushReStack( label, param->actionName );
729  }
730  else if ( ( pcType & 2 ) != 0 ) {
731  popReStack( label, param->actionName );
732  }
733 
734  if ( curStat == REDEBUG_CONTINUE && reDebugStackCurrPtr <= reDebugStackPtr && ( reDebugPCType( label ) & reDebugStopAt ) != 0 ) {
735  curStat = REDEBUG_WAIT;
736  }
737  if ( curStat != REDEBUG_CONTINUE ) {
738  snprintf( hdr, HEADER_TYPE_LEN - 1, "idbug:%s", param->actionName );
739  i = _writeXMsg( GlobalREDebugFlag, hdr, buf );
740  if ( i < 0 ) {
741  irods::log( ERROR( i, "_writeXMsg failed." ) );
742  }
743  }
744 
745  while ( GlobalREDebugFlag > 5 ) {
746  s = sNum;
747  m = mNum;
748  /* what should be the condition */
749  sprintf( condRead, "(*XSEQNUM >= %d) && (*XADDR != \"%s:%i\") && (*XUSER == \"%s@%s\") && ((*XHDR == \"CMSG:ALL\") %%%% (*XHDR == \"CMSG:%s:%i\"))",
751 
752  /*
753  sprintf(condRead, "(*XSEQNUM >= %d) && ((*XHDR == CMSG:ALL) %%%% (*XHDR == CMSG:%s:%i))",
754  s, myHostName, getpid());
755  */
756  status = _readXMsg( GlobalREDebugFlag, condRead, &m, &s, &readhdr, &readmsg, &user, &addr );
758  cleanUpDebug();
759  return 0;
760  }
761  if ( status >= 0 ) {
762  rodsLog( LOG_NOTICE, "Getting XMsg:%i:%s:%s\n", s, readhdr, readmsg );
763  curStat = processXMsg( GlobalREDebugFlag, readmsg,
764  param, node, env, rei );
765  if ( readhdr != NULL ) {
766  free( readhdr );
767  }
768  if ( readmsg != NULL ) {
769  free( readmsg );
770  }
771  if ( user != NULL ) {
772  free( user );
773  }
774  if ( addr != NULL ) {
775  free( addr );
776  }
777 
778  mNum = m;
779  sNum = s + 1;
780  if ( curStat == REDEBUG_WAIT ) {
782  }
783  else if ( curStat == REDEBUG_STEP_OVER ) {
784  reDebugStackPtr = reDebugStackCurrPtr;
785  reDebugStopAt = 1;
786  curStat = REDEBUG_CONTINUE;
787  break;
788  }
789  else if ( curStat == REDEBUG_STEP_OUT ) {
790  reDebugStackPtr = reDebugStackCurrPtr - 1;
791  reDebugStopAt = 2;
792  curStat = REDEBUG_CONTINUE;
793  break;
794  }
795  else if ( curStat == REDEBUG_STEP_CONTINUE ) {
796  reDebugStackPtr = -1;
797  curStat = REDEBUG_CONTINUE;
798  break;
799  }
800  else if ( curStat == REDEBUG_NEXT ) {
801  break;
802  }
803  }
804  else {
805  if ( !( curStat == REDEBUG_CONTINUE || curStat == REDEBUG_CONTINUE_VERBOSE ) ) {
806 
807  /*#if _POSIX_C_SOURCE >= 199309L
808  struct timespec time = {0, 100000000}, rem;
809  nanosleep(&time, &rem);
810  waitCnt+=10;
811  #else*/
812  sleep( sleepT );
813  waitCnt += 100;
814  /*#endif*/
815  if ( waitCnt > 6000 ) {
817  waitCnt = 0;
818  }
819  }
820  }
821  if ( curStat == REDEBUG_CONTINUE || curStat == REDEBUG_CONTINUE_VERBOSE ) {
822  if ( processedBreakPoint == 1 ) {
823  break;
824  }
826  param, node, curStat );
827  processedBreakPoint = 1;
828  if ( curStat == REDEBUG_WAIT ) {
830  continue;
831  }
832  else {
833  break;
834  }
835  }
836  }
837  }
838 
839 
840  return 0;
841 }
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
DataObjInp::objPath
char objPath[(1024+64)]
Definition: dataObjInpOut.h:66
reDebugPCType
int reDebugPCType(RuleEngineEvent label)
Definition: nre.reHelpers1.cpp:612
ABORT
#define ABORT(x)
Definition: parser.hpp:268
NULL
#define NULL
Definition: rodsDef.h:70
rsComm_t
Definition: rcConnect.h:145
parser.hpp
Breakpoint::start
rodsLong_t start
Definition: nre.reHelpers1.cpp:22
convertResToString
char * convertResToString(Res *res0)
Definition: conversion.cpp:556
rError_t::len
int len
Definition: rodsError.h:25
GlobalREAuditFlag
int GlobalREAuditFlag
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:59
PARSER_END
#define PARSER_END(l)
Definition: parser.hpp:145
breakPoints
struct Breakpoint breakPoints[100]
GlobalREDebugFlag
int GlobalREDebugFlag
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:58
reHelpers1.hpp
END_TRY
#define END_TRY(l)
Definition: parser.hpp:264
computeNode
Res * computeNode(Node *expr, Node *reco, Env *env, ruleExecInfo_t *rei, int reiSaveFlag, rError_t *errmsg, Region *r)
Definition: rules.cpp:458
myHostName
char myHostName[(1024+64)]
Definition: nre.reHelpers1.cpp:45
waitHdr
char waitHdr[128]
Definition: nre.reHelpers1.cpp:46
REDEBUG_CONTINUE
#define REDEBUG_CONTINUE
Definition: reDefines.h:40
index.hpp
EXEC_MICRO_SERVICE_BEGIN
@ EXEC_MICRO_SERVICE_BEGIN
Definition: restructs.hpp:304
myPID
int myPID
Definition: nre.reHelpers1.cpp:48
getLineRange
int getLineRange(Pointer *p, int line, rodsLong_t range[2])
Definition: parser.cpp:2600
processXMsg
int processXMsg(int streamId, char *readmsg, RuleEngineEventParam *param, Node *node, Env *env, ruleExecInfo_t *rei)
Definition: nre.reHelpers1.cpp:113
REDEBUG_WAIT
#define REDEBUG_WAIT
Definition: reDefines.h:43
userInfo_t::userName
char userName[64]
Definition: rodsUser.h:66
HEADER_TYPE_LEN
#define HEADER_TYPE_LEN
Definition: rodsDef.h:53
env::previous
Env * previous
Definition: restructs.hpp:228
enableReDebugger
void enableReDebugger(int grdf[2])
Definition: nre.reHelpers1.cpp:40
getNodeType
#define getNodeType(x)
Definition: restructs.hpp:69
EXEC_MY_RULE_END
@ EXEC_MY_RULE_END
Definition: restructs.hpp:314
bucket
Definition: irods_hashtable.h:11
env
Definition: restructs.hpp:226
RuleExecInfo::coi
collInfo_t * coi
Definition: irods_re_structs.hpp:32
EXEC_ACTION_END
@ EXEC_ACTION_END
Definition: restructs.hpp:306
configuration.hpp
typeToString
char * typeToString(ExprType *type, Hashtable *var_types, char *buf, int bufsize)
Definition: utils.cpp:522
rcMisc.h
pid_age.p
p
Definition: pid_age.py:13
reDebug
int reDebug(RuleEngineEvent label, int flag, RuleEngineEventParam *param, Node *node, Env *env, ruleExecInfo_t *rei)
Definition: nre.reHelpers1.cpp:641
getRuleDesc
RuleDesc * getRuleDesc(int ri)
Definition: rules.cpp:595
ParserContext
Definition: parser.hpp:50
token::text
char text[1023+1]
Definition: restructs.hpp:295
EXEC_MY_RULE_BEGIN
@ EXEC_MY_RULE_BEGIN
Definition: restructs.hpp:313
filesystem.hpp
make_region
Region * make_region(size_t is, jmp_buf *label)
Definition: region.cpp:85
TTEXT2
#define TTEXT2(x, y)
Definition: parser.hpp:175
node
Definition: restructs.hpp:244
RuleExecInfo::doi
dataObjInfo_t * doi
Definition: irods_re_structs.hpp:28
getRuleBasePath
char * getRuleBasePath(const char *ruleBaseName, char rulesFileName[(1024+64)])
Definition: filesystem.cpp:14
waitMsg
char waitMsg[(1024+64)]
Definition: nre.reHelpers1.cpp:47
RuleExecInfo::doinp
dataObjInp_t * doinp
Definition: irods_re_structs.hpp:27
coreRuleVarDef
rulevardef_t coreRuleVarDef
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:48
ruleToString
void ruleToString(char *buf, int size, RuleDesc *rd)
Definition: parser.cpp:2244
DataObjInfo::filePath
char filePath[(1024+64)]
Definition: objInfo.h:137
Breakpoint::row
int row
Definition: nre.reHelpers1.cpp:20
breakPointsInx
int breakPointsInx
Definition: nre.reHelpers1.cpp:26
popReStack
int popReStack(RuleEngineEvent label, char *step)
Definition: nre.reHelpers1.cpp:516
token
Definition: restructs.hpp:293
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
pointer
Definition: parser.hpp:34
reDebugStackFullPtr
int reDebugStackFullPtr
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:62
TK_INT
@ TK_INT
Definition: restructs.hpp:112
ruleEngineEventParam::actionName
char * actionName
Definition: restructs.hpp:319
irods.pyparsing.range
range
Definition: pyparsing.py:111
newParserContext
ParserContext * newParserContext(rError_t *errmsg, Region *r)
Definition: parser.cpp:70
Breakpoint::finish
rodsLong_t finish
Definition: nre.reHelpers1.cpp:23
newPointer2
Pointer * newPointer2(char *buf)
Definition: parser.cpp:2435
reDebugStack::label
int label
Definition: reGlobalsExtern.hpp:88
_readXMsg
int _readXMsg(int streamId, char *contRead, int *msgNum, int *seqNum, char **hdr, char **msg, char **user, char **addr)
Definition: xmsgMS.cpp:532
newPointer
Pointer * newPointer(FILE *buf, const char *ruleBaseName)
Definition: parser.cpp:2430
errMsgToString
char * errMsgToString(rError_t *errmsg, char *buf, int buflen)
Definition: utils.cpp:778
RuleExecInfo::rsComm
rsComm_t * rsComm
Definition: irods_re_structs.hpp:22
Breakpoint::actionName
char * actionName
Definition: nre.reHelpers1.cpp:17
generate_iadmin_commands_for_41_to_42_upgrade.cmd
list cmd
Definition: generate_iadmin_commands_for_41_to_42_upgrade.py:19
TTYPE
#define TTYPE(x)
Definition: parser.hpp:192
TTEXT
#define TTEXT(x)
Definition: parser.hpp:168
REDEBUG_NEXT
#define REDEBUG_NEXT
Definition: reDefines.h:39
APPLY_ALL_RULES_END
@ APPLY_ALL_RULES_END
Definition: restructs.hpp:312
reDebugStackCurrPtr
int reDebugStackCurrPtr
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:63
OR
#define OR(l)
Definition: parser.hpp:255
hashtable::buckets
struct bucket ** buckets
Definition: irods_hashtable.h:17
EXEC_MICRO_SERVICE_END
@ EXEC_MICRO_SERVICE_END
Definition: restructs.hpp:307
rError_t
Definition: rodsError.h:24
processBreakPoint
int processBreakPoint(int streamId, RuleEngineEventParam *param, Node *node, int curStat)
Definition: nre.reHelpers1.cpp:468
reDebugStackCurr
struct reDebugStack reDebugStackCurr[1000]
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:61
Breakpoint
Definition: nre.reHelpers1.cpp:16
parseTermRuleGen
Node * parseTermRuleGen(Pointer *expr, int rulegn, ParserContext *pc)
Definition: parser.cpp:3385
TK_TEXT
@ TK_TEXT
Definition: restructs.hpp:114
termToString
void termToString(char **p, int *s, int indent, int prec, Node *n, int quote)
Definition: parser.cpp:1889
REDEBUG_STACK_SIZE_FULL
#define REDEBUG_STACK_SIZE_FULL
Definition: reDefines.h:51
_writeXMsg
int _writeXMsg(int streamId, char *hdr, char *msg)
Definition: xmsgMS.cpp:479
REDEBUG_STACK_SIZE_CURR
#define REDEBUG_STACK_SIZE_CURR
Definition: reDefines.h:52
TIME_LEN
#define TIME_LEN
Definition: rodsDef.h:54
cleanUpDebug
int cleanUpDebug()
Definition: nre.reHelpers1.cpp:548
syncTokenQueue
void syncTokenQueue(Pointer *e, ParserContext *context)
Definition: parser.cpp:355
node::expr
rodsLong_t expr
Definition: restructs.hpp:253
NO_MORE_RULES_ERR
@ NO_MORE_RULES_ERR
Definition: rodsErrorTable.h:594
PARSER_BEGIN
#define PARSER_BEGIN(l)
Definition: parser.hpp:124
Cache::logging
int logging
Definition: configuration.hpp:67
MAX_NAME_LEN
#define MAX_NAME_LEN
Definition: rodsDef.h:61
terminate_irods_processes.e
e
Definition: terminate_irods_processes.py:19
reDebugStackFull
char * reDebugStackFull[2000]
Definition: libirods_rule_engine_plugin-irods_rule_language.cpp:60
EXEC_RULE_BEGIN
@ EXEC_RULE_BEGIN
Definition: restructs.hpp:302
insertIntoHashTable
int insertIntoHashTable(Hashtable *h, const char *key, const void *value)
Definition: hashtable.cpp:99
ruleIndexListNode
Definition: restructs.hpp:213
Breakpoint::pending
int pending
Definition: nre.reHelpers1.cpp:19
SYS_UNMATCHED_XMSG_TICKET
@ SYS_UNMATCHED_XMSG_TICKET
Definition: rodsErrorTable.h:129
NEXT_TOKEN_BASIC
#define NEXT_TOKEN_BASIC
Definition: parser.hpp:72
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
userInfo_t::rodsZone
char rodsZone[64]
Definition: rodsUser.h:67
Breakpoint::line
int line
Definition: nre.reHelpers1.cpp:21
ruleEngineEventParam::ruleIndex
int ruleIndex
Definition: restructs.hpp:318
irods::log
void log(const error &)
Definition: irods_log.cpp:13
RegionRegionCopyFuncType
const void *() RegionRegionCopyFuncType(const void *, Region *)
Definition: region.to.region.proto.hpp:7
LOG_NOTICE
#define LOG_NOTICE
Definition: rodsLog.h:33
lookupFromHashTable
const void * lookupFromHashTable(Hashtable *h, const char *key)
Definition: hashtable.cpp:222
node::base
char * base
Definition: restructs.hpp:255
rsComm_t::clientUser
userInfo_t clientUser
Definition: rcConnect.h:153
reDebugStack::step
char * step
Definition: reGlobalsExtern.hpp:87
APPLY_ALL_RULES_BEGIN
@ APPLY_ALL_RULES_BEGIN
Definition: restructs.hpp:311
ERROR
#define ERROR(code_, message_)
Definition: irods_error.hpp:117
region
Definition: region.h:45
int
typedef int((*funcPtr)())
RuleDesc
Definition: restructs.hpp:272
rulevardef_t::MaxNumOfDVars
int MaxNumOfDVars
Definition: reGlobalsExtern.hpp:103
disableReDebugger
void disableReDebugger(int grdf[2])
Definition: nre.reHelpers1.cpp:32
MIN_PREC
#define MIN_PREC
Definition: reconstants.hpp:32
findNextRule2
int findNextRule2(const char *action, int i, RuleIndexListNode **node)
Definition: index.cpp:322
RuleExecInfo::uoic
userInfo_t * uoic
Definition: irods_re_structs.hpp:30
REDEBUG_STEP_OVER
#define REDEBUG_STEP_OVER
Definition: reDefines.h:45
REDEBUG_STEP_OUT
#define REDEBUG_STEP_OUT
Definition: reDefines.h:47
MAX_RULE_LEN
#define MAX_RULE_LEN
Definition: reconstants.hpp:9
DataObjInfo::rescName
char rescName[64]
Definition: objInfo.h:131
REDEBUG_CONTINUE_VERBOSE
#define REDEBUG_CONTINUE_VERBOSE
Definition: reDefines.h:44
REDEBUG_STEP_CONTINUE
#define REDEBUG_STEP_CONTINUE
Definition: reDefines.h:48
skipWhitespace
void skipWhitespace(Pointer *expr)
Definition: parser.cpp:115
update_schema_ids_for_cmake.file
file
Definition: update_schema_ids_for_cmake.py:21
irods.six.b
def b(s)
Definition: six.py:606
Breakpoint::base
char * base
Definition: nre.reHelpers1.cpp:18
RuleDesc::node
Node * node
Definition: restructs.hpp:275
RuleExecInfo
Definition: irods_re_structs.hpp:18
deletePointer
void deletePointer(Pointer *buf)
Definition: parser.cpp:2441
APPLY_RULE_END
@ APPLY_RULE_END
Definition: restructs.hpp:310
N_ERROR
@ N_ERROR
Definition: restructs.hpp:111
generateErrMsg
char * generateErrMsg(char *msg, long errloc, char *ruleBaseName, char errbuf[1024])
Definition: parser.cpp:3555
env::current
Hashtable * current
Definition: restructs.hpp:227
newHashTable
Hashtable * newHashTable(int size)
Definition: hashtable.cpp:46
region_free
void region_free(Region *r)
Definition: region.cpp:146
ruleEngineEventParam
Definition: restructs.hpp:317
RULES_FILE_READ_ERROR
@ RULES_FILE_READ_ERROR
Definition: rodsErrorTable.h:596
GOT_RULE
@ GOT_RULE
Definition: restructs.hpp:308
hashtable::size
int size
Definition: irods_hashtable.h:18
ruleEngineConfig
Cache ruleEngineConfig
Definition: configuration.cpp:68
printRuleEngineEventLabel
void printRuleEngineEventLabel(char buf[], size_t n, RuleEngineEvent label, RuleEngineEventParam *param)
Definition: nre.reHelpers1.cpp:569
hashtable
Definition: irods_hashtable.h:16
DataObjInfo::objPath
char objPath[(1024+64)]
Definition: objInfo.h:130
EXEC_RULE_END
@ EXEC_RULE_END
Definition: restructs.hpp:305
OPTIONAL_BEGIN
#define OPTIONAL_BEGIN(l)
Definition: parser.hpp:274
sendWaitXMsg
int sendWaitXMsg(int streamId)
Definition: nre.reHelpers1.cpp:544
label
Definition: restructs.hpp:288
initializeReDebug
int initializeReDebug(rsComm_t *svrComm)
Definition: nre.reHelpers1.cpp:50
rulevardef_t::varName
char * varName[2048]
Definition: reGlobalsExtern.hpp:104
rsComm_t::clientAddr
char clientAddr[64]
Definition: rcConnect.h:151
generateLogTimestamp
void generateLogTimestamp(char *ts, int tsLen)
Definition: rodsLog.cpp:514
lookAhead
int lookAhead(Pointer *p, unsigned int n)
Definition: parser.cpp:2651
OPTIONAL_END
#define OPTIONAL_END(l)
Definition: parser.hpp:278
NAME_LEN
#define NAME_LEN
Definition: rodsDef.h:55
rError_t::errMsg
rErrMsg_t ** errMsg
Definition: rodsError.h:26
reFuncDefs.hpp
TRY
#define TRY(l)
Definition: parser.hpp:251
buf
static char buf[64+50+1]
Definition: rsAuthRequest.cpp:21
deleteHashTable
void deleteHashTable(Hashtable *h, void(*f)(const void *))
Definition: hashtable.cpp:260
pushReStack
int pushReStack(RuleEngineEvent label, char *step)
Definition: nre.reHelpers1.cpp:531
APPLY_RULE_BEGIN
@ APPLY_RULE_BEGIN
Definition: restructs.hpp:309
CollInfo::collName
char collName[(1024+64)]
Definition: objInfo.h:179
rsComm_t::localAddr
struct sockaddr_in localAddr
Definition: rcConnect.h:149
irods.pyparsing.line
def line(loc, strg)
Definition: pyparsing.py:728
irods_log.hpp
freeRErrorContent
int freeRErrorContent(rError_t *myError)
Definition: rcMisc.cpp:182
rodsLong_t
long long rodsLong_t
Definition: rodsType.h:32
RuleEngineEvent
enum ruleEngineEvent RuleEngineEvent
EXEC_ACTION_BEGIN
@ EXEC_ACTION_BEGIN
Definition: restructs.hpp:303
ParserContext::errmsg
rError_t * errmsg
Definition: parser.hpp:62