summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--action.c175
-rw-r--r--action.h2
-rw-r--r--runtime/nspoll.c3
-rw-r--r--runtime/queue.c7
-rw-r--r--runtime/rule.c17
-rw-r--r--runtime/ruleset.c11
-rw-r--r--runtime/stream.c5
-rw-r--r--tools/smfile.c1
-rw-r--r--tools/smfwd.c1
-rw-r--r--tools/smtradfile.c1
-rw-r--r--tools/smtradfwd.c1
11 files changed, 111 insertions, 113 deletions
diff --git a/action.c b/action.c
index 20fc3cb6..83929c2e 100644
--- a/action.c
+++ b/action.c
@@ -52,9 +52,9 @@
/* forward definitions */
static rsRetVal processBatchMain(action_t *pAction, batch_t *pBatch, int*);
-static rsRetVal actionCallAction(action_t *pAction, msg_t *pMsg);
-static rsRetVal doSubmitToActionQ(action_t *pAction, msg_t *pMsg);
-static rsRetVal doSubmitToActionQNotAllMark(action_t *pAction, msg_t *pMsg);
+static rsRetVal doSubmitToActionQComplexBatch(action_t *pAction, batch_t *pBatch);
+static rsRetVal doSubmitToActionQNotAllMarkBatch(action_t *pAction, batch_t *pBatch);
+static rsRetVal doSubmitToActionQBatch(action_t *pAction, batch_t *pBatch);
/* object static data (once for all instances) */
/* TODO: make this an object! DEFobjStaticHelpers -- rgerhards, 2008-03-05 */
@@ -260,7 +260,6 @@ actionConstructFinalize(action_t *pThis)
* not used. Thankfully, that is usually the case. The benefit of firehose
* mode is much faster processing (and simpler code) -- rgerhards, 2010-06-08
*/
- /* how about bWriteAllMarkMsgs??? */
if( pThis->iExecEveryNthOccur > 1
|| pThis->f_ReduceRepeated
|| pThis->iSecsExecOnceInterval
@@ -272,13 +271,13 @@ actionConstructFinalize(action_t *pThis)
pThis->iExecEveryNthOccur, pThis->f_ReduceRepeated,
pThis->iSecsExecOnceInterval
);
- pThis->submitToActQ = actionCallAction;
+ pThis->submitToActQ = doSubmitToActionQComplexBatch;
} else if(pThis->bWriteAllMarkMsgs == FALSE) {
/* nearly full-speed submission mode, default case */
- pThis->submitToActQ = doSubmitToActionQNotAllMark;
+ pThis->submitToActQ = doSubmitToActionQNotAllMarkBatch;
} else {
/* full firehose submission mode */
- pThis->submitToActQ = doSubmitToActionQ;
+ pThis->submitToActQ = doSubmitToActionQBatch;
}
/* we need to make a safety check: if the queue is NOT in direct mode, a single
@@ -635,11 +634,11 @@ rsRetVal actionDbgPrint(action_t *pThis)
}
dbgprintf("\tState: %s\n", getActStateName(pThis));
dbgprintf("\tExec only when previous is suspended: %d\n", pThis->bExecWhenPrevSusp);
- if(pThis->submitToActQ == actionCallAction) {
+ if(pThis->submitToActQ == doSubmitToActionQComplexBatch) {
sz = "slow, but feature-rich";
- } else if(pThis->submitToActQ == doSubmitToActionQNotAllMark) {
+ } else if(pThis->submitToActQ == doSubmitToActionQNotAllMarkBatch) {
sz = "fast, but supports partial mark messages";
- } else if(pThis->submitToActQ == doSubmitToActionQ) {
+ } else if(pThis->submitToActQ == doSubmitToActionQBatch) {
sz = "firehose (fastest)";
} else {
sz = "unknown (need to update debug display?)";
@@ -880,7 +879,6 @@ tryDoAction(action_t *pAction, batch_t *pBatch, int *pnElem)
assert(pBatch != NULL);
assert(pnElem != NULL);
-dbgprintf("ZZZ1: tryDoAction, nElem %d, iDoneUpto %d\n", *pnElem, pBatch->iDoneUpTo);
i = pBatch->iDoneUpTo; /* all messages below that index are processed */
iElemProcessed = 0;
iCommittedUpTo = i;
@@ -943,7 +941,6 @@ submitBatch(action_t *pAction, batch_t *pBatch, int nElem)
rsRetVal localRet;
DEFiRet;
-dbgprintf("ZZZ1: submitBatch, nElem %d\n", nElem);
assert(pBatch != NULL);
bDone = 0;
@@ -1032,7 +1029,6 @@ processAction(action_t *pAction, batch_t *pBatch)
DEFiRet;
assert(pBatch != NULL);
-dbgprintf("ZZZ1: processAction\n");
CHKiRet(submitBatch(pAction, pBatch, pBatch->nElem));
iRet = finishBatch(pAction, pBatch);
@@ -1054,13 +1050,11 @@ processBatchMain(action_t *pAction, batch_t *pBatch, int *pbShutdownImmediate)
assert(pBatch != NULL);
-dbgprintf("ZZZ1: processBatchMain\n");
pbShutdownImmdtSave = pBatch->pbShutdownImmediate;
pBatch->pbShutdownImmediate = pbShutdownImmediate;
pAction->pbShutdownImmediate = pBatch->pbShutdownImmediate;
CHKiRet(prepareBatch(pAction, pBatch));
-dbgprintf("ZZZ1: processBatchMain\n");
/* We now must guard the output module against execution by multiple threads. The
* plugin interface specifies that output modules must not be thread-safe (except
* if they notify us they are - functionality not yet implemented...).
@@ -1070,13 +1064,6 @@ dbgprintf("ZZZ1: processBatchMain\n");
pthread_cleanup_push(mutexCancelCleanup, &pAction->mutActExec);
iRet = processAction(pAction, pBatch);
- //
- // DEBUG
- int i;
- for(i = 0 ; i < batchNumMsgs(pBatch) ; ++i) {
-dbgprintf("ZZZ: after processBatchMain item %d: filter %d, state %d\n", i, pBatch->pElem[i].bFilterOK, pBatch->pElem[i].state);
- }
- // END DEBUG
pthread_cleanup_pop(1); /* unlock mutex */
@@ -1273,7 +1260,7 @@ finalize_it:
/* helper to actonCallAction, mostly needed because of this damn
* pthread_cleanup_push() POSIX macro...
*/
-static rsRetVal
+static inline rsRetVal
doActionCallAction(action_t *pAction, msg_t *pMsg)
{
DEFiRet;
@@ -1328,72 +1315,104 @@ finalize_it:
RETiRet;
}
-
-/* This submits the message to the action queue in case where we need to handle
- * bWriteAllMarkMessage == FALSE only. Note that we use a non-blocking CAS loop
- * for the synchronization.
+/* This submits the message to the action queue in case we do NOT need to handle repeat
+ * message processing. That case permits us to gain lots of freedom during processing
+ * and thus speed.
* rgerhards, 2010-06-08
*/
-static rsRetVal
-doSubmitToActionQNotAllMark(action_t *pAction, msg_t *pMsg)
+static inline rsRetVal
+doSubmitToActionQ(action_t *pAction, msg_t *pMsg)
{
DEFiRet;
- time_t now;
- time_t lastAct;
- if(pMsg->msgFlags & MARK) {
- now = datetime.GetTime(NULL); /* good time call - the only one done */
- /* CAS loop, we write back a bit early, but that's OK... */
- /* we use reception time, not dequeue time - this is considered more appropriate and
- * also faster ;) -- rgerhards, 2008-09-17 */
- do {
- lastAct = pAction->f_time;
- if((now - lastAct) < MarkInterval / 2) {
- DBGPRINTF("file was recently written, ignoring mark message\n");
- ABORT_FINALIZE(RS_RET_OK);
- }
- } while(ATOMIC_CAS(&pAction->f_time, lastAct, pMsg->ttGenTime, ADDME) == 0);
- }
-
- DBGPRINTF("Called action, logging to %s\n", module.GetStateName(pAction->pMod));
if(pAction->pQueue->qType == QUEUETYPE_DIRECT)
iRet = qqueueEnqObjDirect(pAction->pQueue, (void*) MsgAddRef(pMsg));
else
iRet = qqueueEnqObj(pAction->pQueue, pMsg->flowCtlType, (void*) MsgAddRef(pMsg));
- //iRet = qqueueEnqObj(pAction->pQueue, pMsg->flowCtlType, (void*) MsgAddRef(pMsg));
-finalize_it:
RETiRet;
}
-/* This submits the message to the action queue in case we do NOT need to handle repeat
- * message processing. That case permits us to gain lots of freedom during processing
- * and thus speed.
+
+/* This submits the message to the action queue in case where we need to handle
+ * bWriteAllMarkMessage == FALSE only. Note that we use a non-blocking CAS loop
+ * for the synchronization. Here, we just modify the filter condition to be false when
+ * a mark message must not be written. However, in this case we must save the previous
+ * filter as we may need it in the next action (potential future optimization: check if this is
+ * the last action TODO).
* rgerhards, 2010-06-08
*/
static rsRetVal
-doSubmitToActionQ(action_t *pAction, msg_t *pMsg)
+doSubmitToActionQNotAllMarkBatch(action_t *pAction, batch_t *pBatch)
{
+ time_t now = 0;
+ time_t lastAct;
+ int i;
+ int bProcessMarkMsgs;
+ int bModifiedFilter;
+ sbool FilterSave[128];
+ sbool *pFilterSave;
DEFiRet;
- DBGPRINTF("Called action, logging to %s\n", module.GetStateName(pAction->pMod));
- if(pAction->pQueue->qType == QUEUETYPE_DIRECT)
- iRet = qqueueEnqObjDirect(pAction->pQueue, (void*) MsgAddRef(pMsg));
- else
- iRet = qqueueEnqObj(pAction->pQueue, pMsg->flowCtlType, (void*) MsgAddRef(pMsg));
+ if(batchNumMsgs(pBatch) <= (int) (sizeof(FilterSave)/sizeof(sbool))) {
+ pFilterSave = FilterSave;
+ } else {
+ CHKmalloc(pFilterSave = malloc(batchNumMsgs(pBatch) * sizeof(sbool)));
+ }
+
+ bModifiedFilter = 0;
+ for(i = 0 ; i < batchNumMsgs(pBatch) ; ++i) {
+ pFilterSave[i] = pBatch->pElem[i].bFilterOK;
+ if(((msg_t*)(pBatch->pElem[i].pUsrp))->msgFlags & MARK) {
+ /* check if we need to write or not */
+ if(now == 0) {
+ now = datetime.GetTime(NULL); /* good time call - the only one done */
+ /* CAS loop, we write back a bit early, but that's OK... */
+ /* we use reception time, not dequeue time - this is considered more appropriate and
+ * also faster ;) -- rgerhards, 2008-09-17 */
+ do {
+ lastAct = pAction->f_time;
+ if((now - lastAct) < MarkInterval / 2) {
+ DBGPRINTF("action was recently called, ignoring mark message\n");
+ bProcessMarkMsgs = 0;
+ } else {
+ bProcessMarkMsgs = 1;
+ }
+ } while(ATOMIC_CAS(&pAction->f_time, lastAct, ((msg_t*)(pBatch->pElem[i].pUsrp))->ttGenTime, ADDME) == 0);
+ }
+ if(bProcessMarkMsgs) {
+ pBatch->pElem[i].bFilterOK = 0;
+ bModifiedFilter = 1;
+ }
+ }
+ }
+
+ DBGPRINTF("Called action(NotAllMark), logging to %s\n", module.GetStateName(pAction->pMod));
+
+ iRet = doSubmitToActionQBatch(pAction, pBatch);
+
+ if(bModifiedFilter) {
+ /* in this case, we need to restore previous state */
+ for(i = 0 ; i < batchNumMsgs(pBatch) ; ++i) {
+ pBatch->pElem[i].bFilterOK = pFilterSave[i];
+ }
+ }
+
+finalize_it:
+ if(pFilterSave != FilterSave)
+ free(pFilterSave);
RETiRet;
}
-//*** EXPERIMENTAL ***/
/* This submits the message to the action queue in case we do NOT need to handle repeat
* message processing. That case permits us to gain lots of freedom during processing
* and thus speed.
* rgerhards, 2010-06-08
*/
-rsRetVal
+static rsRetVal
doSubmitToActionQBatch(action_t *pAction, batch_t *pBatch)
{
int i;
@@ -1407,39 +1426,48 @@ doSubmitToActionQBatch(action_t *pAction, batch_t *pBatch)
*/
for(i = 0 ; i < batchNumMsgs(pBatch) && !*(pBatch->pbShutdownImmediate) ; ++i) {
if(pBatch->pElem[i].bFilterOK) {
-dbgprintf("ZZZ: submitToActQ item %d:%s\n", i, ((msg_t*)(pBatch->pElem[i].pUsrp))->szRawMsg+15);
- pAction->submitToActQ(pAction, (msg_t*)(pBatch->pElem[i].pUsrp));
+ doSubmitToActionQ(pAction, (msg_t*)(pBatch->pElem[i].pUsrp));
}
}
+ }
- // DEBUG
- for(i = 0 ; i < batchNumMsgs(pBatch) && !*(pBatch->pbShutdownImmediate) ; ++i) {
- if(pBatch->pElem[i].bFilterOK) {
-dbgprintf("ZZZ: batch state after processing item %d: %d\n", i, pBatch->pElem[i].state);
- }
+ RETiRet;
+}
+
+
+
+/* Helper to submit a batch of actions to the engine. Note that we have rather
+ * complicated processing here, so we need to do this one message after another.
+ * rgerhards, 2010-06-23
+ */
+static inline rsRetVal
+helperSubmitToActionQComplexBatch(action_t *pAction, batch_t *pBatch)
+{
+ int i;
+ DEFiRet;
+
+ DBGPRINTF("Called action(complex case), logging to %s\n", module.GetStateName(pAction->pMod));
+ for(i = 0 ; i < batchNumMsgs(pBatch) && !*(pBatch->pbShutdownImmediate) ; ++i) {
+ if(pBatch->pElem[i].bFilterOK) {
+ doActionCallAction(pAction, (msg_t*)(pBatch->pElem[i].pUsrp));
}
- // END DEBUG
}
RETiRet;
}
-
/* Call configured action, most complex case with all features supported (and thus slow).
* rgerhards, 2010-06-08
*/
#pragma GCC diagnostic ignored "-Wempty-body"
static rsRetVal
-actionCallAction(action_t *pAction, msg_t *pMsg)
+doSubmitToActionQComplexBatch(action_t *pAction, batch_t *pBatch)
{
DEFiRet;
- ISOBJ_TYPE_assert(pMsg, msg);
- ASSERT(pAction != NULL);
-
LockObj(pAction);
pthread_cleanup_push(mutexCancelCleanup, pAction->Sync_mut);
- iRet = doActionCallAction(pAction, pMsg);
+ iRet = helperSubmitToActionQComplexBatch(pAction, pBatch);
UnlockObj(pAction);
pthread_cleanup_pop(0); /* remove mutex cleanup handler */
@@ -1447,7 +1475,6 @@ actionCallAction(action_t *pAction, msg_t *pMsg)
}
#pragma GCC diagnostic warning "-Wempty-body"
-
/* add an Action to the current selector
* The pOMSR is freed, as it is not needed after this function.
* Note: this function pulls global data that specifies action config state.
diff --git a/action.h b/action.h
index 509eada4..d313a6e3 100644
--- a/action.h
+++ b/action.h
@@ -73,7 +73,7 @@ struct action_s {
short f_ReduceRepeated;/* reduce repeated lines 0 - no, 1 - yes */
int f_prevcount; /* repetition cnt of prevline */
int f_repeatcount; /* number of "repeated" msgs */
- rsRetVal (*submitToActQ)(action_t *, msg_t *); /* function submit message to action queue */
+ rsRetVal (*submitToActQ)(action_t *, batch_t *);/* function submit message to action queue */
rsRetVal (*qConstruct)(struct queue_s *pThis);
enum { ACT_STRING_PASSING = 0, ACT_ARRAY_PASSING = 1, ACT_MSG_PASSING }
eParamPassing; /* mode of parameter passing to action */
diff --git a/runtime/nspoll.c b/runtime/nspoll.c
index f287cd4e..64927280 100644
--- a/runtime/nspoll.c
+++ b/runtime/nspoll.c
@@ -79,7 +79,6 @@ loadDrvr(nspoll_t *pThis)
* about this hack, but for the time being it is efficient and clean
* enough. -- rgerhards, 2008-04-18
*/
-RUNLOG_VAR("%s", szDrvrName+2);
CHKiRet(obj.UseObj(__FILE__, szDrvrName+2, DONT_LOAD_LIB, (void*) &pThis->Drvr));
finalize_it:
@@ -120,11 +119,9 @@ ConstructFinalize(nspoll_t *pThis)
{
DEFiRet;
ISOBJ_TYPE_assert(pThis, nspoll);
-RUNLOG_STR("trying to load epoll driver\n");
CHKiRet(loadDrvr(pThis));
CHKiRet(pThis->Drvr.Construct(&pThis->pDrvrData));
finalize_it:
-dbgprintf("XXX: done trying to load epoll driver, state %d\n", iRet);
RETiRet;
}
diff --git a/runtime/queue.c b/runtime/queue.c
index 5e9c67ca..60d17086 100644
--- a/runtime/queue.c
+++ b/runtime/queue.c
@@ -852,8 +852,11 @@ static rsRetVal qAddDirect(qqueue_t *pThis, void* pUsr)
* We use our knowledge about the batch_t structure below, but without that, we
* pay a too-large performance toll... -- rgerhards, 2009-04-22
*/
+ memset(&batchObj, 0, sizeof(batch_obj_t));
+ memset(&singleBatch, 0, sizeof(batch_t));
batchObj.state = BATCH_STATE_RDY;
batchObj.pUsrp = (obj_t*) pUsr;
+ batchObj.bFilterOK = 1;
singleBatch.nElem = 1; /* there always is only one in direct mode */
singleBatch.pElem = &batchObj;
iRet = pThis->pConsumer(pThis->pUsr, &singleBatch, &pThis->bShutdownImmediate);
@@ -862,7 +865,9 @@ static rsRetVal qAddDirect(qqueue_t *pThis, void* pUsr)
RETiRet;
}
-/*** EXPERIMENTAL ***/
+/* "enqueue" a batch in direct mode. This is a shortcut which saves all the overhead
+ * otherwise incured. -- rgerhards, ~2010-06-23
+ */
rsRetVal qqueueEnqObjDirectBatch(qqueue_t *pThis, batch_t *pBatch)
{
DEFiRet;
diff --git a/runtime/rule.c b/runtime/rule.c
index 453e631d..c3c974bf 100644
--- a/runtime/rule.c
+++ b/runtime/rule.c
@@ -101,6 +101,7 @@ DEFFUNC_llExecFunc(processBatchDoActions)
assert(pAction != NULL);
+#warning execonly when prev suspended functionality missing!
#if 0 // TODO: move this to the action object
if((pAction->bExecWhenPrevSusp == 1) && (pDoActData->bPrevWasSuspended == 0)) {
dbgprintf("not calling action because the previous one is not suspended\n");
@@ -108,20 +109,8 @@ DEFFUNC_llExecFunc(processBatchDoActions)
}
#endif
-#if 1
- // NEW (potentially):
- iRetMod = doSubmitToActionQBatch(pAction, (batch_t*) pParam);
-#else
- // old code -- milestone check
- int i;
- for(i = 0 ; i < batchNumMsgs(pBatch) && !*(pBatch->pbShutdownImmediate) ; ++i) {
-dbgprintf("ZZZ: inside processBatchDoActions, processing elem %d/%d\n", i, batchNumMsgs(pBatch));
- if(pBatch->pElem[i].bFilterOK) {
- iRetMod = pAction->submitToActQ(pAction, (msg_t*)(pBatch->pElem[i].pUsrp));
- }
- }
-#endif
- //end old code
+ iRetMod = pAction->submitToActQ(pAction, pBatch);
+
#if 0 // TODO: this must be done inside the action as well!
if(iRetMod == RS_RET_DISCARDMSG) {
ABORT_FINALIZE(RS_RET_DISCARDMSG);
diff --git a/runtime/ruleset.c b/runtime/ruleset.c
index 31c2e1a7..8d6a1c2f 100644
--- a/runtime/ruleset.c
+++ b/runtime/ruleset.c
@@ -175,7 +175,6 @@ processBatchMultiRuleset(batch_t *pBatch)
CHKiRet(batchInit(&snglRuleBatch, pBatch->nElem));
snglRuleBatch.pbShutdownImmediate = pBatch->pbShutdownImmediate;
-dbgprintf("ZZZ: multi-ruleset batch of %d elements must be processed\n", pBatch->nElem);
while(1) { /* loop broken inside */
/* search for first unprocessed element */
for(iStart = 0 ; iStart < pBatch->nElem && pBatch->pElem[iStart].state == BATCH_STATE_DISC ; ++iStart)
@@ -189,7 +188,6 @@ dbgprintf("ZZZ: multi-ruleset batch of %d elements must be processed\n", pBatch-
iNew = 0;
for(i = iStart ; i < pBatch->nElem ; ++i) {
if(batchElemGetRuleset(pBatch, i) == currRuleset) {
-dbgprintf("ZZZ: proc elem %d:'%s'\n", i, ((msg_t*)(pBatch->pElem[i].pUsrp))->szRawMsg+15);
batchCopyElem(&(snglRuleBatch.pElem[iNew++]), &(pBatch->pElem[i]));
/* We indicate the element also as done, so it will not be processed again */
pBatch->pElem[i].state = BATCH_STATE_DISC;
@@ -199,15 +197,6 @@ dbgprintf("ZZZ: proc elem %d:'%s'\n", i, ((msg_t*)(pBatch->pElem[i].pUsrp))->szR
batchSetSingleRuleset(&snglRuleBatch, 1);
/* process temp batch */
processBatch(&snglRuleBatch);
-
-#if 0
-for(i = iStart ; i < pBatch->nElem ; ++i) {
- dbgprintf("ZZZ: after partial execution item %d state %d\n", i, pBatch->pElem[i].state);
-}
-//dbgprintf("ZZZ: search item %d: state %d, bFilterOK %d, IsValid %d, msg:%s\n",
-//iStart, pBatch->pElem[iStart].state, pBatch->pElem[iStart].bFilterOK, batchIsValidElem(pBatch, iStart),
-//((msg_t*)(pBatch->pElem[iStart].pUsrp))->szRawMsg+40);
-#endif
}
batchFree(&snglRuleBatch);
diff --git a/runtime/stream.c b/runtime/stream.c
index e0b97f9f..b4295762 100644
--- a/runtime/stream.c
+++ b/runtime/stream.c
@@ -937,7 +937,6 @@ asyncWriterThread(void *pPtr)
while(1) { /* loop broken inside */
d_pthread_mutex_lock(&pThis->mut);
-dbgprintf("XXX: asyncWriterThread iterating %s\n", pThis->pszFName);
while(pThis->iCnt == 0) {
if(pThis->bStopWriter) {
pthread_cond_broadcast(&pThis->isEmpty);
@@ -953,7 +952,6 @@ dbgprintf("XXX: asyncWriterThread iterating %s\n", pThis->pszFName);
bTimedOut = 0;
timeoutComp(&t, pThis->iFlushInterval * 2000); /* *1000 millisconds */ // TODO: check the 2000?!?
if(pThis->bDoTimedWait) {
-dbgprintf("asyncWriter thread going to timeout sleep\n");
if(pthread_cond_timedwait(&pThis->notEmpty, &pThis->mut, &t) != 0) {
int err = errno;
if(err == ETIMEDOUT) {
@@ -967,16 +965,13 @@ dbgprintf("asyncWriter thread going to timeout sleep\n");
}
}
} else {
-dbgprintf("asyncWriter thread going to eternal sleep\n");
d_pthread_cond_wait(&pThis->notEmpty, &pThis->mut);
}
-dbgprintf("asyncWriter woke up\n");
}
bTimedOut = 0; /* we may have timed out, but there *is* work to do... */
iDeq = pThis->iDeq++ % STREAM_ASYNC_NUMBUFS;
-dbgprintf("asyncWriter writes data\n");
doWriteInternal(pThis, pThis->asyncBuf[iDeq].pBuf, pThis->asyncBuf[iDeq].lenBuf);
// TODO: error check????? 2009-07-06
diff --git a/tools/smfile.c b/tools/smfile.c
index 9ad01421..5e4a775f 100644
--- a/tools/smfile.c
+++ b/tools/smfile.c
@@ -72,7 +72,6 @@ BEGINstrgen
size_t lenMSG;
size_t lenTotal;
CODESTARTstrgen
- DBGPRINTF("XXX: smfile strgen called\n");
/* first obtain all strings and their length (if not fixed) */
pTimeStamp = (uchar*) getTimeReported(pMsg, tplFmtRFC3339Date);
lenTimeStamp = ustrlen(pTimeStamp);
diff --git a/tools/smfwd.c b/tools/smfwd.c
index 4521e0e9..fe33fb2c 100644
--- a/tools/smfwd.c
+++ b/tools/smfwd.c
@@ -71,7 +71,6 @@ BEGINstrgen
size_t lenMSG;
size_t lenTotal;
CODESTARTstrgen
- DBGPRINTF("XXX: smfwd strgen called\n");
/* first obtain all strings and their length (if not fixed) */
pPRI = getPRI(pMsg);
lenPRI = strlen(pPRI);
diff --git a/tools/smtradfile.c b/tools/smtradfile.c
index 103c367e..eff2f99a 100644
--- a/tools/smtradfile.c
+++ b/tools/smtradfile.c
@@ -68,7 +68,6 @@ BEGINstrgen
size_t lenMSG;
size_t lenTotal;
CODESTARTstrgen
- DBGPRINTF("XXX: smtradfile strgen called\n");
/* first obtain all strings and their length (if not fixed) */
pTimeStamp = (uchar*) getTimeReported(pMsg, tplFmtRFC3164Date);
pHOSTNAME = (uchar*) getHOSTNAME(pMsg);
diff --git a/tools/smtradfwd.c b/tools/smtradfwd.c
index 90e5e59e..88dc6082 100644
--- a/tools/smtradfwd.c
+++ b/tools/smtradfwd.c
@@ -70,7 +70,6 @@ BEGINstrgen
size_t lenMSG;
size_t lenTotal;
CODESTARTstrgen
- DBGPRINTF("XXX: smtradfwd strgen called\n");
/* first obtain all strings and their length (if not fixed) */
pPRI = getPRI(pMsg);
lenPRI = strlen(pPRI);
generated by cgit (git 2.34.1) at 2024-04-27 15:29:31 +0000