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