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