summaryrefslogtreecommitdiffstats
path: root/plugins/mmexternal/mmexternal.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--plugins/mmexternal/mmexternal.c611
1 files changed, 611 insertions, 0 deletions
diff --git a/plugins/mmexternal/mmexternal.c b/plugins/mmexternal/mmexternal.c
new file mode 100644
index 0000000..317420a
--- /dev/null
+++ b/plugins/mmexternal/mmexternal.c
@@ -0,0 +1,611 @@
+/* mmexternal.c
+ * This core plugin is an interface module to message modification
+ * modules written in languages other than C.
+ *
+ * Copyright 2014-2018 by Rainer Gerhards
+ *
+ * This file is part 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 <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/wait.h>
+#include <sys/uio.h>
+#include "rsyslog.h"
+#include "conf.h"
+#include "syslogd-types.h"
+#include "srUtils.h"
+#include "module-template.h"
+#include "msg.h"
+#include "errmsg.h"
+#include "cfsysline.h"
+#include "glbl.h"
+#include "rsconf.h"
+
+
+MODULE_TYPE_OUTPUT
+MODULE_TYPE_NOKEEP
+MODULE_CNFNAME("mmexternal")
+
+/* internal structures
+ */
+DEF_OMOD_STATIC_DATA
+
+typedef struct _instanceData {
+ uchar *szBinary; /* name of binary to call */
+ char **aParams; /* Optional Parameters for binary command */
+ int iParams; /* Holds the count of parameters if set*/
+ int bForceSingleInst; /* only a single wrkr instance of program permitted? */
+ int inputProp; /* what to provide as input to the external program? */
+#define INPUT_MSG 0
+#define INPUT_RAWMSG 1
+#define INPUT_JSON 2
+ uchar *outputFileName; /* name of file for std[out/err] or NULL if to discard */
+ pthread_mutex_t mut; /* make sure only one instance is active */
+} instanceData;
+
+typedef struct wrkrInstanceData {
+ instanceData *pData;
+ pid_t pid; /* pid of currently running process */
+ int fdOutput; /* it's fd (-1 if closed) */
+ int fdPipeOut; /* file descriptor to write to */
+ int fdPipeIn; /* fd we receive messages from the program (if we want to) */
+ int bIsRunning; /* is binary currently running? 0-no, 1-yes */
+ char *respBuf; /* buffer to read exernal plugin's response */
+ int maxLenRespBuf; /* (current) maximum length of response buffer */
+ int lenRespBuf; /* actual nbr of chars in response buffer */
+ int idxRespBuf; /* last char read from response buffer */
+} wrkrInstanceData_t;
+
+typedef struct configSettings_s {
+ uchar *szBinary; /* name of binary to call */
+} configSettings_t;
+static configSettings_t cs;
+
+
+/* tables for interfacing with the v6 config system */
+/* action (instance) parameters */
+static struct cnfparamdescr actpdescr[] = {
+ { "binary", eCmdHdlrString, CNFPARAM_REQUIRED },
+ { "interface.input", eCmdHdlrString, 0 },
+ { "output", eCmdHdlrString, 0 },
+ { "forcesingleinstance", eCmdHdlrBinary, 0 }
+};
+static struct cnfparamblk actpblk =
+ { CNFPARAMBLK_VERSION,
+ sizeof(actpdescr)/sizeof(struct cnfparamdescr),
+ actpdescr
+ };
+
+BEGINinitConfVars /* (re)set config variables to default values */
+CODESTARTinitConfVars
+ cs.szBinary = NULL; /* name of binary to call */
+ENDinitConfVars
+
+/* config settings */
+
+BEGINcreateInstance
+CODESTARTcreateInstance
+ pData->inputProp = INPUT_MSG;
+ pthread_mutex_init(&pData->mut, NULL);
+ENDcreateInstance
+
+BEGINcreateWrkrInstance
+CODESTARTcreateWrkrInstance
+ pWrkrData->fdPipeIn = -1;
+ pWrkrData->fdPipeOut = -1;
+ pWrkrData->fdOutput = -1;
+ pWrkrData->bIsRunning = 0;
+ pWrkrData->respBuf = NULL;
+ pWrkrData->maxLenRespBuf = 0;
+ pWrkrData->lenRespBuf = 0;
+ pWrkrData->idxRespBuf = 0;
+ENDcreateWrkrInstance
+
+
+BEGINisCompatibleWithFeature
+CODESTARTisCompatibleWithFeature
+ if(eFeat == sFEATURERepeatedMsgReduction)
+ iRet = RS_RET_OK;
+ENDisCompatibleWithFeature
+
+
+BEGINfreeInstance
+ int i;
+CODESTARTfreeInstance
+ pthread_mutex_destroy(&pData->mut);
+ free(pData->szBinary);
+ free(pData->outputFileName);
+ if(pData->aParams != NULL) {
+ for (i = 0; i < pData->iParams; i++) {
+ free(pData->aParams[i]);
+ }
+ free(pData->aParams);
+ }
+ENDfreeInstance
+
+BEGINfreeWrkrInstance
+CODESTARTfreeWrkrInstance
+ free(pWrkrData->respBuf);
+ENDfreeWrkrInstance
+
+
+BEGINdbgPrintInstInfo
+CODESTARTdbgPrintInstInfo
+ENDdbgPrintInstInfo
+
+
+BEGINtryResume
+CODESTARTtryResume
+ENDtryResume
+
+
+/* As this is just a debug function, we only make
+ * best effort to write the message but do *not* try very
+ * hard to handle errors. -- rgerhards, 2014-01-16
+ */
+static void
+writeOutputDebug(wrkrInstanceData_t *__restrict__ const pWrkrData,
+ const char *__restrict__ const buf,
+ const ssize_t lenBuf)
+{
+ char errStr[1024];
+ ssize_t r;
+
+ if(pWrkrData->pData->outputFileName == NULL)
+ goto done;
+
+ if(pWrkrData->fdOutput == -1) {
+ pWrkrData->fdOutput = open((char*)pWrkrData->pData->outputFileName,
+ O_WRONLY | O_APPEND | O_CREAT, 0600);
+ if(pWrkrData->fdOutput == -1) {
+ DBGPRINTF("mmexternal: error opening output file %s: %s\n",
+ pWrkrData->pData->outputFileName,
+ rs_strerror_r(errno, errStr, sizeof(errStr)));
+ goto done;
+ }
+ }
+
+ r = write(pWrkrData->fdOutput, buf, (size_t) lenBuf);
+ if(r != lenBuf) {
+ DBGPRINTF("mmexternal: problem writing output file %s: bytes "
+ "requested %lld, written %lld, msg: %s\n",
+ pWrkrData->pData->outputFileName, (long long) lenBuf, (long long) r,
+ rs_strerror_r(errno, errStr, sizeof(errStr)));
+ }
+done: return;
+}
+
+
+/* Get reply from external program. Note that we *must* receive one
+ * reply for each message sent (half-duplex protocol). As such, the last
+ * char we read MUST be \n ... we cannot have multiple LF as this is
+ * forbidden by the plugin interface. We cannot have multiple responses
+ * for multiple messages, as we are in half-duplex mode! This makes
+ * things quite a bit simpler. So don't think the simple code does
+ * not handle those border-cases that are describe to cannot exist!
+ */
+static void
+processProgramReply(wrkrInstanceData_t *__restrict__ const pWrkrData, smsg_t *const pMsg)
+{
+ rsRetVal iRet;
+ char errStr[1024];
+ ssize_t r;
+ int numCharsRead;
+ char *newptr;
+
+ numCharsRead = 0;
+ do {
+ if(pWrkrData->maxLenRespBuf < numCharsRead + 256) { /* 256 to permit at least a decent read */
+ pWrkrData->maxLenRespBuf += 4096;
+ if((newptr = realloc(pWrkrData->respBuf, pWrkrData->maxLenRespBuf)) == NULL) {
+ DBGPRINTF("mmexternal: error realloc responseBuf: %s\n",
+ rs_strerror_r(errno, errStr, sizeof(errStr)));
+ /* emergency - fake no update */
+ strcpy(pWrkrData->respBuf, "{}\n");
+ numCharsRead = 3;
+ break;
+ }
+ pWrkrData->respBuf = newptr;
+ }
+ r = read(pWrkrData->fdPipeIn, pWrkrData->respBuf+numCharsRead,
+ pWrkrData->maxLenRespBuf-numCharsRead-1);
+ if(r > 0) {
+ numCharsRead += r;
+ pWrkrData->respBuf[numCharsRead] = '\0'; /* space reserved in read! */
+ } else {
+ /* emergency - fake no update */
+ strcpy(pWrkrData->respBuf, "{}\n");
+ numCharsRead = 3;
+ }
+ if(Debug && r == -1) {
+ DBGPRINTF("mmexternal: error reading from external program: %s\n",
+ rs_strerror_r(errno, errStr, sizeof(errStr)));
+ }
+ } while(pWrkrData->respBuf[numCharsRead-1] != '\n');
+
+ writeOutputDebug(pWrkrData, pWrkrData->respBuf, numCharsRead);
+ /* strip LF, which is not part of the JSON message but framing */
+ pWrkrData->respBuf[numCharsRead-1] = '\0';
+ iRet = MsgSetPropsViaJSON(pMsg, (uchar*)pWrkrData->respBuf);
+ if(iRet != RS_RET_OK) {
+ LogError(0, iRet, "mmexternal: invalid reply '%s' from program '%s'",
+ pWrkrData->respBuf, pWrkrData->pData->szBinary);
+ }
+
+ return;
+}
+
+
+
+/* execute the child process (must be called in child context
+ * after fork).
+ * Note: all output will go to std[err/out] of the **child**, so
+ * rsyslog will never see it except as script output. Do NOT
+ * use dbgprintf() or LogError() and friends.
+ */
+static void __attribute__((noreturn))
+execBinary(wrkrInstanceData_t *pWrkrData, const int fdStdin, const int fdStdOutErr)
+{
+ int i;
+ struct sigaction sigAct;
+ sigset_t set;
+ char *newenviron[] = { NULL };
+
+ if(dup2(fdStdin, STDIN_FILENO) == -1) {
+ perror("mmexternal: dup() stdin failed\n");
+ }
+ if(dup2(fdStdOutErr, STDOUT_FILENO) == -1) {
+ perror("mmexternal: dup() stdout failed\n");
+ }
+ if(dup2(fdStdOutErr, STDERR_FILENO) == -1) {
+ perror("mmexternal: dup() stderr failed\n");
+ }
+
+ /* we close all file handles as we fork soon
+ * Is there a better way to do this? - mail me! rgerhards@adiscon.com
+ */
+# ifndef VALGRIND /* we can not use this with valgrind - too many errors... */
+ for(i = 3 ; i <= 65535 ; ++i)
+ close(i);
+# endif
+
+ /* reset signal handlers to default */
+ memset(&sigAct, 0, sizeof(sigAct));
+ sigemptyset(&sigAct.sa_mask);
+ sigAct.sa_handler = SIG_DFL;
+ for(i = 1 ; i < NSIG ; ++i)
+ sigaction(i, &sigAct, NULL);
+ /* we need to block SIGINT, otherwise the external program is cancelled when we are
+ * stopped in debug mode.
+ */
+ sigAct.sa_handler = SIG_IGN;
+ sigaction(SIGINT, &sigAct, NULL);
+ sigemptyset(&set);
+ sigprocmask(SIG_SETMASK, &set, NULL);
+
+ alarm(0);
+
+ /* finally exec child */
+ execve((char*)pWrkrData->pData->szBinary, pWrkrData->pData->aParams, newenviron);
+
+ /* we should never reach this point, but if we do, we complain and terminate */
+ char errstr[1024];
+ char errbuf[2048];
+ rs_strerror_r(errno, errstr, sizeof(errstr));
+ errstr[sizeof(errstr)-1] = '\0';
+ const size_t lenbuf = snprintf(errbuf, sizeof(errbuf),
+ "mmexternal: failed to execute binary '%s': %s\n",
+ pWrkrData->pData->szBinary, errstr);
+ errbuf[sizeof(errbuf)-1] = '\0';
+ if(write(2, errbuf, lenbuf) != (ssize_t) lenbuf) {
+ /* just keep static analyzers happy... */
+ exit(2);
+ }
+ exit(1);
+}
+
+
+/* creates a pipe and starts program, uses pipe as stdin for program.
+ * rgerhards, 2009-04-01
+ */
+static rsRetVal
+openPipe(wrkrInstanceData_t *pWrkrData)
+{
+ int pipestdin[2];
+ int pipestdout[2];
+ pid_t cpid;
+ DEFiRet;
+
+ if(pipe(pipestdin) == -1) {
+ ABORT_FINALIZE(RS_RET_ERR_CREAT_PIPE);
+ }
+ if(pipe(pipestdout) == -1) {
+ ABORT_FINALIZE(RS_RET_ERR_CREAT_PIPE);
+ }
+
+ DBGPRINTF("mmexternal: executing program '%s' with '%d' parameters\n",
+ pWrkrData->pData->szBinary, pWrkrData->pData->iParams);
+
+ /* final sanity check */
+ assert(pWrkrData->pData->szBinary != NULL);
+ assert(pWrkrData->pData->aParams != NULL);
+
+ /* NO OUTPUT AFTER FORK! */
+ cpid = fork();
+ if(cpid == -1) {
+ ABORT_FINALIZE(RS_RET_ERR_FORK);
+ }
+ pWrkrData->pid = cpid;
+
+ if(cpid == 0) {
+ /* we are now the child, just exec the binary. */
+ close(pipestdin[1]); /* close those pipe "ports" that */
+ close(pipestdout[0]); /* we don't need */
+ execBinary(pWrkrData, pipestdin[0], pipestdout[1]);
+ /*NO CODE HERE - WILL NEVER BE REACHED!*/
+ }
+
+ DBGPRINTF("mmexternal: child has pid %d\n", (int) cpid);
+ pWrkrData->fdPipeIn = dup(pipestdout[0]);
+ close(pipestdin[0]);
+ close(pipestdout[1]);
+ pWrkrData->pid = cpid;
+ pWrkrData->fdPipeOut = pipestdin[1];
+ pWrkrData->bIsRunning = 1;
+finalize_it:
+ RETiRet;
+}
+
+
+/* clean up after a terminated child
+ */
+static rsRetVal
+cleanup(wrkrInstanceData_t *pWrkrData)
+{
+ int status;
+ int ret;
+ DEFiRet;
+
+ assert(pWrkrData->bIsRunning == 1);
+ ret = waitpid(pWrkrData->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 == pWrkrData->pid) {
+ glblReportChildProcessExit(runConf, pWrkrData->pData->szBinary, pWrkrData->pid, status);
+ }
+
+ if(pWrkrData->fdOutput != -1) {
+ close(pWrkrData->fdOutput);
+ pWrkrData->fdOutput = -1;
+ }
+ if(pWrkrData->fdPipeIn != -1) {
+ close(pWrkrData->fdPipeIn);
+ pWrkrData->fdPipeIn = -1;
+ }
+ if(pWrkrData->fdPipeOut != -1) {
+ close(pWrkrData->fdPipeOut);
+ pWrkrData->fdPipeOut = -1;
+ }
+ pWrkrData->bIsRunning = 0;
+ pWrkrData->bIsRunning = 0;
+ RETiRet;
+}
+
+
+/* try to restart the binary when it has stopped.
+ */
+static rsRetVal
+tryRestart(wrkrInstanceData_t *pWrkrData)
+{
+ DEFiRet;
+ assert(pWrkrData->bIsRunning == 0);
+
+ iRet = openPipe(pWrkrData);
+ RETiRet;
+}
+
+/* write to pipe
+ * note that we do not try to run block-free. If the users fears something
+ * may block (and this not be acceptable), the action should be run on its
+ * own action queue.
+ */
+static rsRetVal
+callExtProg(wrkrInstanceData_t *__restrict__ const pWrkrData, smsg_t *__restrict__ const pMsg)
+{
+ int lenWritten;
+ int lenWrite;
+ int writeOffset;
+ int i_iov;
+ struct iovec iov[2];
+ int bFreeInputstr = 1; /* we must only free if it does not point to msg-obj mem! */
+ const uchar *inputstr = NULL; /* string to be processed by external program */
+ DEFiRet;
+
+ if(pWrkrData->pData->inputProp == INPUT_MSG) {
+ inputstr = getMSG(pMsg);
+ lenWrite = getMSGLen(pMsg);
+ bFreeInputstr = 0;
+ } else if(pWrkrData->pData->inputProp == INPUT_RAWMSG) {
+ getRawMsg(pMsg, (uchar**)&inputstr, &lenWrite);
+ bFreeInputstr = 0;
+ } else {
+ inputstr = msgGetJSONMESG(pMsg);
+ lenWrite = strlen((const char*)inputstr);
+ }
+
+ writeOffset = 0;
+ do {
+ DBGPRINTF("mmexternal: writing to prog (fd %d, offset %d): %s\n",
+ pWrkrData->fdPipeOut, (int) writeOffset, inputstr);
+ i_iov = 0;
+ if(writeOffset < lenWrite) {
+ iov[0].iov_base = (char*)inputstr+writeOffset;
+ iov[0].iov_len = lenWrite - writeOffset;
+ ++i_iov;
+ }
+ iov[i_iov].iov_base = (void*)"\n";
+ iov[i_iov].iov_len = 1;
+ lenWritten = writev(pWrkrData->fdPipeOut, iov, i_iov+1);
+ if(lenWritten == -1) {
+ switch(errno) {
+ case EPIPE:
+ LogMsg(0, RS_RET_ERR_WRITE_PIPE, LOG_WARNING,
+ "mmexternal: program '%s' (pid %ld) terminated; will be restarted",
+ pWrkrData->pData->szBinary, (long) pWrkrData->pid);
+ CHKiRet(cleanup(pWrkrData));
+ CHKiRet(tryRestart(pWrkrData));
+ writeOffset = 0;
+ break;
+ default:
+ LogError(errno, RS_RET_ERR_WRITE_PIPE, "mmexternal: error sending message to program");
+ ABORT_FINALIZE(RS_RET_ERR_WRITE_PIPE);
+ break;
+ }
+ } else {
+ writeOffset += lenWritten;
+ }
+ } while(lenWritten != lenWrite+1);
+
+ processProgramReply(pWrkrData, pMsg);
+
+finalize_it:
+ /* we need to free json input strings, only. All others point to memory
+ * inside the msg object, which is destroyed when the msg is destroyed.
+ */
+ if(bFreeInputstr) {
+ free((void*)inputstr);
+ }
+ RETiRet;
+}
+
+
+BEGINdoAction_NoStrings
+ smsg_t **ppMsg = (smsg_t **) pMsgData;
+ smsg_t *pMsg = ppMsg[0];
+ instanceData *pData;
+CODESTARTdoAction
+ pData = pWrkrData->pData;
+ if(pData->bForceSingleInst)
+ pthread_mutex_lock(&pData->mut);
+ if(pWrkrData->bIsRunning == 0) {
+ openPipe(pWrkrData);
+ }
+
+ iRet = callExtProg(pWrkrData, pMsg);
+
+ if(iRet != RS_RET_OK)
+ iRet = RS_RET_SUSPENDED;
+ if(pData->bForceSingleInst)
+ pthread_mutex_unlock(&pData->mut);
+ENDdoAction
+
+
+static void
+setInstParamDefaults(instanceData *pData)
+{
+ pData->szBinary = NULL;
+ pData->aParams = NULL;
+ pData->outputFileName = NULL;
+ pData->iParams = 0;
+ pData->bForceSingleInst = 0;
+}
+
+
+BEGINnewActInst
+ struct cnfparamvals *pvals;
+ int i;
+ const char *cstr = NULL;
+CODESTARTnewActInst
+ if((pvals = nvlstGetParams(lst, &actpblk, NULL)) == NULL) {
+ ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS);
+ }
+
+ CHKiRet(createInstance(&pData));
+ setInstParamDefaults(pData);
+
+ CODE_STD_STRING_REQUESTnewActInst(1)
+ for(i = 0 ; i < actpblk.nParams ; ++i) {
+ if(!pvals[i].bUsed)
+ continue;
+ if(!strcmp(actpblk.descr[i].name, "binary")) {
+ CHKiRet(split_binary_parameters(&pData->szBinary, &pData->aParams, &pData->iParams,
+ pvals[i].val.d.estr));
+ } else if(!strcmp(actpblk.descr[i].name, "output")) {
+ pData->outputFileName = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL);
+ } else if(!strcmp(actpblk.descr[i].name, "forcesingleinstance")) {
+ pData->bForceSingleInst = (int) pvals[i].val.d.n;
+ } else if(!strcmp(actpblk.descr[i].name, "interface.input")) {
+ cstr = es_str2cstr(pvals[i].val.d.estr, NULL);
+ if(!strcmp(cstr, "msg"))
+ pData->inputProp = INPUT_MSG;
+ else if(!strcmp(cstr, "rawmsg"))
+ pData->inputProp = INPUT_RAWMSG;
+ else if(!strcmp(cstr, "fulljson"))
+ pData->inputProp = INPUT_JSON;
+ else {
+ LogError(0, RS_RET_INVLD_INTERFACE_INPUT,
+ "mmexternal: invalid interface.input parameter '%s'",
+ cstr);
+ ABORT_FINALIZE(RS_RET_INVLD_INTERFACE_INPUT);
+ }
+ } else {
+ DBGPRINTF("mmexternal: program error, non-handled param '%s'\n", actpblk.descr[i].name);
+ }
+ }
+
+ CHKiRet(OMSRsetEntry(*ppOMSR, 0, NULL, OMSR_TPL_AS_MSG));
+ DBGPRINTF("mmexternal: bForceSingleInst %d\n", pData->bForceSingleInst);
+ DBGPRINTF("mmexternal: interface.input '%s', mode %d\n", cstr, pData->inputProp);
+CODE_STD_FINALIZERnewActInst
+ free((void*)cstr);
+ cnfparamvalsDestruct(pvals, &actpblk);
+ENDnewActInst
+
+NO_LEGACY_CONF_parseSelectorAct
+
+
+BEGINmodExit
+CODESTARTmodExit
+ free(cs.szBinary);
+ cs.szBinary = NULL;
+ENDmodExit
+
+
+BEGINqueryEtryPt
+CODESTARTqueryEtryPt
+CODEqueryEtryPt_STD_OMOD_QUERIES
+CODEqueryEtryPt_STD_OMOD8_QUERIES
+CODEqueryEtryPt_STD_CONF2_CNFNAME_QUERIES
+CODEqueryEtryPt_STD_CONF2_OMOD_QUERIES
+ENDqueryEtryPt
+
+BEGINmodInit()
+CODESTARTmodInit
+INITLegCnfVars
+ *ipIFVersProvided = CURR_MOD_IF_VERSION; /* we only support the current interface specification */
+CODEmodInit_QueryRegCFSLineHdlr
+CODEmodInit_QueryRegCFSLineHdlr
+ENDmodInit