00001
00002
00003
00004 #include "reHelpers1.h"
00005
00006 #include "index.h"
00007 #include "parser.h"
00008 #include "filesystem.h"
00009 #include "configuration.h"
00010
00011 struct Breakpoint {
00012 char *actionName;
00013 char *base;
00014 int pending;
00015 int row;
00016 int line;
00017 rodsLong_t start;
00018 rodsLong_t finish;
00019 } breakPoints[100];
00020
00021 int breakPointsInx = 0;
00022
00023 void disableReDebugger(int grdf[2]) {
00024 grdf[0] = GlobalREAuditFlag;
00025 grdf[1] = GlobalREDebugFlag;
00026 GlobalREAuditFlag = 0;
00027 GlobalREDebugFlag = 0;
00028
00029 }
00030
00031 void enableReDebugger(int grdf[2]) {
00032 GlobalREAuditFlag = grdf[0];
00033 GlobalREDebugFlag = grdf[1];
00034
00035 }
00036 char myHostName[MAX_NAME_LEN];
00037 char waitHdr[HEADER_TYPE_LEN];
00038 char waitMsg[MAX_NAME_LEN];
00039 int myPID;
00040
00041 int initializeReDebug(rsComm_t *svrComm, int flag)
00042 {
00043 char condRead[NAME_LEN];
00044 int i, s,m, status;
00045 char *readhdr = NULL;
00046 char *readmsg = NULL;
00047 char *user = NULL;
00048 char *addr = NULL;
00049
00050 if (svrComm == NULL)
00051 return(0);
00052 if ( GlobalREDebugFlag != 4 )
00053 return(0);
00054
00055 s=0;
00056 m=0;
00057 myPID = (int) getpid();
00058 myHostName[0] = '\0';
00059 gethostname (myHostName, MAX_NAME_LEN);
00060 sprintf(condRead, "(*XUSER == \"%s@%s\") && (*XHDR == \"STARTDEBUG\")",
00061 svrComm->clientUser.userName, svrComm->clientUser.rodsZone);
00062 status = _readXMsg(GlobalREDebugFlag, condRead, &m, &s, &readhdr, &readmsg, &user, &addr);
00063 if (status >= 0) {
00064 if ( (readmsg != NULL) && strlen(readmsg) > 0) {
00065 GlobalREDebugFlag = atoi(readmsg);
00066 }
00067 if (readhdr != NULL)
00068 free(readhdr);
00069 if (readmsg != NULL)
00070 free(readmsg);
00071 if (user != NULL)
00072 free(user);
00073 if (addr != NULL)
00074 free(addr);
00075
00076 for (i = 0; i < REDEBUG_STACK_SIZE_FULL; i++)
00077 reDebugStackFull[i] = NULL;
00078 for (i = 0; i < REDEBUG_STACK_SIZE_CURR; i++) {
00079 reDebugStackCurr[i][0] = NULL;
00080 reDebugStackCurr[i][1] = NULL;
00081 reDebugStackCurr[i][2] = NULL;
00082 }
00083 memset(breakPoints, 0, sizeof(struct Breakpoint) * 100);
00084
00085 reDebugStackFullPtr = 0;
00086 reDebugStackCurrPtr = 0;
00087 snprintf(waitHdr,HEADER_TYPE_LEN - 1, "idbug:");
00088
00089 rodsLog (LOG_NOTICE,"reDebugInitialization: Got Debug StreamId:%i\n",GlobalREDebugFlag);
00090 snprintf(waitMsg, MAX_NAME_LEN, "PROCESS BEGIN at %s:%i. Client connected from %s at port %i\n",
00091 myHostName, myPID, svrComm->clientAddr,ntohs(svrComm->localAddr.sin_port));
00092 _writeXMsg(GlobalREDebugFlag, "idbug", waitMsg);
00093 snprintf(waitMsg, MAX_NAME_LEN, "%s:%i is waiting\n", myHostName, myPID); }
00094 return(0);
00095 }
00096
00097
00098 int processXMsg(int streamId, int *msgNum, int *seqNum,
00099 char * readhdr, char *readmsg,
00100 char *callLabel, Node *node,
00101 Env *env, int curStat, ruleExecInfo_t *rei)
00102 {
00103
00104 char myhdr[HEADER_TYPE_LEN];
00105 char mymsg[MAX_NAME_LEN];
00106 char *outStr = NULL;
00107 char *ptr;
00108 int i,n;
00109 int iLevel, wCnt;
00110 int ruleInx = 0;
00111 Region *r;
00112 Res *res;
00113 rError_t errmsg;
00114 errmsg.len = 0;
00115 errmsg.errMsg = NULL;
00116 r = make_region(0, NULL);
00117 ParserContext *context = newParserContext(&errmsg, r);
00118 Pointer *e = newPointer2(readmsg);
00119 int rulegen = 1;
00120 int found;
00121 int grdf[2];
00122 int cmd;
00123 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug:%s",callLabel);
00124 PARSER_BEGIN(DbgCmd)
00125 TRY(DbgCmd)
00126 TTEXT2("n", "next");
00127 cmd = REDEBUG_STEP_OVER;
00128 OR(DbgCmd)
00129 TTEXT2("s", "step");
00130 cmd = REDEBUG_NEXT;
00131 OR(DbgCmd)
00132 TTEXT2("f", "finish");
00133 cmd = REDEBUG_STEP_OUT;
00134 OR(DbgCmd)
00135 TTEXT2("b", "break");
00136 TRY(Param)
00137 TTYPE(TK_TEXT);
00138 char *fn = strdup(token->text);
00139 int breakPointsInx2;
00140 for(breakPointsInx2=0;breakPointsInx2<100;breakPointsInx2++) {
00141 if(breakPoints[breakPointsInx2].actionName == NULL) {
00142 break;
00143 }
00144 }
00145 if(breakPointsInx2 == 100) {
00146 _writeXMsg(streamId, myhdr, "Maximum breakpoint count reached. Breakpoint not set.\n");
00147 cmd = REDEBUG_WAIT;
00148 } else {
00149 breakPoints[breakPointsInx2].actionName = fn;
00150 ptr = NULL;
00151 TRY(loc)
00152 TTYPE(TK_TEXT);
00153 ptr = (char *) malloc(sizeof(token->text) + 2);
00154 ptr[0] = 'f';
00155 strcpy(ptr+1, token->text);
00156 TTEXT(":");
00157 TTYPE(TK_INT);
00158 breakPoints[breakPointsInx2].base = ptr;
00159 breakPoints[breakPointsInx2].line = atoi(token->text);
00160 rodsLong_t range[2];
00161 char rulesFileName[MAX_NAME_LEN];
00162 getRuleBasePath(ptr, rulesFileName);
00163
00164 FILE *file;
00165
00166 file = fopen(rulesFileName, "r");
00167 if (file == NULL) {
00168 return(RULES_FILE_READ_ERROR);
00169 }
00170 Pointer *p = newPointer(file, ptr);
00171
00172
00173 if(getLineRange(p, breakPoints[breakPointsInx2].line, range) == 0) {
00174 breakPoints[breakPointsInx2].start = range[0];
00175 breakPoints[breakPointsInx2].finish = range[1];
00176 } else {
00177 breakPoints[breakPointsInx2].actionName = NULL;
00178 }
00179 deletePointer(p);
00180 OR(loc)
00181 TTYPE(TK_INT);
00182 if(node!=NULL) {
00183 breakPoints[breakPointsInx2].base = strdup(node->base);
00184 breakPoints[breakPointsInx2].line = atoi(token->text);
00185 rodsLong_t range[2];
00186 Pointer *p = newPointer2(breakPoints[breakPointsInx2].base);
00187 if(getLineRange(p, breakPoints[breakPointsInx2].line, range) == 0) {
00188 breakPoints[breakPointsInx2].start = range[0];
00189 breakPoints[breakPointsInx2].finish = range[1];
00190 } else {
00191 breakPoints[breakPointsInx2].actionName = NULL;
00192 }
00193 deletePointer(p);
00194 } else {
00195 breakPoints[breakPointsInx2].actionName = NULL;
00196 }
00197 OR(loc)
00198
00199 END_TRY(loc)
00200
00201 if(ptr!=NULL && breakPoints[breakPointsInx2].base == NULL) {
00202 free(ptr);
00203 }
00204 if(breakPoints[breakPointsInx2].actionName != NULL)
00205 snprintf(mymsg, MAX_NAME_LEN, "Breakpoint %i set at %s\n", breakPointsInx2,
00206 breakPoints[breakPointsInx2].actionName);
00207 else
00208 snprintf(mymsg, MAX_NAME_LEN, "Cannot set breakpoint, source not available\n");
00209 _writeXMsg(streamId, myhdr, mymsg);
00210 if(breakPointsInx <= breakPointsInx2) {
00211 breakPointsInx = breakPointsInx2 + 1;
00212 }
00213 cmd = REDEBUG_WAIT;
00214 }
00215 OR(Param)
00216 NEXT_TOKEN_BASIC;
00217 _writeXMsg(streamId, myhdr, "Unknown parameter type.\n");
00218 cmd = REDEBUG_WAIT;
00219 OR(Param)
00220 _writeXMsg(streamId, myhdr, "Debugger command \'break\' requires at least one argument.\n");
00221 cmd = REDEBUG_WAIT;
00222 END_TRY(Param)
00223
00224 OR(DbgCmd)
00225 TTEXT2("w", "where");
00226 wCnt = 20;
00227 OPTIONAL_BEGIN(Param)
00228 TTYPE(TK_INT);
00229 wCnt = atoi(token->text);
00230 OPTIONAL_END(Param)
00231 iLevel = 0;
00232
00233 i = reDebugStackCurrPtr - 1;
00234 while (i >=0 && wCnt > 0 && reDebugStackCurr[i][0] != NULL) {
00235 if (strstr(reDebugStackCurr[i][0] , "ExecAction") != NULL || strstr(reDebugStackCurr[i][0] , "ExecMicroSrvc") != NULL || strstr(reDebugStackCurr[i][0] , "ExecRule") != NULL) {
00236 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i",iLevel);
00237 char *msg = (char *) malloc(strlen(reDebugStackCurr[i][0]) + strlen(reDebugStackCurr[i][1]) + strlen(reDebugStackCurr[i][2])+4);
00238 sprintf(msg, "%s:%s: %s", reDebugStackCurr[i][0], reDebugStackCurr[i][1], reDebugStackCurr[i][2]);
00239 _writeXMsg(streamId, myhdr, msg);
00240 free(msg);
00241 if (strstr(reDebugStackCurr[i][0] , "ExecAction") != NULL)
00242 iLevel++;
00243 wCnt--;
00244 }
00245 i--;
00246 }
00247 OR(DbgCmd)
00248 TTEXT2("l", "list");
00249 TRY(Param)
00250 TTEXT2("r", "rule");
00251 TRY(ParamParam)
00252 TTYPE(TK_TEXT);
00253 ptr = strdup(token->text);
00254
00255 mymsg[0] = '\n';
00256 mymsg[1] = '\0';
00257 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",ptr);
00258 RuleIndexListNode *node;
00259 found = 0;
00260 while (findNextRule2 (ptr, ruleInx, &node) != NO_MORE_RULES_ERR) {
00261 found = 1;
00262 if(node->secondaryIndex) {
00263 n = node->condIndex->valIndex->len;
00264 int i;
00265 for(i=0;i<n;i++) {
00266 Bucket *b = node->condIndex->valIndex->buckets[i];
00267 while(b!=NULL) {
00268 RuleDesc *rd = getRuleDesc(*(int *)b->value);
00269 char buf[MAX_RULE_LEN];
00270 ruleToString(buf, MAX_RULE_LEN, rd);
00271 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);
00272 b = b->next;
00273 }
00274 }
00275 } else {
00276 RuleDesc *rd = getRuleDesc(node->ruleIndex);
00277 char buf[MAX_RULE_LEN];
00278 ruleToString(buf, MAX_RULE_LEN, rd);
00279 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);
00280 }
00281 ruleInx ++;
00282 }
00283 if (!found) {
00284 snprintf(mymsg, MAX_NAME_LEN,"Rule %s not found\n", ptr);
00285 }
00286 _writeXMsg(streamId, myhdr, mymsg);
00287 cmd = REDEBUG_WAIT;
00288 OR(ParamParam)
00289 _writeXMsg(streamId, myhdr, "Debugger command \'list rule\' requires one argument.\n");
00290 cmd = REDEBUG_WAIT;
00291 END_TRY(ParamParam)
00292 OR(Param)
00293 TTEXT2("b", "breakpoints");
00294 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",token->text);
00295 mymsg[0] = '\n';
00296 mymsg[1] = '\0';
00297 for(i=0;i<breakPointsInx;i++) {
00298 if(breakPoints[i].actionName!=NULL) {
00299 if(breakPoints[i].base!=NULL) {
00300 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);
00301 } else {
00302 snprintf(mymsg + strlen(mymsg),MAX_NAME_LEN - strlen(mymsg), "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName);
00303 }
00304 }
00305 }
00306 _writeXMsg(streamId, myhdr, mymsg);
00307 cmd = REDEBUG_WAIT;
00308 OR(Param)
00309 TTEXT("*");
00310 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",token->text);
00311 Env *cenv = env;
00312 mymsg[0] = '\n';
00313 mymsg[1] = '\0';
00314 found = 0;
00315 while(cenv!=NULL) {
00316 n = cenv->current->size;
00317 for(i = 0;i<n;i++) {
00318 Bucket *b = cenv->current->buckets[i];
00319 while(b!=NULL) {
00320 if(b->key[0] == '*') {
00321 found = 1;
00322 char typeString[128];
00323 typeToString(((Res *)b->value)->exprType, NULL, typeString, 128);
00324 snprintf(mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg), "%s of type %s\n", b->key, typeString);
00325 }
00326 b = b->next;
00327 }
00328 }
00329 cenv = cenv->previous;
00330 }
00331 if (!found) {
00332 snprintf(mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg), "<empty>\n");
00333 }
00334 _writeXMsg(streamId, myhdr, mymsg);
00335 cmd = REDEBUG_WAIT;
00336 OR(Param)
00337 syncTokenQueue(e, context);
00338 skipWhitespace(e);
00339 ABORT(lookAhead(e, 0) != '$');
00340 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",token->text);
00341 mymsg[0] = '\n';
00342 mymsg[1] = '\0';
00343 Hashtable *vars = newHashTable(100);
00344 for (i= 0; i < coreRuleVarDef .MaxNumOfDVars; i++) {
00345 if(lookupFromHashTable(vars, coreRuleVarDef.varName[i])==NULL) {
00346 snprintf(&mymsg[strlen(mymsg)], MAX_NAME_LEN - strlen(mymsg), "$%s\n", coreRuleVarDef.varName[i]);
00347 insertIntoHashTable(vars, coreRuleVarDef.varName[i], coreRuleVarDef.varName[i]);
00348 }
00349 }
00350 deleteHashTable(vars, NULL);
00351 _writeXMsg(streamId, myhdr, mymsg);
00352 cmd = REDEBUG_WAIT;
00353 OR(Param)
00354 NEXT_TOKEN_BASIC;
00355 _writeXMsg(streamId, myhdr, "Unknown parameter type.\n");
00356 cmd = REDEBUG_WAIT;
00357 OR(Param)
00358 _writeXMsg(streamId, myhdr, "Debugger command \'list\' requires at least one argument.\n");
00359 cmd = REDEBUG_WAIT;
00360 END_TRY(Param)
00361 OR(DbgCmd)
00362 TTEXT2("c", "continue");
00363 cmd = REDEBUG_STEP_CONTINUE;
00364 OR(DbgCmd)
00365 TTEXT2("C", "Continue");
00366 cmd = REDEBUG_CONTINUE_VERBOSE;
00367 OR(DbgCmd)
00368 TTEXT2("del", "delete");
00369 TRY(Param)
00370 TTYPE(TK_INT);
00371 n = atoi(token->text);
00372 if(breakPoints[n].actionName!= NULL) {
00373 free(breakPoints[n].actionName);
00374 if(breakPoints[n].base != NULL) {
00375 free(breakPoints[n].base);
00376 }
00377 breakPoints[n].actionName = NULL;
00378 breakPoints[n].base = NULL;
00379 snprintf(mymsg, MAX_NAME_LEN, "Breakpoint %i deleted\n", n);
00380 } else {
00381 snprintf(mymsg, MAX_NAME_LEN, "Breakpoint %i has not been defined\n", n);
00382 }
00383 _writeXMsg(streamId, myhdr, mymsg);
00384 cmd = REDEBUG_WAIT;
00385 OR(Param)
00386 _writeXMsg(streamId, myhdr, "Debugger command \'delete\' requires one argument.\n");
00387 cmd = REDEBUG_WAIT;
00388 END_TRY(Param)
00389 OR(DbgCmd)
00390 TTEXT2("p", "print");
00391 Node *n = parseTermRuleGen(e, 1, context);
00392 if(getNodeType(n) == N_ERROR) {
00393 errMsgToString(context->errmsg, mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg));
00394 } else {
00395 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Printing ");
00396 ptr = myhdr + strlen(myhdr);
00397 i = HEADER_TYPE_LEN - 1 - strlen(myhdr);
00398 termToString(&ptr, &i, 0, MIN_PREC, n, 0);
00399 snprintf(ptr, i, "\n");
00400 if(env != NULL) {
00401 disableReDebugger(grdf);
00402 res = computeNode(n, NULL, regionRegionCpEnv(env, r, (RegionRegionCopyFuncType *) regionRegionCpNode), rei, 0, &errmsg, r);
00403 enableReDebugger(grdf);
00404 outStr = convertResToString(res);
00405 snprintf(mymsg, MAX_NAME_LEN, "%s\n", outStr);
00406 free(outStr);
00407 if(getNodeType(res) == N_ERROR) {
00408 errMsgToString(&errmsg, mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg));
00409 }
00410 } else {
00411 snprintf(mymsg, MAX_NAME_LEN, "Runtime environment: <empty>\n");
00412 }
00413 }
00414 _writeXMsg(streamId, myhdr, mymsg);
00415
00416 cmd = REDEBUG_WAIT;
00417 OR(DbgCmd)
00418 TTEXT2("W", "Where");
00419 wCnt = 20;
00420 OPTIONAL_BEGIN(Param)
00421 TTYPE(TK_INT);
00422 wCnt = atoi(token->text);
00423 OPTIONAL_END(Param)
00424 iLevel = 0;
00425
00426 i = reDebugStackCurrPtr - 1;
00427 while (i >=0 && wCnt > 0 && reDebugStackCurr[i][0] != NULL) {
00428 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i",iLevel);
00429 char *msg = (char *) malloc(strlen(reDebugStackCurr[i][0]) + strlen(reDebugStackCurr[i][1]) + strlen(reDebugStackCurr[i][2])+4);
00430 sprintf(msg, "%s:%s: %s", reDebugStackCurr[i][0], reDebugStackCurr[i][1], reDebugStackCurr[i][2]);
00431 _writeXMsg(streamId, myhdr, msg);
00432 free(msg);
00433 if (strstr(reDebugStackCurr[i][0] , "ExecAction") != NULL)
00434 iLevel++;
00435 wCnt--;
00436 i--;
00437 }
00438 cmd = REDEBUG_WAIT;
00439 OR(DbgCmd)
00440 TTEXT2("d", "discontinue");
00441 cmd = REDEBUG_WAIT;
00442 OR(DbgCmd)
00443 snprintf(mymsg, MAX_NAME_LEN, "Unknown Action: %s", readmsg);
00444 _writeXMsg(streamId, myhdr, mymsg);
00445 cmd = REDEBUG_WAIT;
00446 END_TRY(DbgCmd)
00447 PARSER_END(DbgCmd)
00448 freeRErrorContent(&errmsg);
00449 region_free(r);
00450 deletePointer(e);
00451 return cmd;
00452 }
00453
00454 int
00455 processBreakPoint(int streamId, int *msgNum, int *seqNum,
00456 char *callLabel, char *actionStr, Node *node,
00457 Env *env, int curStat, ruleExecInfo_t *rei)
00458 {
00459
00460 int i;
00461 char myhdr[HEADER_TYPE_LEN];
00462 char mymsg[MAX_NAME_LEN];
00463
00464 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug:%s",callLabel);
00465
00466
00467 if (breakPointsInx > 0) {
00468 for (i = 0; i < breakPointsInx; i++) {
00469 if (breakPoints[i].actionName!=NULL) {
00470 int len = strlen(breakPoints[i].actionName);
00471
00472 if(strncmp(actionStr, breakPoints[i].actionName, len) == 0 && !isalnum(actionStr[len])) {
00473 if(breakPoints[i].base != NULL &&
00474 (node == NULL || node->expr < breakPoints[i].start || node->expr >= breakPoints[i].finish ||
00475 strcmp(node->base, breakPoints[i].base)!=0)) {
00476 continue;
00477 }
00478 char buf[MAX_NAME_LEN];
00479 snprintf(buf,MAX_NAME_LEN, "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName);
00480 generateErrMsg(buf, node->expr, node->base, mymsg);
00481 _writeXMsg(streamId, myhdr, mymsg);
00482 snprintf(mymsg,MAX_NAME_LEN, "%s\n", actionStr);
00483 _writeXMsg(streamId, myhdr, mymsg);
00484 curStat = REDEBUG_WAIT;
00485 return(curStat);
00486 }
00487 }
00488 }
00489 }
00490 return(curStat);
00491 }
00492
00493
00494 int
00495 storeInStack(char *hdr, char *action, char* step)
00496 {
00497
00498
00499
00500 int i;
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 if (strcmp(action,"Done") == 0) {
00520 i = reDebugStackCurrPtr - 1;
00521
00522
00523 while (i >= 0 && reDebugStackCurr[i] != NULL && strcmp(reDebugStackCurr[i][0] , hdr) != 0) {
00524 free(reDebugStackCurr[i][0]);
00525 free(reDebugStackCurr[i][1]);
00526 free(reDebugStackCurr[i][2]);
00527 reDebugStackCurr[i][0] = NULL;
00528 reDebugStackCurr[i][1] = NULL;
00529 reDebugStackCurr[i][2] = NULL;
00530 i = i - 1;
00531
00532
00533 }
00534
00535
00536
00537
00538 reDebugStackCurrPtr = i;
00539 return(0);
00540 } else {
00541
00542 i = reDebugStackCurrPtr;
00543
00544
00545
00546 if(i < REDEBUG_STACK_SIZE_CURR) {
00547 reDebugStackCurr[i][0] = strdup(hdr);
00548 reDebugStackCurr[i][1] = strdup(action);
00549 reDebugStackCurr[i][2] = strdup(step);
00550 reDebugStackCurrPtr = i + 1;
00551 }
00552 return(0);
00553 }
00554 }
00555
00556
00557 int sendWaitXMsg (int streamId) {
00558 _writeXMsg(streamId, waitHdr, waitMsg);
00559 return(0);
00560 }
00561 int cleanUpDebug(int streamId) {
00562 int i;
00563 for (i = 0 ; i < REDEBUG_STACK_SIZE_CURR; i++) {
00564 if (reDebugStackCurr[i] != NULL) {
00565 free(reDebugStackCurr[i][0]);
00566 free(reDebugStackCurr[i][1]);
00567 free(reDebugStackCurr[i][2]);
00568 reDebugStackCurr[i][0] = NULL;
00569 reDebugStackCurr[i][1] = NULL;
00570 reDebugStackCurr[i][2] = NULL;
00571 }
00572 }
00573 for (i = 0 ; i < REDEBUG_STACK_SIZE_FULL; i++) {
00574 if (reDebugStackFull[i] != NULL) {
00575 free(reDebugStackFull[i]);
00576 reDebugStackFull[i] = NULL;
00577 }
00578 }
00579 reDebugStackCurrPtr = 0;
00580 reDebugStackFullPtr = 0;
00581 GlobalREDebugFlag = -1;
00582 return(0);
00583 }
00584
00585 int
00586 reDebug(char *callLabel, int flag, char *action, char *actionStr, Node *node, Env *env, ruleExecInfo_t *rei)
00587 {
00588 int i, m, s, status, sleepT, j;
00589 int processedBreakPoint = 0;
00590 char hdr[HEADER_TYPE_LEN];
00591 char *readhdr = NULL;
00592 char *readmsg = NULL;
00593 char *user = NULL;
00594 char *addr = NULL;
00595 static int mNum = 0;
00596 static int sNum = 0;
00597 static int curStat = 0;
00598 static int reDebugStackPtr = -1;
00599 static char *reDebugAction = NULL;
00600 char condRead[MAX_NAME_LEN];
00601 char myActionStr[10][MAX_NAME_LEN + 10];
00602 int aNum = 0;
00603 char seActionStr[10 * MAX_NAME_LEN + 100];
00604 char timestamp[TIME_LEN];
00605 rsComm_t *svrComm;
00606 int waitCnt = 0;
00607 sleepT = 1;
00608 svrComm = rei->rsComm;
00609
00610 if (svrComm == NULL) {
00611 rodsLog(LOG_ERROR, "Empty svrComm in REI structure for actionStr=%s\n",
00612 actionStr);
00613 return(0);
00614 }
00615
00616 generateLogTimestamp(timestamp, TIME_LEN);
00617 snprintf(hdr, HEADER_TYPE_LEN - 1, "iaudit:%s:%s", timestamp, callLabel);
00618 condRead[0] = '\0';
00619
00620 snprintf(seActionStr, MAX_NAME_LEN + 10, "%s:%s", action, actionStr);
00621 if (GlobalREAuditFlag > 0) {
00622 if (flag == -4) {
00623 if (rei->uoic != NULL && rei->uoic->userName != NULL && rei->uoic->rodsZone != NULL) {
00624 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " USER:%s@%s", rei->uoic->userName, rei->uoic->rodsZone);
00625 aNum++;
00626 }
00627 if (rei->doi != NULL && rei->doi->objPath != NULL && strlen(rei->doi->objPath) > 0 ) {
00628 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " DATA:%s", rei->doi->objPath);
00629 aNum++;
00630 }
00631 if (rei->doi != NULL && rei->doi->filePath != NULL && strlen(rei->doi->filePath) > 0) {
00632 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " FILE:%s", rei->doi->filePath);
00633 aNum++;
00634 }
00635 if (rei->doinp != NULL && rei->doinp->objPath != NULL && strlen(rei->doinp->objPath) > 0) {
00636 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " DATAIN:%s",rei->doinp->objPath);
00637 aNum++;
00638 }
00639 if (rei->doi != NULL && rei->doi->rescName != NULL && strlen(rei->doi->rescName) > 0) {
00640 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESC:%s",rei->doi->rescName);
00641 aNum++;
00642 }
00643 if (rei->rgi != NULL && rei->rgi->rescInfo->rescName != NULL && strlen(rei->rgi->rescInfo->rescName) > 0) {
00644 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESC:%s",rei->rgi->rescInfo->rescName);
00645 aNum++;
00646 }
00647 if (rei->doi != NULL && rei->doi->rescGroupName != NULL && strlen(rei->doi->rescGroupName) > 0) {
00648 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESCGRP:%s",rei->doi->rescGroupName);
00649 aNum++;
00650 }
00651 if (rei->rgi != NULL && rei->rgi->rescGroupName != NULL && strlen(rei->rgi->rescGroupName) > 0) {
00652 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESCGRP:%s",rei->rgi->rescGroupName);
00653 aNum++;
00654 }
00655 if (rei->coi != NULL && rei->coi->collName != NULL) {
00656 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " COLL:%s", rei->coi->collName);
00657 aNum++;
00658 }
00659 for (j = 0; j < aNum; j++) {
00660 strncat(seActionStr, myActionStr[j], 10 * MAX_NAME_LEN + 100);
00661 }
00662 }
00663 }
00664
00665
00666 if (GlobalREAuditFlag == 3) {
00667 i = _writeXMsg(GlobalREAuditFlag, hdr, seActionStr);
00668 }
00669
00670
00671
00672 if ( GlobalREDebugFlag > 5 ) {
00673
00674 storeInStack(callLabel, action, actionStr);
00675
00676 if (curStat == REDEBUG_CONTINUE && reDebugStackCurrPtr <= reDebugStackPtr && strcmp(action, reDebugAction) == 0) {
00677 curStat = REDEBUG_WAIT;
00678 }
00679 if (curStat != REDEBUG_CONTINUE) {
00680 char *buf = (char *)malloc(strlen(action)+strlen(actionStr)+2);
00681 sprintf(buf, "%s:%s", action, actionStr);
00682 snprintf(hdr, HEADER_TYPE_LEN - 1, "idbug:%s",callLabel);
00683 i = _writeXMsg(GlobalREDebugFlag, hdr, buf);
00684 free(buf);
00685 }
00686
00687 while ( GlobalREDebugFlag > 5 ) {
00688 s = sNum;
00689 m = mNum;
00690
00691 sprintf(condRead, "(*XSEQNUM >= %d) && (*XADDR != \"%s:%i\") && (*XUSER == \"%s@%s\") && ((*XHDR == \"CMSG:ALL\") %%%% (*XHDR == \"CMSG:%s:%i\"))",
00692 s, myHostName, myPID, svrComm->clientUser.userName, svrComm->clientUser.rodsZone, myHostName, myPID);
00693
00694
00695
00696
00697
00698 status = _readXMsg(GlobalREDebugFlag, condRead, &m, &s, &readhdr, &readmsg, &user, &addr);
00699 if (status == SYS_UNMATCHED_XMSG_TICKET) {
00700 cleanUpDebug(GlobalREDebugFlag);
00701 return(0);
00702 }
00703 if (status >= 0) {
00704 rodsLog (LOG_NOTICE,"Getting XMsg:%i:%s:%s\n", s,readhdr, readmsg);
00705 curStat = processXMsg(GlobalREDebugFlag, &m, &s, readhdr, readmsg,
00706 callLabel,node,
00707 env, curStat, rei);
00708 if (readhdr != NULL)
00709 free(readhdr);
00710 if (readmsg != NULL)
00711 free(readmsg);
00712 if (user != NULL)
00713 free(user);
00714 if (addr != NULL)
00715 free(addr);
00716
00717 mNum = m;
00718 sNum = s + 1;
00719 if (curStat == REDEBUG_WAIT) {
00720 sendWaitXMsg(GlobalREDebugFlag);
00721 } else
00722 if(curStat == REDEBUG_STEP_OVER) {
00723 reDebugStackPtr = reDebugStackCurrPtr;
00724 reDebugAction = "";
00725 curStat = REDEBUG_CONTINUE;
00726 break;
00727 } else
00728 if(curStat == REDEBUG_STEP_OUT) {
00729 reDebugStackPtr = reDebugStackCurrPtr - 1;
00730 reDebugAction = "Done";
00731 curStat = REDEBUG_CONTINUE;
00732 break;
00733 } else
00734 if(curStat == REDEBUG_STEP_CONTINUE) {
00735 reDebugStackPtr = -1;
00736 curStat = REDEBUG_CONTINUE;
00737 break;
00738 } else if (curStat == REDEBUG_NEXT )
00739 break;
00740 } else {
00741 if (!(curStat == REDEBUG_CONTINUE || curStat == REDEBUG_CONTINUE_VERBOSE)) {
00742
00743
00744
00745
00746
00747
00748 sleep(sleepT);
00749 waitCnt+=100;
00750
00751 if (waitCnt > 6000) {
00752 sendWaitXMsg(GlobalREDebugFlag);
00753 waitCnt = 0;
00754 }
00755 }
00756 }
00757 if (curStat == REDEBUG_CONTINUE || curStat == REDEBUG_CONTINUE_VERBOSE) {
00758 if (processedBreakPoint == 1)
00759 break;
00760 if(strcmp(action, "") != 0 || strstr(callLabel, "ExecAction")==NULL)
00761 break;
00762 curStat = processBreakPoint(GlobalREDebugFlag, &m, &s,
00763 callLabel, actionStr, node,
00764 env, curStat, rei);
00765 processedBreakPoint = 1;
00766 if (curStat == REDEBUG_WAIT) {
00767 sendWaitXMsg(GlobalREDebugFlag);
00768 continue;
00769 } else
00770 break;
00771 }
00772 }
00773 }
00774
00775
00776 return(0);
00777 }