summaryrefslogtreecommitdiffstats
path: root/contrib/improg/improg.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/improg/improg.c')
-rw-r--r--contrib/improg/improg.c722
1 files changed, 722 insertions, 0 deletions
diff --git a/contrib/improg/improg.c b/contrib/improg/improg.c
new file mode 100644
index 0000000..d525ddd
--- /dev/null
+++ b/contrib/improg/improg.c
@@ -0,0 +1,722 @@
+/* improg.c
+ * This input plugin enables rsyslog to execute a program and
+ * receive from it the message stream as standard input.
+ * One message per line with a maximum size
+ *
+ * NOTE: read comments in module-template.h for more specifics!
+ *
+ * File begun on 2009-04-01 by RGerhards
+ * File copied and adjust from improg.c on 2019-02-07 by Ph. Duveau
+ *
+ * Copyright 2009-2018 Adiscon GmbH.
+ *
+ * This file is contribution of rsyslog.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * -or-
+ * see COPYING.ASL20 in the source distribution
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "config.h"
+#include <stdio.h>
+#include <syslog.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <signal.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <pthread.h>
+#include <poll.h>
+
+/* Very strange error on solaris 11 LOG_CRON already defined here.
+ * It is redefined in rsyslog.h
+ * The error also appeared with module omprog but the warning is
+ * accepted without generated an error
+ */
+#ifdef LOG_CRON
+#undef LOG_CRON
+#endif
+
+#include "rsyslog.h"
+#include "conf.h"
+#include "syslogd-types.h"
+#include "srUtils.h"
+#include "template.h"
+#include "module-template.h"
+#include "unicode-helper.h"
+#include "errmsg.h"
+#include "cfsysline.h"
+#include "glbl.h"
+#include "prop.h"
+#include "ruleset.h"
+#include "ratelimit.h"
+#include "stringbuf.h"
+
+MODULE_TYPE_INPUT
+MODULE_TYPE_NOKEEP
+MODULE_CNFNAME("improg")
+
+struct instanceConf_s {
+ uchar *pszBinary; /* name of external program to call */
+ char **aParams; /* optional parameters to pass to external program */
+ int iParams; /* holds the count of parameters if set */
+ uchar *pszTag;
+ size_t lenTag;
+ int iFacility;
+ int iSeverity;
+ int bConfirmMessages; /* does the program provide feedback via stdout? */
+ int bSignalOnClose; /* should send SIGTERM to program before closing pipe? */
+ long lCloseTimeout; /* how long to wait for program to terminate after closing pipe (ms) */
+ int bKillUnresponsive; /* should send SIGKILL if closeTimeout is reached? */
+ cstr_t *ppCStr;
+ int bIsRunning; /* is program currently running? 0-no, 1-yes */
+ pid_t pid; /* pid of currently running child process */
+ int fdPipeToChild; /* fd for sending data to the program */
+ int fdPipeFromChild; /* fd for receiving messages from the program, or -1 */
+ uchar *pszBindRuleset;
+ ruleset_t *pBindRuleset; /* ruleset to bind listener to (use system default if unspecified) */
+ ratelimit_t *ratelimiter;
+ struct instanceConf_s *next;
+ struct instanceConf_s *prev;
+};
+
+/* config variables */
+struct modConfData_s {
+ rsconf_t *pConf; /* our overall config object */
+
+};
+
+/* internal structures
+ */
+DEF_OMOD_STATIC_DATA
+DEFobjCurrIf(glbl)
+DEFobjCurrIf(prop)
+DEFobjCurrIf(ruleset)
+
+static prop_t *pInputName = NULL;
+
+#define NO_HUP_FORWARD -1 /* indicates that HUP should NOT be forwarded */
+#define DEFAULT_CONFIRM_TIMEOUT_MS 10000
+#define DEFAULT_CLOSE_TIMEOUT_MS 5000
+#define RESPONSE_LINE_BUFFER_SIZE 4096
+#define OUTPUT_CAPTURE_BUFFER_SIZE 4096
+#define MAX_FD_TO_CLOSE 65535
+
+static instanceConf_t *confRoot = NULL;
+static fd_set rfds;
+static int nfds = 0;
+
+extern char **environ; /* POSIX environment ptr, by std not in a header... (see man 7 environ) */
+
+static inline void
+std_checkRuleset_genErrMsg(__attribute__((unused)) modConfData_t *modConf, instanceConf_t *pInst)
+{
+ LogError(0, NO_ERRCODE, "improg: ruleset '%s' for binary %s not found - "
+ "using default ruleset instead", pInst->pszBindRuleset,
+ pInst->pszBinary);
+}
+
+#include "im-helper.h" /* must be included AFTER the type definitions! */
+
+/* tables for interfacing with the v6 config system */
+/* action (instance) parameters */
+static struct cnfparamdescr inppdescr[] = {
+ { "binary", eCmdHdlrString, CNFPARAM_REQUIRED },
+ { "tag", eCmdHdlrString, CNFPARAM_REQUIRED },
+ { "severity", eCmdHdlrSeverity, 0 },
+ { "facility", eCmdHdlrFacility, 0 },
+ { "ruleset", eCmdHdlrString, 0 },
+ { "confirmmessages", eCmdHdlrBinary, 0 },
+ { "signalonclose", eCmdHdlrBinary, 0 },
+ { "closetimeout", eCmdHdlrInt, 0 },
+ { "killunresponsive", eCmdHdlrBinary, 0 }
+};
+static struct cnfparamblk inppblk =
+ { CNFPARAMBLK_VERSION,
+ sizeof(inppdescr)/sizeof(struct cnfparamdescr),
+ inppdescr
+ };
+
+/* execute the external program (must be called in child context after fork).
+ */
+static __attribute__((noreturn)) void execBinary(const instanceConf_t *pInst, int pipeToParent, int pipeFromParent)
+{
+ int maxFd, fd, sigNum;
+ struct sigaction sigAct;
+ sigset_t sigSet;
+ char errStr[1024];
+
+ if(dup2(pipeToParent, STDOUT_FILENO) == -1) {
+ goto failed;
+ }
+
+ if(pipeFromParent != -1) {
+ if(dup2(pipeFromParent, STDIN_FILENO) == -1) {
+ goto failed;
+ }
+ }
+
+ /* close the file handles the child process doesn't need (all above STDERR).
+ * The following way is simple and portable, though not perfect.
+ * See https://stackoverflow.com/a/918469 for alternatives.
+ */
+ maxFd = sysconf(_SC_OPEN_MAX);
+ if(maxFd < 0 || maxFd > MAX_FD_TO_CLOSE) {
+ maxFd = MAX_FD_TO_CLOSE;
+ }
+ # ifdef VALGRIND
+ else {
+ maxFd -= 10;
+ }
+ # endif
+ for(fd = STDERR_FILENO + 1 ; fd <= maxFd ; ++fd) {
+ close(fd);
+ }
+
+ /* reset signal handlers to default */
+ memset(&sigAct, 0, sizeof(sigAct));
+ sigemptyset(&sigAct.sa_mask);
+ sigAct.sa_handler = SIG_DFL;
+ for(sigNum = 1 ; sigNum < NSIG ; ++sigNum) {
+ sigaction(sigNum, &sigAct, NULL);
+ }
+
+ /* we need to block SIGINT, otherwise our program is cancelled when we are
+ * stopped in debug mode.
+ */
+ sigAct.sa_handler = SIG_IGN;
+ sigaction(SIGINT, &sigAct, NULL);
+ sigemptyset(&sigSet);
+ sigprocmask(SIG_SETMASK, &sigSet, NULL);
+
+ alarm(0);
+
+ /* finally exec program */
+ execve((char*)pInst->pszBinary, pInst->aParams, environ);
+
+failed:
+ /* an error occurred: log it and exit the child process. We use the
+ * 'syslog' system call to log the error (we cannot use LogMsg/LogError,
+ * since these functions add directly to the rsyslog input queue).
+ */
+ rs_strerror_r(errno, errStr, sizeof(errStr));
+ DBGPRINTF("improg: failed to execute program '%s': %s\n",
+ pInst->pszBinary, errStr);
+ openlog("rsyslogd", 0, LOG_SYSLOG);
+ syslog(LOG_ERR, "improg: failed to execute program '%s': %s\n",
+ pInst->pszBinary, errStr);
+ /* let's print the error to stderr for test bench purposes */
+ fprintf(stderr, "improg: failed to execute program '%s': %s\n",
+ pInst->pszBinary, errStr);
+ exit(1);
+}
+
+/* creates a pipe and starts program, uses pipe as stdin for program.
+ * rgerhards, 2009-04-01
+ */
+static rsRetVal openPipe(instanceConf_t *pInst)
+{
+ int pipeFromChild[2] = { -1, -1 };
+ int pipeToChild[2] = { -1, -1 };
+ pid_t cpid;
+ DEFiRet;
+
+ /* if the 'confirmMessages' setting is enabled, open a pipe to send
+ message confirmations to the program */
+ if(pInst->bConfirmMessages && pipe(pipeToChild) == -1) {
+ ABORT_FINALIZE(RS_RET_ERR_CREAT_PIPE);
+ }
+
+ /* open a pipe to receive messages to the program */
+ if(pipe(pipeFromChild) == -1) {
+ ABORT_FINALIZE(RS_RET_ERR_CREAT_PIPE);
+ }
+
+ DBGPRINTF("improg: executing program '%s' with '%d' parameters\n",
+ pInst->pszBinary, pInst->iParams);
+
+ cpid = fork();
+ if(cpid == -1) {
+ ABORT_FINALIZE(RS_RET_ERR_FORK);
+ }
+
+ if(cpid == 0) { /* we are now the child process: execute the program */
+ /* close the pipe ends that the child doesn't need */
+ close(pipeFromChild[0]);
+ if(pipeToChild[1] != -1) {
+ close(pipeToChild[1]);
+ }
+
+ execBinary(pInst, pipeFromChild[1], pipeToChild[0]);
+ /* NO CODE HERE - WILL NEVER BE REACHED! */
+ }
+
+ DBGPRINTF("improg: child has pid %ld\n", (long int) cpid);
+
+ /* close the pipe ends that the parent doesn't need */
+ close(pipeFromChild[1]);
+ if(pipeToChild[0] != -1) {
+ close(pipeToChild[0]);
+ }
+
+ pInst->fdPipeToChild = pipeToChild[1]; /* we'll send messages confirmations to the program via this fd */
+ pInst->fdPipeFromChild = pipeFromChild[0]; /* we'll receive message via this fd */
+
+ FD_SET(pInst->fdPipeFromChild, &rfds); /* manage select read fd set */
+ nfds = (nfds > pInst->fdPipeFromChild) ? nfds : pInst->fdPipeFromChild+1;
+
+ pInst->pid = cpid;
+ pInst->bIsRunning = 1;
+
+finalize_it:
+ if(iRet != RS_RET_OK) {
+ if(pipeFromChild[0] != -1) {
+ close(pipeFromChild[0]);
+ close(pipeFromChild[1]);
+ }
+ if(pipeToChild[0] != -1) {
+ close(pipeToChild[0]);
+ close(pipeToChild[1]);
+ }
+ }
+ RETiRet;
+}
+
+static void waitForChild(instanceConf_t *pInst)
+{
+ int status;
+ int ret;
+ long counter;
+
+ counter = pInst->lCloseTimeout / 10;
+ while ((ret = waitpid(pInst->pid, &status, WNOHANG)) == 0 && counter > 0) {
+ srSleep(0, 10000); /* 0 seconds, 10 milliseconds */
+ --counter;
+ }
+
+ if (ret == 0) { /* timeout reached */
+ if (!pInst->bKillUnresponsive) {
+ LogMsg(0, NO_ERRCODE, LOG_WARNING, "improg: program '%s' (pid %ld) did not terminate "
+ "within timeout (%ld ms); ignoring it", pInst->pszBinary, (long int)pInst->pid,
+ pInst->lCloseTimeout);
+ return;
+ }
+
+ LogMsg(0, NO_ERRCODE, LOG_WARNING, "improg: program '%s' (pid %ld) did not terminate "
+ "within timeout (%ld ms); killing it", pInst->pszBinary, (long int)pInst->pid,
+ pInst->lCloseTimeout);
+ if (kill(pInst->pid, SIGKILL) == -1) {
+ LogError(errno, RS_RET_SYS_ERR, "improg: could not send SIGKILL to child process");
+ return;
+ }
+
+ ret = waitpid(pInst->pid, &status, 0);
+ }
+
+ /* waitpid will fail with errno == ECHILD if the child process has already
+ been reaped by the rsyslogd main loop (see rsyslogd.c) */
+ if(ret == pInst->pid) {
+ glblReportChildProcessExit(runConf, pInst->pszBinary, pInst->pid, status);
+ }
+}
+
+/* Send SIGTERM to child process if configured to do so, close pipe
+ * and wait for child to terminate.
+ */
+static void terminateChild(instanceConf_t *pInst)
+{
+ if(pInst->bIsRunning) {
+
+ if(pInst->fdPipeFromChild != -1) {
+ close(pInst->fdPipeFromChild);
+ FD_CLR(pInst->fdPipeFromChild, &rfds);
+ pInst->fdPipeFromChild = -1;
+
+ }
+
+ if(pInst->fdPipeToChild != -1) {
+ close(pInst->fdPipeToChild);
+ pInst->fdPipeToChild = -1;
+ }
+
+ /* wait for the child AFTER closing the pipe, so it receives EOF */
+ waitForChild(pInst);
+
+ pInst->bIsRunning = 0;
+ }
+}
+
+static rsRetVal startChild(instanceConf_t *pInst)
+{
+ DEFiRet;
+
+ if (!pInst->bIsRunning)
+
+ CHKiRet(openPipe(pInst));
+
+finalize_it:
+ if(iRet != RS_RET_OK && pInst->bIsRunning) {
+ /* if initialization has failed, terminate program */
+ terminateChild(pInst);
+ }
+ RETiRet;
+}
+
+static rsRetVal enqLine(instanceConf_t *const __restrict__ pInst)
+{
+ DEFiRet;
+ smsg_t *pMsg;
+
+ if(cstrLen(pInst->ppCStr) == 0) {
+ /* we do not process empty lines */
+ FINALIZE;
+ }
+
+ CHKiRet(msgConstruct(&pMsg));
+
+ MsgSetMSGoffs(pMsg, 0);
+ MsgSetHOSTNAME(pMsg, glbl.GetLocalHostName(), ustrlen(glbl.GetLocalHostName()));
+ MsgSetFlowControlType(pMsg, eFLOWCTL_FULL_DELAY);
+ MsgSetInputName(pMsg, pInputName);
+ MsgSetAPPNAME(pMsg, (const char*)pInst->pszTag);
+ MsgSetTAG(pMsg, pInst->pszTag, pInst->lenTag);
+ msgSetPRI(pMsg, pInst->iFacility | pInst->iSeverity);
+ MsgSetRawMsg(pMsg, (const char*)rsCStrGetBufBeg(pInst->ppCStr), cstrLen(pInst->ppCStr));
+ MsgSetRuleset(pMsg, pInst->pBindRuleset);
+
+ ratelimitAddMsg(pInst->ratelimiter, NULL, pMsg);
+finalize_it:
+ RETiRet;
+}
+
+/* read line(s) from the external program and sent them when they are complete */
+static rsRetVal readChild(instanceConf_t *const pInst){
+ char c;
+ int retval;
+
+ while ((retval = read(pInst->fdPipeFromChild, &c, 1)) == 1) {
+ if (c=='\n'){
+ enqLine(pInst);
+ /* if confirm required then send an ACK to the program */
+ if (pInst->bConfirmMessages) {
+ if (write(pInst->fdPipeToChild,"ACK\n",sizeof("ACK\n")-1) <= 0)
+ LogMsg(0, NO_ERRCODE, LOG_WARNING, "improg: pipe to child seems to be closed.");
+ }
+ rsCStrTruncate(pInst->ppCStr, rsCStrLen(pInst->ppCStr));
+ } else {
+ cstrAppendChar(pInst->ppCStr, c);
+ }
+ }
+ return (retval == 0) ? RS_RET_OK : RS_RET_IO_ERROR;
+}
+
+/* create input instance, set default parameters, and
+ * add it to the list of instances.
+ */
+static rsRetVal ATTR_NONNULL(1) createInstance(instanceConf_t **const ppInst)
+{
+ instanceConf_t *pInst;
+ DEFiRet;
+ CHKmalloc(pInst = malloc(sizeof(instanceConf_t)));
+ pInst->next = NULL;
+ pInst->pszBindRuleset = NULL;
+ pInst->pBindRuleset = NULL;
+ pInst->ratelimiter = NULL;
+ pInst->iSeverity = 5;
+ pInst->iFacility = 128;
+
+ pInst->pszTag = NULL;
+ pInst->lenTag = 0;
+
+ pInst->bIsRunning = 0;
+ pInst->pid = -1;
+ pInst->fdPipeToChild = -1;
+ pInst->fdPipeFromChild = -1;
+
+ pInst->pszBinary = NULL;
+ pInst->aParams = NULL;
+ pInst->iParams = 0;
+
+ pInst->bConfirmMessages = 1;
+ pInst->bSignalOnClose = 0;
+ pInst->lCloseTimeout = 200;
+ pInst->bKillUnresponsive = 1;
+
+ *ppInst = pInst;
+finalize_it:
+ RETiRet;
+}
+
+/* This adds a new listener object to the bottom of the list, but
+ * it does NOT initialize any data members except for the list
+ * pointers themselves.
+ */
+static rsRetVal ATTR_NONNULL() lstnAdd(instanceConf_t *pInst)
+{
+ DEFiRet;
+ CHKiRet(ratelimitNew(&pInst->ratelimiter, "improg", (char*)pInst->pszBinary));
+
+ /* insert it at the begin of the list */
+ pInst->prev = NULL;
+ pInst->next = confRoot;
+
+ if (confRoot != NULL)
+ confRoot->prev = pInst;
+
+ confRoot = pInst;
+
+finalize_it:
+ RETiRet;
+}
+
+/* delete a listener object */
+static void ATTR_NONNULL(1) lstnFree(instanceConf_t *pInst)
+{
+ DBGPRINTF("lstnFree called for %s\n", pInst->pszBinary);
+ if (pInst->ratelimiter != NULL)
+ ratelimitDestruct(pInst->ratelimiter);
+ if(pInst->pszBinary != NULL)
+ free(pInst->pszBinary);
+ if (pInst->pszTag)
+ free(pInst->pszTag);
+ if (pInst->pszBindRuleset != NULL)
+ free(pInst->pszBindRuleset);
+ if (pInst->aParams) {
+ int i;
+ for (i = 0;pInst->aParams[i]; i++)
+ free(pInst->aParams[i]);
+ free(pInst->aParams);
+ }
+ if (pInst->ppCStr)
+ rsCStrDestruct(&pInst->ppCStr);
+ free(pInst);
+}
+
+/* read */
+BEGINnewInpInst
+ struct cnfparamvals *pvals;
+ instanceConf_t *pInst = NULL;
+ int i;
+CODESTARTnewInpInst
+ DBGPRINTF("newInpInst (improg)\n");
+
+ pvals = nvlstGetParams(lst, &inppblk, NULL);
+ if(pvals == NULL) {
+ ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS);
+ }
+
+ if(Debug) {
+ DBGPRINTF("input param blk in improg:\n");
+ cnfparamsPrint(&inppblk, pvals);
+ }
+
+ CHKiRet(createInstance(&pInst));
+
+ for(i = 0 ; i < inppblk.nParams ; ++i) {
+ if(!pvals[i].bUsed)
+ continue;
+ if(!strcmp(inppblk.descr[i].name, "binary")) {
+ CHKiRet(split_binary_parameters(&pInst->pszBinary, &pInst->aParams, &pInst->iParams,
+ pvals[i].val.d.estr));
+ } else if(!strcmp(inppblk.descr[i].name, "tag")) {
+ pInst->pszTag = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL);
+ pInst->lenTag = es_strlen(pvals[i].val.d.estr);
+ } else if(!strcmp(inppblk.descr[i].name, "ruleset")) {
+ pInst->pszBindRuleset = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL);
+ } else if(!strcmp(inppblk.descr[i].name, "severity")) {
+ pInst->iSeverity = pvals[i].val.d.n;
+ } else if(!strcmp(inppblk.descr[i].name, "facility")) {
+ pInst->iFacility = pvals[i].val.d.n;
+ } else if(!strcmp(inppblk.descr[i].name, "confirmmessages")) {
+ pInst->bConfirmMessages = pvals[i].val.d.n;
+ } else if(!strcmp(inppblk.descr[i].name, "signalonclose")) {
+ pInst->bSignalOnClose = pvals[i].val.d.n;
+ } else if(!strcmp(inppblk.descr[i].name, "closetimeout")) {
+ pInst->lCloseTimeout = pvals[i].val.d.n;
+ } else if(!strcmp(inppblk.descr[i].name, "killunresponsive")) {
+ pInst->bKillUnresponsive = pvals[i].val.d.n;
+ } else {
+ DBGPRINTF("program error, non-handled "
+ "param '%s'\n", inppblk.descr[i].name);
+ }
+ }
+ if(pInst->pszBinary == NULL) {
+ LogError(0, RS_RET_FILE_NOT_SPECIFIED,
+ "ulogbase is not configured - no input will be gathered");
+ ABORT_FINALIZE(RS_RET_FILE_NOT_SPECIFIED);
+ }
+
+ CHKiRet(cstrConstruct(&pInst->ppCStr));
+
+ if ((iRet = lstnAdd(pInst)) != RS_RET_OK) {
+ ABORT_FINALIZE(iRet);
+ }
+
+finalize_it:
+CODE_STD_FINALIZERnewInpInst
+ if (pInst && iRet != RS_RET_OK)
+ lstnFree(pInst);
+ cnfparamvalsDestruct(pvals, &inppblk);
+ENDnewInpInst
+
+BEGINwillRun
+CODESTARTwillRun
+ /* we need to create the inputName property (only once during our lifetime) */
+ CHKiRet(prop.Construct(&pInputName));
+ CHKiRet(prop.SetString(pInputName, UCHAR_CONSTANT("improg"), sizeof("improg") - 1));
+ CHKiRet(prop.ConstructFinalize(pInputName));
+finalize_it:
+ENDwillRun
+
+BEGINrunInput
+ struct timeval tv;
+ int retval;
+ instanceConf_t *pInst;
+CODESTARTrunInput
+ FD_ZERO(&rfds);
+
+ for(pInst = confRoot ; pInst != NULL ; pInst = pInst->next) {
+ startChild(pInst);
+ }
+
+ for(pInst = confRoot ; pInst != NULL ; pInst = pInst->next) {
+ if (pInst->bIsRunning && pInst->fdPipeToChild > 0){
+ if (write(pInst->fdPipeToChild, "START\n", sizeof("START\n")-1) <= 0)
+ LogMsg(0, NO_ERRCODE, LOG_WARNING, "improg: pipe to child seems to be closed.");
+ DBGPRINTF("Sending START to %s\n", pInst->pszBinary);
+ }
+ }
+
+ /* main module loop */
+ tv.tv_usec = 1000;
+ while (glbl.GetGlobalInputTermState() == 0)
+ {
+ fd_set temp;
+ memcpy(&temp, &rfds, sizeof(fd_set));
+ tv.tv_sec = 0;
+
+ /* wait for external data or 0.1 second */
+ retval = select(nfds, &temp, NULL, NULL, &tv);
+
+ /* retval is the number of fd with data to read */
+ while (retval>0) {
+ for (pInst = confRoot; pInst != NULL; pInst = pInst->next) {
+ if (FD_ISSET(pInst->fdPipeFromChild, &temp)) {
+ DBGPRINTF("read child %s\n",pInst->pszBinary);
+ readChild(pInst);
+ retval--;
+ }
+ }
+ }
+ tv.tv_usec = 100000;
+ }
+ DBGPRINTF("terminating upon request of rsyslog core\n");
+ENDrunInput
+
+/* This function is called by the framework after runInput() has been terminated. It
+ * shall free any resources and prepare the module for unload.
+ * CODEqueryEtryPt_STD_IMOD_QUERIES
+ */
+BEGINafterRun
+CODESTARTafterRun
+ instanceConf_t *pInst = confRoot, *nextInst;
+ confRoot = NULL;
+
+ DBGPRINTF("afterRun\n");
+
+ while(pInst != NULL) {
+ nextInst = pInst->next;
+
+ if (pInst->bIsRunning) {
+ if (pInst->bSignalOnClose) {
+ kill(pInst->pid, SIGTERM);
+ LogMsg(0, NO_ERRCODE, LOG_INFO, "%s SIGTERM signaled.", pInst->aParams[0]);
+ }
+ if (pInst->fdPipeToChild > 0){
+ if (write(pInst->fdPipeToChild, "STOP\n", strlen("STOP\n")) <= 0 &&
+ !pInst->bSignalOnClose)
+ LogMsg(0, NO_ERRCODE, LOG_WARNING,
+ "improg: pipe to child seems to be closed.");
+ }
+ terminateChild(pInst);
+ }
+
+ lstnFree(pInst);
+
+ pInst = nextInst;
+ }
+
+ if(pInputName != NULL)
+ prop.Destruct(&pInputName);
+ENDafterRun
+
+BEGINisCompatibleWithFeature
+CODESTARTisCompatibleWithFeature
+ if(eFeat == sFEATURERepeatedMsgReduction) {
+ iRet = RS_RET_OK;
+ }
+ENDisCompatibleWithFeature
+
+BEGINbeginCnfLoad
+CODESTARTbeginCnfLoad
+ pModConf->pConf = pConf;
+ENDbeginCnfLoad
+
+BEGINendCnfLoad
+CODESTARTendCnfLoad
+ENDendCnfLoad
+
+BEGINcheckCnf
+instanceConf_t *pInst;
+CODESTARTcheckCnf
+ for(pInst = confRoot ; pInst != NULL ; pInst = pInst->next) {
+ std_checkRuleset(pModConf , pInst);
+ }
+ENDcheckCnf
+
+BEGINactivateCnf
+CODESTARTactivateCnf
+ENDactivateCnf
+
+BEGINfreeCnf
+CODESTARTfreeCnf
+ENDfreeCnf
+
+
+BEGINmodExit
+CODESTARTmodExit
+ objRelease(ruleset, CORE_COMPONENT);
+ objRelease(glbl, CORE_COMPONENT);
+ objRelease(prop, CORE_COMPONENT);
+ENDmodExit
+
+BEGINqueryEtryPt
+CODESTARTqueryEtryPt
+CODEqueryEtryPt_STD_IMOD_QUERIES
+CODEqueryEtryPt_STD_CONF2_QUERIES
+CODEqueryEtryPt_STD_CONF2_IMOD_QUERIES
+CODEqueryEtryPt_IsCompatibleWithFeature_IF_OMOD_QUERIES
+ENDqueryEtryPt
+
+BEGINmodInit()
+CODESTARTmodInit
+ *ipIFVersProvided = CURR_MOD_IF_VERSION; /* we only support the current interface specification */
+CODEmodInit_QueryRegCFSLineHdlr
+ CHKiRet(objUse(ruleset, CORE_COMPONENT));
+ CHKiRet(objUse(glbl, CORE_COMPONENT));
+ CHKiRet(objUse(prop, CORE_COMPONENT));
+ENDmodInit
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-21 01:21:14 +0000