diff options
Diffstat (limited to 'tools/omfwd.c')
| -rw-r--r-- | tools/omfwd.c | 1778 |
1 files changed, 1778 insertions, 0 deletions
diff --git a/tools/omfwd.c b/tools/omfwd.c new file mode 100644 index 0000000..d1eeeff --- /dev/null +++ b/tools/omfwd.c @@ -0,0 +1,1778 @@ +/* omfwd.c + * This is the implementation of the build-in forwarding output module. + * + * NOTE: read comments in module-template.h to understand how this file + * works! + * + * Copyright 2007-2021 Adiscon GmbH. + * + * 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 <time.h> +#include <netinet/in.h> +#include <netdb.h> +#include <fnmatch.h> +#include <assert.h> +#include <errno.h> +#include <ctype.h> +#include <unistd.h> +#include <stdint.h> +#include <fcntl.h> +#include <zlib.h> +#include <pthread.h> +#include "rsyslog.h" +#include "syslogd.h" +#include "conf.h" +#include "syslogd-types.h" +#include "srUtils.h" +#include "net.h" +#include "netstrms.h" +#include "netstrm.h" +#include "omfwd.h" +#include "template.h" +#include "msg.h" +#include "tcpclt.h" +#include "cfsysline.h" +#include "module-template.h" +#include "glbl.h" +#include "errmsg.h" +#include "unicode-helper.h" +#include "parserif.h" +#include "ratelimit.h" +#include "statsobj.h" + +MODULE_TYPE_OUTPUT +MODULE_TYPE_NOKEEP +MODULE_CNFNAME("omfwd") + +/* internal structures + */ +DEF_OMOD_STATIC_DATA +DEFobjCurrIf(glbl) +DEFobjCurrIf(net) +DEFobjCurrIf(netstrms) +DEFobjCurrIf(netstrm) +DEFobjCurrIf(tcpclt) +DEFobjCurrIf(statsobj) + + +/* some local constants (just) for better readybility */ +#define IS_FLUSH 1 +#define NO_FLUSH 0 + +typedef struct _instanceData { + uchar *tplName; /* name of assigned template */ + uchar *pszStrmDrvr; + uchar *pszStrmDrvrAuthMode; + uchar *pszStrmDrvrPermitExpiredCerts; + permittedPeers_t *pPermPeers; + int iStrmDrvrMode; + int iStrmDrvrExtendedCertCheck; /* verify also purpose OID in certificate extended field */ + int iStrmDrvrSANPreference; /* ignore CN when any SAN set */ + int iStrmTlsVerifyDepth; /**< Verify Depth for certificate chains */ + const uchar *pszStrmDrvrCAFile; + const uchar *pszStrmDrvrCRLFile; + const uchar *pszStrmDrvrKeyFile; + const uchar *pszStrmDrvrCertFile; + char *target; + char *address; + char *device; + int compressionLevel; /* 0 - no compression, else level for zlib */ + char *port; + int protocol; + char *networkNamespace; + int originalNamespace; + int iRebindInterval; /* rebind interval */ + sbool bKeepAlive; + int iKeepAliveIntvl; + int iKeepAliveProbes; + int iKeepAliveTime; + int iConErrSkip; /* skipping excessive connection errors */ + uchar *gnutlsPriorityString; + int ipfreebind; + +# define FORW_UDP 0 +# define FORW_TCP 1 + /* following fields for UDP-based delivery */ + int bSendToAll; + int iUDPSendDelay; + int UDPSendBuf; + /* following fields for TCP-based delivery */ + TCPFRAMINGMODE tcp_framing; + uchar tcp_framingDelimiter; + int bResendLastOnRecon; /* should the last message be re-sent on a successful reconnect? */ +# define COMPRESS_NEVER 0 +# define COMPRESS_SINGLE_MSG 1 /* old, single-message compression */ + /* all other settings are for stream-compression */ +# define COMPRESS_STREAM_ALWAYS 2 + uint8_t compressionMode; + int errsToReport; /* max number of errors to report (per instance) */ + sbool strmCompFlushOnTxEnd; /* flush stream compression on transaction end? */ + unsigned int ratelimitInterval; + unsigned int ratelimitBurst; + ratelimit_t *ratelimiter; + statsobj_t *stats; /* dynafile, primarily cache stats */ + intctr_t sentBytes; + DEF_ATOMIC_HELPER_MUT64(mut_sentBytes) +} instanceData; + +typedef struct wrkrInstanceData { + instanceData *pData; + netstrms_t *pNS; /* netstream subsystem */ + netstrm_t *pNetstrm; /* our output netstream */ + struct addrinfo *f_addr; + int *pSockArray; /* sockets to use for UDP */ + int bIsConnected; /* are we connected to remote host? 0 - no, 1 - yes, UDP means addr resolved */ + int nXmit; /* number of transmissions since last (re-)bind */ + tcpclt_t *pTCPClt; /* our tcpclt object */ + sbool bzInitDone; /* did we do an init of zstrm already? */ + z_stream zstrm; /* zip stream to use for tcp compression */ + uchar sndBuf[16*1024]; /* this is intensionally fixed -- see no good reason to make configurable */ + unsigned offsSndBuf; /* next free spot in send buffer */ + int errsToReport; /* (remaining) number of errors to report */ +} wrkrInstanceData_t; + +/* config data */ +typedef struct configSettings_s { + uchar *pszTplName; /* name of the default template to use */ + uchar *pszStrmDrvr; /* name of the stream driver to use */ + int iStrmDrvrMode; /* mode for stream driver, driver-dependent (0 mostly means plain tcp) */ + int bResendLastOnRecon; /* should the last message be re-sent on a successful reconnect? */ + uchar *pszStrmDrvrAuthMode; /* authentication mode to use */ + uchar *pszStrmDrvrPermitExpiredCerts; /* control how to handly expired certificates */ + int iTCPRebindInterval; /* support for automatic re-binding (load balancers!). 0 - no rebind */ + int iUDPRebindInterval; /* support for automatic re-binding (load balancers!). 0 - no rebind */ + int bKeepAlive; + int iKeepAliveIntvl; + int iKeepAliveProbes; + int iKeepAliveTime; + int iConErrSkip; + uchar *gnutlsPriorityString; + permittedPeers_t *pPermPeers; +} configSettings_t; +static configSettings_t cs; + +/* tables for interfacing with the v6 config system */ +/* module-global parameters */ +static struct cnfparamdescr modpdescr[] = { + { "template", eCmdHdlrGetWord, 0 }, +}; +static struct cnfparamblk modpblk = + { CNFPARAMBLK_VERSION, + sizeof(modpdescr)/sizeof(struct cnfparamdescr), + modpdescr + }; + +/* action (instance) parameters */ +static struct cnfparamdescr actpdescr[] = { + { "target", eCmdHdlrGetWord, 0 }, + { "address", eCmdHdlrGetWord, 0 }, + { "device", eCmdHdlrGetWord, 0 }, + { "port", eCmdHdlrGetWord, 0 }, + { "protocol", eCmdHdlrGetWord, 0 }, + { "networknamespace", eCmdHdlrGetWord, 0 }, + { "tcp_framing", eCmdHdlrGetWord, 0 }, + { "tcp_framedelimiter", eCmdHdlrInt, 0 }, + { "ziplevel", eCmdHdlrInt, 0 }, + { "compression.mode", eCmdHdlrGetWord, 0 }, + { "compression.stream.flushontxend", eCmdHdlrBinary, 0 }, + { "ipfreebind", eCmdHdlrInt, 0 }, + { "maxerrormessages", eCmdHdlrInt, CNFPARAM_DEPRECATED }, + { "rebindinterval", eCmdHdlrInt, 0 }, + { "keepalive", eCmdHdlrBinary, 0 }, + { "keepalive.probes", eCmdHdlrNonNegInt, 0 }, + { "keepalive.time", eCmdHdlrNonNegInt, 0 }, + { "keepalive.interval", eCmdHdlrNonNegInt, 0 }, + { "conerrskip", eCmdHdlrNonNegInt, 0 }, + { "gnutlsprioritystring", eCmdHdlrString, 0 }, + { "streamdriver", eCmdHdlrGetWord, 0 }, + { "streamdrivermode", eCmdHdlrInt, 0 }, + { "streamdriverauthmode", eCmdHdlrGetWord, 0 }, + { "streamdriverpermittedpeers", eCmdHdlrGetWord, 0 }, + { "streamdriver.permitexpiredcerts", eCmdHdlrGetWord, 0 }, + { "streamdriver.CheckExtendedKeyPurpose", eCmdHdlrBinary, 0 }, + { "streamdriver.PrioritizeSAN", eCmdHdlrBinary, 0 }, + { "streamdriver.TlsVerifyDepth", eCmdHdlrPositiveInt, 0 }, + { "streamdriver.cafile", eCmdHdlrString, 0 }, + { "streamdriver.keyfile", eCmdHdlrString, 0 }, + { "streamdriver.certfile", eCmdHdlrString, 0 }, + { "resendlastmsgonreconnect", eCmdHdlrBinary, 0 }, + { "udp.sendtoall", eCmdHdlrBinary, 0 }, + { "udp.senddelay", eCmdHdlrInt, 0 }, + { "udp.sendbuf", eCmdHdlrSize, 0 }, + { "template", eCmdHdlrGetWord, 0 }, + { "ratelimit.interval", eCmdHdlrInt, 0 }, + { "ratelimit.burst", eCmdHdlrInt, 0 } +}; +static struct cnfparamblk actpblk = + { CNFPARAMBLK_VERSION, + sizeof(actpdescr)/sizeof(struct cnfparamdescr), + actpdescr + }; + +struct modConfData_s { + rsconf_t *pConf; /* our overall config object */ + uchar *tplName; /* default template */ +}; + +static modConfData_t *loadModConf = NULL;/* modConf ptr to use for the current load process */ +static modConfData_t *runModConf = NULL;/* modConf ptr to use for the current exec process */ + + +static rsRetVal initTCP(wrkrInstanceData_t *pWrkrData); + + +BEGINinitConfVars /* (re)set config variables to default values */ +CODESTARTinitConfVars + cs.pszTplName = NULL; /* name of the default template to use */ + cs.pszStrmDrvr = NULL; /* name of the stream driver to use */ + cs.iStrmDrvrMode = 0; /* mode for stream driver, driver-dependent (0 mostly means plain tcp) */ + cs.bResendLastOnRecon = 0; /* should the last message be re-sent on a successful reconnect? */ + cs.pszStrmDrvrAuthMode = NULL; /* authentication mode to use */ + cs.iUDPRebindInterval = 0; /* support for automatic re-binding (load balancers!). 0 - no rebind */ + cs.iTCPRebindInterval = 0; /* support for automatic re-binding (load balancers!). 0 - no rebind */ + cs.pPermPeers = NULL; +ENDinitConfVars + + +static rsRetVal doTryResume(wrkrInstanceData_t *); +static rsRetVal doZipFinish(wrkrInstanceData_t *); + +/* this function gets the default template. It coordinates action between + * old-style and new-style configuration parts. + */ +static uchar* +getDfltTpl(void) +{ + if(loadModConf != NULL && loadModConf->tplName != NULL) + return loadModConf->tplName; + else if(cs.pszTplName == NULL) + return (uchar*)"RSYSLOG_TraditionalForwardFormat"; + else + return cs.pszTplName; +} + + +/* set the default template to be used + * This is a module-global parameter, and as such needs special handling. It needs to + * be coordinated with values set via the v2 config system (rsyslog v6+). What we do + * is we do not permit this directive after the v2 config system has been used to set + * the parameter. + */ +static rsRetVal +setLegacyDfltTpl(void __attribute__((unused)) *pVal, uchar* newVal) +{ + DEFiRet; + + if(loadModConf != NULL && loadModConf->tplName != NULL) { + free(newVal); + LogError(0, RS_RET_ERR, "omfwd default template already set via module " + "global parameter - can no longer be changed"); + ABORT_FINALIZE(RS_RET_ERR); + } + free(cs.pszTplName); + cs.pszTplName = newVal; +finalize_it: + RETiRet; +} + +/* Close the UDP sockets. + * rgerhards, 2009-05-29 + */ +static rsRetVal +closeUDPSockets(wrkrInstanceData_t *pWrkrData) +{ + DEFiRet; + if(pWrkrData->pSockArray != NULL) { + net.closeUDPListenSockets(pWrkrData->pSockArray); + pWrkrData->pSockArray = NULL; + freeaddrinfo(pWrkrData->f_addr); + pWrkrData->f_addr = NULL; + } +pWrkrData->bIsConnected = 0; // TODO: remove this variable altogether + RETiRet; +} + + +/* destruct the TCP helper objects + * This, for example, is needed after something went wrong. + * This function is void because it "can not" fail. + * rgerhards, 2008-06-04 + * Note that we DO NOT discard the current buffer contents + * (if any). This permits us to save data between sessions. In + * the worst case, some duplication occurs, but we do not + * loose data. + */ +static void +DestructTCPInstanceData(wrkrInstanceData_t *pWrkrData) +{ + doZipFinish(pWrkrData); + if(pWrkrData->pNetstrm != NULL) + netstrm.Destruct(&pWrkrData->pNetstrm); + if(pWrkrData->pNS != NULL) + netstrms.Destruct(&pWrkrData->pNS); +} + + +BEGINbeginCnfLoad +CODESTARTbeginCnfLoad + loadModConf = pModConf; + pModConf->pConf = pConf; + pModConf->tplName = NULL; +ENDbeginCnfLoad + +BEGINsetModCnf + int i; +CODESTARTsetModCnf + const struct cnfparamvals *const __restrict__ pvals = nvlstGetParams(lst, &modpblk, NULL); + if(pvals == NULL) { + ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS); + } + + if(Debug) { + dbgprintf("module (global) param blk for omfwd:\n"); + cnfparamsPrint(&modpblk, pvals); + } + + for(i = 0 ; i < modpblk.nParams ; ++i) { + if(!pvals[i].bUsed) + continue; + if(!strcmp(modpblk.descr[i].name, "template")) { + loadModConf->tplName = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + if(cs.pszTplName != NULL) { + LogError(0, RS_RET_DUP_PARAM, "omfwd: warning: default template " + "was already set via legacy directive - may lead to inconsistent " + "results."); + } + } else { + dbgprintf("omfwd: program error, non-handled " + "param '%s' in beginCnfLoad\n", modpblk.descr[i].name); + } + } +finalize_it: + if(pvals != NULL) + cnfparamvalsDestruct(pvals, &modpblk); +ENDsetModCnf + +BEGINendCnfLoad +CODESTARTendCnfLoad + loadModConf = NULL; /* done loading */ + /* free legacy config vars */ + free(cs.pszTplName); + cs.pszTplName = NULL; +ENDendCnfLoad + +BEGINcheckCnf +CODESTARTcheckCnf +ENDcheckCnf + +BEGINactivateCnf +CODESTARTactivateCnf + runModConf = pModConf; +ENDactivateCnf + +BEGINfreeCnf +CODESTARTfreeCnf + free(pModConf->tplName); +ENDfreeCnf + +BEGINcreateInstance +CODESTARTcreateInstance + if(cs.pszStrmDrvr != NULL) + CHKmalloc(pData->pszStrmDrvr = (uchar*)strdup((char*)cs.pszStrmDrvr)); + if(cs.pszStrmDrvrAuthMode != NULL) + CHKmalloc(pData->pszStrmDrvrAuthMode = + (uchar*)strdup((char*)cs.pszStrmDrvrAuthMode)); +finalize_it: +ENDcreateInstance + + +BEGINcreateWrkrInstance +CODESTARTcreateWrkrInstance + dbgprintf("DDDD: createWrkrInstance: pWrkrData %p\n", pWrkrData); + pWrkrData->offsSndBuf = 0; + iRet = initTCP(pWrkrData); +ENDcreateWrkrInstance + + +BEGINisCompatibleWithFeature +CODESTARTisCompatibleWithFeature + if(eFeat == sFEATURERepeatedMsgReduction) + iRet = RS_RET_OK; +ENDisCompatibleWithFeature + + +BEGINfreeInstance +CODESTARTfreeInstance + if(pData->stats != NULL) + statsobj.Destruct(&(pData->stats)); + free(pData->pszStrmDrvr); + free(pData->pszStrmDrvrAuthMode); + free(pData->pszStrmDrvrPermitExpiredCerts); + free(pData->gnutlsPriorityString); + free(pData->port); + free(pData->networkNamespace); + free(pData->target); + free(pData->address); + free(pData->device); + free((void*)pData->pszStrmDrvrCAFile); + free((void*)pData->pszStrmDrvrCRLFile); + free((void*)pData->pszStrmDrvrKeyFile); + free((void*)pData->pszStrmDrvrCertFile); + net.DestructPermittedPeers(&pData->pPermPeers); + if (pData->ratelimiter != NULL){ + ratelimitDestruct(pData->ratelimiter); + pData->ratelimiter = NULL; + } + +ENDfreeInstance + + +BEGINfreeWrkrInstance +CODESTARTfreeWrkrInstance + DestructTCPInstanceData(pWrkrData); + closeUDPSockets(pWrkrData); + + if(pWrkrData->pData->protocol == FORW_TCP) { + tcpclt.Destruct(&pWrkrData->pTCPClt); + } +ENDfreeWrkrInstance + + +BEGINdbgPrintInstInfo +CODESTARTdbgPrintInstInfo + dbgprintf("omfwd\n"); + dbgprintf("\ttarget='%s'\n", pData->target); + dbgprintf("\tratelimit.interval='%u'\n", pData->ratelimitInterval); + dbgprintf("\tratelimit.burst='%u'\n", pData->ratelimitBurst); +ENDdbgPrintInstInfo + + +/* Send a message via UDP + * rgehards, 2007-12-20 + */ +#define UDP_MAX_MSGSIZE 65507 /* limit per RFC definition */ +static rsRetVal UDPSend(wrkrInstanceData_t *__restrict__ const pWrkrData, + uchar *__restrict__ const msg, + size_t len) +{ + DEFiRet; + struct addrinfo *r; + int i; + ssize_t lsent = 0; + sbool bSendSuccess; + sbool reInit = RSFALSE; + int lasterrno = ENOENT; + int lasterr_sock = -1; + + if(pWrkrData->pData->iRebindInterval && (pWrkrData->nXmit++ % pWrkrData->pData->iRebindInterval == 0)) { + dbgprintf("omfwd dropping UDP 'connection' (as configured)\n"); + pWrkrData->nXmit = 1; /* else we have an addtl wrap at 2^31-1 */ + CHKiRet(closeUDPSockets(pWrkrData)); + } + + if(pWrkrData->pSockArray == NULL) { + CHKiRet(doTryResume(pWrkrData)); + } + + if(pWrkrData->pSockArray == NULL) { + FINALIZE; + } + + + if(len > UDP_MAX_MSGSIZE) { + LogError(0, RS_RET_UDP_MSGSIZE_TOO_LARGE, "omfwd/udp: message is %u " + "bytes long, but UDP can send at most %d bytes (by RFC limit) " + "- truncating message", (unsigned) len, UDP_MAX_MSGSIZE); + len = UDP_MAX_MSGSIZE; + } + + /* we need to track if we have success sending to the remote + * peer. Success is indicated by at least one sendto() call + * succeeding. We track this be bSendSuccess. We can not simply + * rely on lsent, as a call might initially work, but a later + * call fails. Then, lsent has the error status, even though + * the sendto() succeeded. -- rgerhards, 2007-06-22 + */ + bSendSuccess = RSFALSE; + for (r = pWrkrData->f_addr; r; r = r->ai_next) { + int runSockArrayLoop = 1; + for (i = 0; runSockArrayLoop && (i < *pWrkrData->pSockArray) ; i++) { + int try_send = 1; + size_t lenThisTry = len; + while(try_send) { + lsent = sendto(pWrkrData->pSockArray[i+1], msg, lenThisTry, 0, + r->ai_addr, r->ai_addrlen); + if (lsent == (ssize_t) lenThisTry) { + bSendSuccess = RSTRUE; + ATOMIC_ADD_uint64(&pWrkrData->pData->sentBytes, + &pWrkrData->pData->mut_sentBytes, lenThisTry); + try_send = 0; + runSockArrayLoop = 0; + } else if(errno == EMSGSIZE) { + const size_t newlen = (lenThisTry > 1024) ? lenThisTry - 1024 : 512; + LogError(0, RS_RET_UDP_MSGSIZE_TOO_LARGE, + "omfwd/udp: send failed due to message being too " + "large for this system. Message size was %u bytes. " + "Truncating to %u bytes and retrying.", + (unsigned) lenThisTry, (unsigned) newlen); + lenThisTry = newlen; + } else { + reInit = RSTRUE; + lasterrno = errno; + lasterr_sock = pWrkrData->pSockArray[i+1]; + LogError(lasterrno, RS_RET_ERR_UDPSEND, + "omfwd/udp: socket %d: sendto() error", + lasterr_sock); + try_send = 0; + } + } + } + if (lsent == (ssize_t) len && !pWrkrData->pData->bSendToAll) + break; + } + + /* one or more send failures; close sockets and re-init */ + if (reInit == RSTRUE) { + CHKiRet(closeUDPSockets(pWrkrData)); + } + + /* finished looping */ + if(bSendSuccess == RSTRUE) { + if(pWrkrData->pData->iUDPSendDelay > 0) { + srSleep(pWrkrData->pData->iUDPSendDelay / 1000000, + pWrkrData->pData->iUDPSendDelay % 1000000); + } + } else { + LogError(lasterrno, RS_RET_ERR_UDPSEND, + "omfwd: socket %d: error %d sending via udp", lasterr_sock, lasterrno); + iRet = RS_RET_SUSPENDED; + } + +finalize_it: + RETiRet; +} + + +/* set the permitted peers -- rgerhards, 2008-05-19 + */ +static rsRetVal +setPermittedPeer(void __attribute__((unused)) *pVal, uchar *pszID) +{ + DEFiRet; + CHKiRet(net.AddPermittedPeer(&cs.pPermPeers, pszID)); + free(pszID); /* no longer needed, but we must free it as of interface def */ +finalize_it: + RETiRet; +} + + + +/* CODE FOR SENDING TCP MESSAGES */ + +static rsRetVal +TCPSendBufUncompressed(wrkrInstanceData_t *pWrkrData, uchar *const buf, const unsigned len) +{ + DEFiRet; + unsigned alreadySent; + ssize_t lenSend; + + alreadySent = 0; + CHKiRet(netstrm.CheckConnection(pWrkrData->pNetstrm)); + /* hack for plain tcp syslog - see ptcp driver for details */ + + while(alreadySent != len) { + lenSend = len - alreadySent; + CHKiRet(netstrm.Send(pWrkrData->pNetstrm, buf+alreadySent, &lenSend)); + DBGPRINTF("omfwd: TCP sent %ld bytes, requested %u\n", (long) lenSend, len - alreadySent); + alreadySent += lenSend; + } + + ATOMIC_ADD_uint64(&pWrkrData->pData->sentBytes, &pWrkrData->pData->mut_sentBytes, len); + +finalize_it: + if(iRet != RS_RET_OK) { + if(iRet == RS_RET_IO_ERROR) { + static unsigned int conErrCnt = 0; + const int skipFactor = pWrkrData->pData->iConErrSkip; + if (skipFactor <= 1) { + /* All the connection errors are printed. */ + LogError(0, iRet, "omfwd: remote server at %s:%s seems to have closed connection. " + "This often happens when the remote peer (or an interim system like a load " + "balancer or firewall) shuts down or aborts a connection. Rsyslog will " + "re-open the connection if configured to do so (we saw a generic IO Error, " + "which usually goes along with that behaviour).", + pWrkrData->pData->target, pWrkrData->pData->port); + } else if ((conErrCnt++ % skipFactor) == 0) { + /* Every N'th error message is printed where N is a skipFactor. */ + LogError(0, iRet, "omfwd: remote server at %s:%s seems to have closed connection. " + "This often happens when the remote peer (or an interim system like a load " + "balancer or firewall) shuts down or aborts a connection. Rsyslog will " + "re-open the connection if configured to do so (we saw a generic IO Error, " + "which usually goes along with that behaviour). Note that the next %d " + "connection error messages will be skipped.", + pWrkrData->pData->target, pWrkrData->pData->port, skipFactor-1); + } + } else { + LogError(0, iRet, "omfwd: TCPSendBuf error %d, destruct TCP Connection to %s:%s", + iRet, pWrkrData->pData->target, pWrkrData->pData->port); + } + DestructTCPInstanceData(pWrkrData); + iRet = RS_RET_SUSPENDED; + } + RETiRet; +} + +static rsRetVal +TCPSendBufCompressed(wrkrInstanceData_t *pWrkrData, uchar *buf, unsigned len, sbool bIsFlush) +{ + int zRet; /* zlib return state */ + unsigned outavail; + uchar zipBuf[32*1024]; + int op; + DEFiRet; + + if(!pWrkrData->bzInitDone) { + /* allocate deflate state */ + pWrkrData->zstrm.zalloc = Z_NULL; + pWrkrData->zstrm.zfree = Z_NULL; + pWrkrData->zstrm.opaque = Z_NULL; + /* see note in file header for the params we use with deflateInit2() */ + zRet = deflateInit(&pWrkrData->zstrm, pWrkrData->pData->compressionLevel); + if(zRet != Z_OK) { + DBGPRINTF("error %d returned from zlib/deflateInit()\n", zRet); + ABORT_FINALIZE(RS_RET_ZLIB_ERR); + } + pWrkrData->bzInitDone = RSTRUE; + } + + /* now doing the compression */ + pWrkrData->zstrm.next_in = (Bytef*) buf; + pWrkrData->zstrm.avail_in = len; + if(pWrkrData->pData->strmCompFlushOnTxEnd && bIsFlush) + op = Z_SYNC_FLUSH; + else + op = Z_NO_FLUSH; + /* run deflate() on buffer until everything has been compressed */ + do { + DBGPRINTF("omfwd: in deflate() loop, avail_in %d, total_in %ld, isFlush %d\n", + pWrkrData->zstrm.avail_in, pWrkrData->zstrm.total_in, bIsFlush); + pWrkrData->zstrm.avail_out = sizeof(zipBuf); + pWrkrData->zstrm.next_out = zipBuf; + zRet = deflate(&pWrkrData->zstrm, op); /* no bad return value */ + DBGPRINTF("after deflate, ret %d, avail_out %d\n", zRet, pWrkrData->zstrm.avail_out); + outavail = sizeof(zipBuf) - pWrkrData->zstrm.avail_out; + if(outavail != 0) { + CHKiRet(TCPSendBufUncompressed(pWrkrData, zipBuf, outavail)); + } + } while (pWrkrData->zstrm.avail_out == 0); + +finalize_it: + RETiRet; +} + +static rsRetVal +TCPSendBuf(wrkrInstanceData_t *pWrkrData, uchar *buf, unsigned len, sbool bIsFlush) +{ + DEFiRet; + if(pWrkrData->pData->compressionMode >= COMPRESS_STREAM_ALWAYS) + iRet = TCPSendBufCompressed(pWrkrData, buf, len, bIsFlush); + else + iRet = TCPSendBufUncompressed(pWrkrData, buf, len); + RETiRet; +} + +/* finish zlib buffer, to be called before closing the ZIP file (if + * running in stream mode). + */ +static rsRetVal +doZipFinish(wrkrInstanceData_t *pWrkrData) +{ + int zRet; /* zlib return state */ + DEFiRet; + unsigned outavail; + uchar zipBuf[32*1024]; + + if(!pWrkrData->bzInitDone) + goto done; + + // TODO: can we get this into a single common function? + pWrkrData->zstrm.avail_in = 0; + /* run deflate() on buffer until everything has been compressed */ + do { + DBGPRINTF("in deflate() loop, avail_in %d, total_in %ld\n", pWrkrData->zstrm.avail_in, + pWrkrData->zstrm.total_in); + pWrkrData->zstrm.avail_out = sizeof(zipBuf); + pWrkrData->zstrm.next_out = zipBuf; + zRet = deflate(&pWrkrData->zstrm, Z_FINISH); /* no bad return value */ + DBGPRINTF("after deflate, ret %d, avail_out %d\n", zRet, pWrkrData->zstrm.avail_out); + outavail = sizeof(zipBuf) - pWrkrData->zstrm.avail_out; + if(outavail != 0) { + CHKiRet(TCPSendBufUncompressed(pWrkrData, zipBuf, outavail)); + } + } while (pWrkrData->zstrm.avail_out == 0); + +finalize_it: + zRet = deflateEnd(&pWrkrData->zstrm); + if(zRet != Z_OK) { + DBGPRINTF("error %d returned from zlib/deflateEnd()\n", zRet); + } + + pWrkrData->bzInitDone = 0; +done: RETiRet; +} + + +/* Add frame to send buffer (or send, if requried) + */ +static rsRetVal TCPSendFrame(void *pvData, char *msg, size_t len) +{ + DEFiRet; + wrkrInstanceData_t *pWrkrData = (wrkrInstanceData_t *) pvData; + + DBGPRINTF("omfwd: add %u bytes to send buffer (curr offs %u)\n", + (unsigned) len, pWrkrData->offsSndBuf); + if(pWrkrData->offsSndBuf != 0 && pWrkrData->offsSndBuf + len >= sizeof(pWrkrData->sndBuf)) { + /* no buffer space left, need to commit previous records. With the + * current API, there unfortunately is no way to signal this + * state transition to the upper layer. + */ + DBGPRINTF("omfwd: we need to do a tcp send due to buffer " + "out of space. If the transaction fails, this will " + "lead to duplication of messages"); + CHKiRet(TCPSendBuf(pWrkrData, pWrkrData->sndBuf, pWrkrData->offsSndBuf, NO_FLUSH)); + pWrkrData->offsSndBuf = 0; + } + + /* check if the message is too large to fit into buffer */ + if(len > sizeof(pWrkrData->sndBuf)) { + CHKiRet(TCPSendBuf(pWrkrData, (uchar*)msg, len, NO_FLUSH)); + ABORT_FINALIZE(RS_RET_OK); /* committed everything so far */ + } + + /* we now know the buffer has enough free space */ + memcpy(pWrkrData->sndBuf + pWrkrData->offsSndBuf, msg, len); + pWrkrData->offsSndBuf += len; + iRet = RS_RET_DEFER_COMMIT; + +finalize_it: + RETiRet; +} + + +/* This function is called immediately before a send retry is attempted. + * It shall clean up whatever makes sense. + * rgerhards, 2007-12-28 + */ +static rsRetVal TCPSendPrepRetry(void *pvData) +{ + DEFiRet; + wrkrInstanceData_t *pWrkrData = (wrkrInstanceData_t *) pvData; + + assert(pWrkrData != NULL); + DestructTCPInstanceData(pWrkrData); + RETiRet; +} + + +/* initializes everything so that TCPSend can work. + * rgerhards, 2007-12-28 + */ +static rsRetVal TCPSendInit(void *pvData) +{ + DEFiRet; + wrkrInstanceData_t *pWrkrData = (wrkrInstanceData_t *) pvData; + instanceData *pData; + + assert(pWrkrData != NULL); + pData = pWrkrData->pData; + + if(pWrkrData->pNetstrm == NULL) { + dbgprintf("TCPSendInit CREATE\n"); + CHKiRet(netstrms.Construct(&pWrkrData->pNS)); + /* the stream driver must be set before the object is finalized! */ + CHKiRet(netstrms.SetDrvrName(pWrkrData->pNS, pData->pszStrmDrvr)); + CHKiRet(netstrms.ConstructFinalize(pWrkrData->pNS)); + + /* now create the actual stream and connect to the server */ + CHKiRet(netstrms.CreateStrm(pWrkrData->pNS, &pWrkrData->pNetstrm)); + CHKiRet(netstrm.ConstructFinalize(pWrkrData->pNetstrm)); + CHKiRet(netstrm.SetDrvrMode(pWrkrData->pNetstrm, pData->iStrmDrvrMode)); + CHKiRet(netstrm.SetDrvrCheckExtendedKeyUsage(pWrkrData->pNetstrm, pData->iStrmDrvrExtendedCertCheck)); + CHKiRet(netstrm.SetDrvrPrioritizeSAN(pWrkrData->pNetstrm, pData->iStrmDrvrSANPreference)); + CHKiRet(netstrm.SetDrvrTlsVerifyDepth(pWrkrData->pNetstrm, pData->iStrmTlsVerifyDepth)); + /* now set optional params, but only if they were actually configured */ + if(pData->pszStrmDrvrAuthMode != NULL) { + CHKiRet(netstrm.SetDrvrAuthMode(pWrkrData->pNetstrm, pData->pszStrmDrvrAuthMode)); + } + /* Call SetDrvrPermitExpiredCerts required + * when param is NULL default handling for ExpiredCerts is set! */ + CHKiRet(netstrm.SetDrvrPermitExpiredCerts(pWrkrData->pNetstrm, + pData->pszStrmDrvrPermitExpiredCerts)); + CHKiRet(netstrm.SetDrvrTlsCAFile(pWrkrData->pNetstrm, pData->pszStrmDrvrCAFile)); + CHKiRet(netstrm.SetDrvrTlsCRLFile(pWrkrData->pNetstrm, pData->pszStrmDrvrCRLFile)); + CHKiRet(netstrm.SetDrvrTlsKeyFile(pWrkrData->pNetstrm, pData->pszStrmDrvrKeyFile)); + CHKiRet(netstrm.SetDrvrTlsCertFile(pWrkrData->pNetstrm, pData->pszStrmDrvrCertFile)); + + if(pData->pPermPeers != NULL) { + CHKiRet(netstrm.SetDrvrPermPeers(pWrkrData->pNetstrm, pData->pPermPeers)); + } + /* params set, now connect */ + if(pData->gnutlsPriorityString != NULL) { + CHKiRet(netstrm.SetGnutlsPriorityString(pWrkrData->pNetstrm, pData->gnutlsPriorityString)); + } + CHKiRet(netstrm.Connect(pWrkrData->pNetstrm, glbl.GetDefPFFamily(runModConf->pConf), + (uchar*)pData->port, (uchar*)pData->target, pData->device)); + + /* set keep-alive if enabled */ + if(pData->bKeepAlive) { + CHKiRet(netstrm.SetKeepAliveProbes(pWrkrData->pNetstrm, pData->iKeepAliveProbes)); + CHKiRet(netstrm.SetKeepAliveIntvl(pWrkrData->pNetstrm, pData->iKeepAliveIntvl)); + CHKiRet(netstrm.SetKeepAliveTime(pWrkrData->pNetstrm, pData->iKeepAliveTime)); + CHKiRet(netstrm.EnableKeepAlive(pWrkrData->pNetstrm)); + } + } + +finalize_it: + if(iRet != RS_RET_OK) { + dbgprintf("TCPSendInit FAILED with %d.\n", iRet); + DestructTCPInstanceData(pWrkrData); + } + + RETiRet; +} + + +/* change to network namespace pData->networkNamespace and keep the file + * descriptor to the original namespace. + */ +static rsRetVal changeToNs(instanceData *const pData __attribute__((unused))) +{ + DEFiRet; +#ifdef HAVE_SETNS + int iErr; + int destinationNs = -1; + char *nsPath = NULL; + + if(pData->networkNamespace) { + /* keep file descriptor of original network namespace */ + pData->originalNamespace = open("/proc/self/ns/net", O_RDONLY); + if (pData->originalNamespace < 0) { + LogError(0, RS_RET_IO_ERROR, "omfwd: could not read /proc/self/ns/net"); + ABORT_FINALIZE(RS_RET_IO_ERROR); + } + + /* build network namespace path */ + if (asprintf(&nsPath, "/var/run/netns/%s", pData->networkNamespace) == -1) { + LogError(0, RS_RET_OUT_OF_MEMORY, "omfwd: asprintf failed"); + ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY); + } + + /* keep file descriptor of destination network namespace */ + destinationNs = open(nsPath, 0); + if (destinationNs < 0) { + LogError(0, RS_RET_IO_ERROR, "omfwd: could not change to namespace '%s'", + pData->networkNamespace); + ABORT_FINALIZE(RS_RET_IO_ERROR); + } + + /* actually change in the destination network namespace */ + if((iErr = (setns(destinationNs, CLONE_NEWNET))) != 0) { + LogError(0, RS_RET_IO_ERROR, "could not change to namespace '%s': %s", + pData->networkNamespace, gai_strerror(iErr)); + ABORT_FINALIZE(RS_RET_IO_ERROR); + } + dbgprintf("omfwd: changed to network namespace '%s'\n", pData->networkNamespace); + } + +finalize_it: + free(nsPath); + if(destinationNs >= 0) { + close(destinationNs); + } +#else /* #ifdef HAVE_SETNS */ + dbgprintf("omfwd: OS does not support network namespaces\n"); +#endif /* #ifdef HAVE_SETNS */ + RETiRet; +} + + +/* return to the original network namespace. This should be called after + * changeToNs(). + */ +static rsRetVal returnToOriginalNs(instanceData *const pData __attribute__((unused))) +{ + DEFiRet; +#ifdef HAVE_SETNS + int iErr; + + /* only in case a network namespace is given and a file descriptor to + * the original namespace exists */ + if(pData->networkNamespace && pData->originalNamespace >= 0) { + /* actually change to the original network namespace */ + if((iErr = (setns(pData->originalNamespace, CLONE_NEWNET))) != 0) { + LogError(0, RS_RET_IO_ERROR, "could not return to original namespace: %s", + gai_strerror(iErr)); + ABORT_FINALIZE(RS_RET_IO_ERROR); + } + + close(pData->originalNamespace); + dbgprintf("omfwd: returned to original network namespace\n"); + } + +finalize_it: +#endif /* #ifdef HAVE_SETNS */ + RETiRet; +} + + +/* try to resume connection if it is not ready + * rgerhards, 2007-08-02 + */ +static rsRetVal doTryResume(wrkrInstanceData_t *pWrkrData) +{ + int iErr; + struct addrinfo *res = NULL; + struct addrinfo hints; + instanceData *pData; + int bBindRequired = 0; + const char *address; + DEFiRet; + + if(pWrkrData->bIsConnected) + FINALIZE; + pData = pWrkrData->pData; + + /* The remote address is not yet known and needs to be obtained */ + if(pData->protocol == FORW_UDP) { + memset(&hints, 0, sizeof(hints)); + /* port must be numeric, because config file syntax requires this */ + hints.ai_flags = AI_NUMERICSERV; + hints.ai_family = glbl.GetDefPFFamily(runModConf->pConf); + hints.ai_socktype = SOCK_DGRAM; + if((iErr = (getaddrinfo(pData->target, pData->port, &hints, &res))) != 0) { + LogError(0, RS_RET_SUSPENDED, + "omfwd: could not get addrinfo for hostname '%s':'%s': %s", + pData->target, pData->port, gai_strerror(iErr)); + ABORT_FINALIZE(RS_RET_SUSPENDED); + } + address = pData->target; + if(pData->address) { + struct addrinfo *addr; + /* The AF of the bind addr must match that of target */ + hints.ai_family = res->ai_family; + hints.ai_flags |= AI_PASSIVE; + iErr = getaddrinfo(pData->address, pData->port, &hints, &addr); + freeaddrinfo(addr); + if(iErr != 0) { + LogError(0, RS_RET_SUSPENDED, + "omfwd: cannot use bind address '%s' for host '%s': %s", + pData->address, pData->target, gai_strerror(iErr)); + ABORT_FINALIZE(RS_RET_SUSPENDED); + } + bBindRequired = 1; + address = pData->address; + } + DBGPRINTF("%s found, resuming.\n", pData->target); + pWrkrData->f_addr = res; + res = NULL; + if(pWrkrData->pSockArray == NULL) { + CHKiRet(changeToNs(pData)); + pWrkrData->pSockArray = net.create_udp_socket((uchar*)address, + NULL, bBindRequired, 0, pData->UDPSendBuf, pData->ipfreebind, pData->device); + CHKiRet(returnToOriginalNs(pData)); + } + if(pWrkrData->pSockArray != NULL) { + pWrkrData->bIsConnected = 1; + } + } else { + CHKiRet(changeToNs(pData)); + CHKiRet(TCPSendInit((void*)pWrkrData)); + CHKiRet(returnToOriginalNs(pData)); + } + +finalize_it: + DBGPRINTF("omfwd: doTryResume %s iRet %d\n", pWrkrData->pData->target, iRet); + if(res != NULL) { + freeaddrinfo(res); + } + if(iRet != RS_RET_OK) { + returnToOriginalNs(pData); + if(pWrkrData->f_addr != NULL) { + freeaddrinfo(pWrkrData->f_addr); + pWrkrData->f_addr = NULL; + } + iRet = RS_RET_SUSPENDED; + } + + RETiRet; +} + + +BEGINtryResume +CODESTARTtryResume + dbgprintf("omfwd: tryResume: pWrkrData %p\n", pWrkrData); + iRet = doTryResume(pWrkrData); +ENDtryResume + + +BEGINbeginTransaction +CODESTARTbeginTransaction + dbgprintf("omfwd: beginTransaction\n"); + iRet = doTryResume(pWrkrData); +ENDbeginTransaction + + +static rsRetVal +processMsg(wrkrInstanceData_t *__restrict__ const pWrkrData, + actWrkrIParams_t *__restrict__ const iparam) +{ + uchar *psz; /* temporary buffering */ + register unsigned l; + int iMaxLine; + Bytef *out = NULL; /* for compression */ + instanceData *__restrict__ const pData = pWrkrData->pData; + DEFiRet; + + iMaxLine = glbl.GetMaxLine(runModConf->pConf); + + psz = iparam->param; + l = iparam->lenStr; + if((int) l > iMaxLine) + l = iMaxLine; + + /* Check if we should compress and, if so, do it. We also + * check if the message is large enough to justify compression. + * The smaller the message, the less likely is a gain in compression. + * To save CPU cycles, we do not try to compress very small messages. + * What "very small" means needs to be configured. Currently, it is + * hard-coded but this may be changed to a config parameter. + * rgerhards, 2006-11-30 + */ + if(pData->compressionMode == COMPRESS_SINGLE_MSG && (l > CONF_MIN_SIZE_FOR_COMPRESS)) { + uLongf destLen = iMaxLine + iMaxLine/100 +12; /* recommended value from zlib doc */ + uLong srcLen = l; + int ret; + CHKmalloc(out = (Bytef*) malloc(destLen)); + out[0] = 'z'; + out[1] = '\0'; + ret = compress2((Bytef*) out+1, &destLen, (Bytef*) psz, + srcLen, pData->compressionLevel); + dbgprintf("Compressing message, length was %d now %d, return state %d.\n", + l, (int) destLen, ret); + if(ret != Z_OK) { + /* if we fail, we complain, but only in debug mode + * Otherwise, we are silent. In any case, we ignore the + * failed compression and just sent the uncompressed + * data, which is still valid. So this is probably the + * best course of action. + * rgerhards, 2006-11-30 + */ + dbgprintf("Compression failed, sending uncompressed message\n"); + } else if(destLen+1 < l) { + /* only use compression if there is a gain in using it! */ + dbgprintf("there is gain in compression, so we do it\n"); + psz = out; + l = destLen + 1; /* take care for the "z" at message start! */ + } + ++destLen; + } + + if(pData->protocol == FORW_UDP) { + /* forward via UDP */ + CHKiRet(UDPSend(pWrkrData, psz, l)); + } else { + /* forward via TCP */ + iRet = tcpclt.Send(pWrkrData->pTCPClt, pWrkrData, (char *)psz, l); + if(iRet != RS_RET_OK && iRet != RS_RET_DEFER_COMMIT && iRet != RS_RET_PREVIOUS_COMMITTED) { + /* error! */ + LogError(0, iRet, "omfwd: error forwarding via tcp to %s:%s, suspending action", + pWrkrData->pData->target, pWrkrData->pData->port); + DestructTCPInstanceData(pWrkrData); + iRet = RS_RET_SUSPENDED; + } + } +finalize_it: + free(out); /* is NULL if it was never used... */ + RETiRet; +} + +BEGINcommitTransaction + unsigned i; + char namebuf[264]; /* 256 for FGDN, 5 for port and 3 for transport => 264 */ +CODESTARTcommitTransaction + CHKiRet(doTryResume(pWrkrData)); + + DBGPRINTF(" %s:%s/%s\n", pWrkrData->pData->target, pWrkrData->pData->port, + pWrkrData->pData->protocol == FORW_UDP ? "udp" : "tcp"); + + if(pWrkrData->pData->ratelimiter) { + snprintf(namebuf, sizeof namebuf, "%s:[%s]:%s", + pWrkrData->pData->protocol == FORW_UDP ? "udp" : "tcp", + pWrkrData->pData->target, + pWrkrData->pData->port); + } + + for(i = 0 ; i < nParams ; ++i) { + /* If rate limiting is enabled, check whether this message has to be discarded */ + if(pWrkrData->pData->ratelimiter) { + iRet = ratelimitMsgCount(pWrkrData->pData->ratelimiter, 0, namebuf); + if (iRet == RS_RET_DISCARDMSG) { + iRet = RS_RET_OK; + continue; + } else if (iRet != RS_RET_OK) { + LogError(0, RS_RET_ERR, "omfwd: error during rate limit : %d.\n",iRet); + } + } + iRet = processMsg(pWrkrData, &actParam(pParams, 1, i, 0)); + if(iRet != RS_RET_OK && iRet != RS_RET_DEFER_COMMIT && iRet != RS_RET_PREVIOUS_COMMITTED) + FINALIZE; + } + + if(pWrkrData->offsSndBuf != 0) { + iRet = TCPSendBuf(pWrkrData, pWrkrData->sndBuf, pWrkrData->offsSndBuf, IS_FLUSH); + pWrkrData->offsSndBuf = 0; + } +finalize_it: +ENDcommitTransaction + + +/* This function loads TCP support, if not already loaded. It will be called + * during config processing. To server ressources, TCP support will only + * be loaded if it actually is used. -- rgerhard, 2008-04-17 + */ +static rsRetVal +loadTCPSupport(void) +{ + DEFiRet; + CHKiRet(objUse(netstrms, LM_NETSTRMS_FILENAME)); + CHKiRet(objUse(netstrm, LM_NETSTRMS_FILENAME)); + CHKiRet(objUse(tcpclt, LM_TCPCLT_FILENAME)); + +finalize_it: + RETiRet; +} + + +/* initialize TCP structures (if necessary) after the instance has been + * created. + */ +static rsRetVal +initTCP(wrkrInstanceData_t *pWrkrData) +{ + instanceData *pData; + DEFiRet; + + pData = pWrkrData->pData; + if(pData->protocol == FORW_TCP) { + /* create our tcpclt */ + CHKiRet(tcpclt.Construct(&pWrkrData->pTCPClt)); + CHKiRet(tcpclt.SetResendLastOnRecon(pWrkrData->pTCPClt, pData->bResendLastOnRecon)); + /* and set callbacks */ + CHKiRet(tcpclt.SetSendInit(pWrkrData->pTCPClt, TCPSendInit)); + CHKiRet(tcpclt.SetSendFrame(pWrkrData->pTCPClt, TCPSendFrame)); + CHKiRet(tcpclt.SetSendPrepRetry(pWrkrData->pTCPClt, TCPSendPrepRetry)); + CHKiRet(tcpclt.SetFraming(pWrkrData->pTCPClt, pData->tcp_framing)); + CHKiRet(tcpclt.SetFramingDelimiter(pWrkrData->pTCPClt, pData->tcp_framingDelimiter)); + CHKiRet(tcpclt.SetRebindInterval(pWrkrData->pTCPClt, pData->iRebindInterval)); + } +finalize_it: + RETiRet; +} + + +static void +setInstParamDefaults(instanceData *pData) +{ + pData->tplName = NULL; + pData->protocol = FORW_UDP; + pData->networkNamespace = NULL; + pData->originalNamespace = -1; + pData->tcp_framing = TCP_FRAMING_OCTET_STUFFING; + pData->tcp_framingDelimiter = '\n'; + pData->pszStrmDrvr = NULL; + pData->pszStrmDrvrAuthMode = NULL; + pData->pszStrmDrvrPermitExpiredCerts = NULL; + pData->iStrmDrvrMode = 0; + pData->iStrmDrvrExtendedCertCheck = 0; + pData->iStrmDrvrSANPreference = 0; + pData->iStrmTlsVerifyDepth = 0; + pData->pszStrmDrvrCAFile = NULL; + pData->pszStrmDrvrCRLFile = NULL; + pData->pszStrmDrvrKeyFile = NULL; + pData->pszStrmDrvrCertFile = NULL; + pData->iRebindInterval = 0; + pData->bKeepAlive = 0; + pData->iKeepAliveProbes = 0; + pData->iKeepAliveIntvl = 0; + pData->iKeepAliveTime = 0; + pData->iConErrSkip = 0; + pData->gnutlsPriorityString = NULL; + pData->bResendLastOnRecon = 0; + pData->bSendToAll = -1; /* unspecified */ + pData->iUDPSendDelay = 0; + pData->UDPSendBuf = 0; + pData->pPermPeers = NULL; + pData->compressionLevel = 9; + pData->strmCompFlushOnTxEnd = 1; + pData->compressionMode = COMPRESS_NEVER; + pData->ipfreebind = IPFREEBIND_ENABLED_WITH_LOG; + pData->ratelimiter = NULL; + pData->ratelimitInterval = 0; + pData->ratelimitBurst = 200; +} + + +static rsRetVal +setupInstStatsCtrs(instanceData *__restrict__ const pData) +{ + uchar ctrName[512]; + DEFiRet; + + /* support statistics gathering */ + snprintf((char*)ctrName, sizeof(ctrName), "%s-%s-%s", + (pData->protocol == FORW_TCP) ? "TCP" : "UDP", + pData->target, pData->port); + ctrName[sizeof(ctrName)-1] = '\0'; /* be on the save side */ + CHKiRet(statsobj.Construct(&(pData->stats))); + CHKiRet(statsobj.SetName(pData->stats, ctrName)); + CHKiRet(statsobj.SetOrigin(pData->stats, (uchar*)"omfwd")); + pData->sentBytes = 0; + INIT_ATOMIC_HELPER_MUT64(pData->mut_sentBytes); + CHKiRet(statsobj.AddCounter(pData->stats, UCHAR_CONSTANT("bytes.sent"), + ctrType_IntCtr, CTR_FLAG_RESETTABLE, &(pData->sentBytes))); + CHKiRet(statsobj.ConstructFinalize(pData->stats)); + +finalize_it: + RETiRet; +} + + +BEGINnewActInst + struct cnfparamvals *pvals; + uchar *tplToUse; + char *cstr; + int i; + rsRetVal localRet; + int complevel = -1; +CODESTARTnewActInst + DBGPRINTF("newActInst (omfwd)\n"); + + pvals = nvlstGetParams(lst, &actpblk, NULL); + if(pvals == NULL) { + ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS); + } + + if(Debug) { + dbgprintf("action param blk in omfwd:\n"); + cnfparamsPrint(&actpblk, pvals); + } + + CHKiRet(createInstance(&pData)); + setInstParamDefaults(pData); + + for(i = 0 ; i < actpblk.nParams ; ++i) { + if(!pvals[i].bUsed) + continue; + if(!strcmp(actpblk.descr[i].name, "target")) { + pData->target = es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "address")) { + pData->address = es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "device")) { + pData->device = es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "port")) { + pData->port = es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "protocol")) { + if(!es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"udp", 3)) { + pData->protocol = FORW_UDP; + } else if(!es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"tcp", 3)) { + localRet = loadTCPSupport(); + if(localRet != RS_RET_OK) { + LogError(0, localRet, "could not activate network stream modules for TCP " + "(internal error %d) - are modules missing?", localRet); + ABORT_FINALIZE(localRet); + } + pData->protocol = FORW_TCP; + } else { + uchar *str; + str = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + LogError(0, RS_RET_INVLD_PROTOCOL, + "omfwd: invalid protocol \"%s\"", str); + free(str); + ABORT_FINALIZE(RS_RET_INVLD_PROTOCOL); + } + } else if(!strcmp(actpblk.descr[i].name, "networknamespace")) { + pData->networkNamespace = es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "tcp_framing")) { + if(!es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"traditional", 11)) { + pData->tcp_framing = TCP_FRAMING_OCTET_STUFFING; + } else if(!es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"octet-counted", 13)) { + pData->tcp_framing = TCP_FRAMING_OCTET_COUNTING; + } else { + uchar *str; + str = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + LogError(0, RS_RET_CNF_INVLD_FRAMING, + "omfwd: invalid framing \"%s\"", str); + free(str); + ABORT_FINALIZE(RS_RET_CNF_INVLD_FRAMING ); + } + } else if(!strcmp(actpblk.descr[i].name, "rebindinterval")) { + pData->iRebindInterval = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "keepalive")) { + pData->bKeepAlive = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "keepalive.probes")) { + pData->iKeepAliveProbes = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "keepalive.interval")) { + pData->iKeepAliveIntvl = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "keepalive.time")) { + pData->iKeepAliveTime = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "conerrskip")) { + pData->iConErrSkip = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "gnutlsprioritystring")) { + pData->gnutlsPriorityString = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdriver")) { + pData->pszStrmDrvr = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdrivermode")) { + pData->iStrmDrvrMode = pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.CheckExtendedKeyPurpose")) { + pData->iStrmDrvrExtendedCertCheck = pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.PrioritizeSAN")) { + pData->iStrmDrvrSANPreference = pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.TlsVerifyDepth")) { + if (pvals[i].val.d.n >= 2) { + pData->iStrmTlsVerifyDepth = pvals[i].val.d.n; + } else { + parser_errmsg("streamdriver.TlsVerifyDepth must be 2 or higher but is %d", + (int) pvals[i].val.d.n); + } + } else if(!strcmp(actpblk.descr[i].name, "streamdriverauthmode")) { + pData->pszStrmDrvrAuthMode = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.permitexpiredcerts")) { + uchar *val = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + if( es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"off", 3) + && es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"on", 2) + && es_strcasebufcmp(pvals[i].val.d.estr, (uchar*)"warn", 4) + ) { + parser_errmsg("streamdriver.permitExpiredCerts must be 'warn', 'off' or 'on' " + "but is '%s' - ignoring parameter, using 'off' instead.", val); + free(val); + } else { + pData->pszStrmDrvrPermitExpiredCerts = val; + } + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.cafile")) { + pData->pszStrmDrvrCAFile = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.crlfile")) { + pData->pszStrmDrvrCRLFile = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.keyfile")) { + pData->pszStrmDrvrKeyFile = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdriver.certfile")) { + pData->pszStrmDrvrCertFile = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "streamdriverpermittedpeers")) { + uchar *start, *str; + uchar *p; + int lenStr; + str = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + start = str; + lenStr = ustrlen(start); /* we need length after '\0' has been dropped... */ + while(lenStr > 0) { + p = start; + while(*p && *p != ',' && lenStr--) + p++; + if(*p == ',') { + *p = '\0'; + } + if(*start == '\0') { + DBGPRINTF("omfwd: ignoring empty permitted peer\n"); + } else { + dbgprintf("omfwd: adding permitted peer: '%s'\n", start); + CHKiRet(net.AddPermittedPeer(&(pData->pPermPeers), start)); + } + start = p+1; + if(lenStr) + --lenStr; + } + free(str); + } else if(!strcmp(actpblk.descr[i].name, "ziplevel")) { + complevel = pvals[i].val.d.n; + if(complevel >= 0 && complevel <= 10) { + pData->compressionLevel = complevel; + pData->compressionMode = COMPRESS_SINGLE_MSG; + } else { + LogError(0, NO_ERRCODE, "Invalid ziplevel %d specified in " + "forwarding action - NOT turning on compression.", + complevel); + } + } else if(!strcmp(actpblk.descr[i].name, "tcp_framedelimiter")) { + if(pvals[i].val.d.n > 255) { + parser_errmsg("tcp_frameDelimiter must be below 255 but is %d", + (int) pvals[i].val.d.n); + ABORT_FINALIZE(RS_RET_PARAM_ERROR); + } + pData->tcp_framingDelimiter = (uchar) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "resendlastmsgonreconnect")) { + pData->bResendLastOnRecon = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "udp.sendtoall")) { + pData->bSendToAll = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "udp.senddelay")) { + pData->iUDPSendDelay = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "udp.sendbuf")) { + pData->UDPSendBuf = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "template")) { + pData->tplName = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL); + } else if(!strcmp(actpblk.descr[i].name, "compression.stream.flushontxend")) { + pData->strmCompFlushOnTxEnd = (sbool) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "compression.mode")) { + cstr = es_str2cstr(pvals[i].val.d.estr, NULL); + if(!strcasecmp(cstr, "stream:always")) { + pData->compressionMode = COMPRESS_STREAM_ALWAYS; + } else if(!strcasecmp(cstr, "none")) { + pData->compressionMode = COMPRESS_NEVER; + } else if(!strcasecmp(cstr, "single")) { + pData->compressionMode = COMPRESS_SINGLE_MSG; + } else { + LogError(0, RS_RET_PARAM_ERROR, "omfwd: invalid value for 'compression.mode' " + "parameter (given is '%s')", cstr); + free(cstr); + ABORT_FINALIZE(RS_RET_PARAM_ERROR); + } + free(cstr); + } else if(!strcmp(actpblk.descr[i].name, "ipfreebind")) { + pData->ipfreebind = (int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "ratelimit.burst")) { + pData->ratelimitBurst = (unsigned int) pvals[i].val.d.n; + } else if(!strcmp(actpblk.descr[i].name, "ratelimit.interval")) { + pData->ratelimitInterval = (unsigned int) pvals[i].val.d.n; + } else { + LogError(0, RS_RET_INTERNAL_ERROR, + "omfwd: program error, non-handled parameter '%s'", + actpblk.descr[i].name); + } + } + + /* check if no port is set. If so, we use the IANA-assigned port of 514 */ + if(pData->port == NULL) { + CHKmalloc(pData->port = strdup("514")); + } + + if(complevel != -1) { + pData->compressionLevel = complevel; + if(pData->compressionMode == COMPRESS_NEVER) { + /* to keep compatible with pre-7.3.11, only setting the + * compresion level means old-style single-message mode. + */ + pData->compressionMode = COMPRESS_SINGLE_MSG; + } + } + + CODE_STD_STRING_REQUESTnewActInst(1) + + tplToUse = ustrdup((pData->tplName == NULL) ? getDfltTpl() : pData->tplName); + CHKiRet(OMSRsetEntry(*ppOMSR, 0, tplToUse, OMSR_NO_RQD_TPL_OPTS)); + + if(pData->bSendToAll == -1) { + pData->bSendToAll = send_to_all; + } else { + if(pData->protocol == FORW_TCP) { + LogError(0, RS_RET_PARAM_ERROR, "omfwd: parameter udp.sendToAll " + "cannot be used with tcp transport -- ignored"); + } + } + + if(pData->address && (pData->protocol == FORW_TCP)) { + LogError(0, RS_RET_PARAM_ERROR, + "omfwd: parameter \"address\" not supported for tcp -- ignored"); + } + + if( pData->ratelimitInterval > 0) { + CHKiRet(ratelimitNew(&pData->ratelimiter, "omfwd", NULL)); + ratelimitSetLinuxLike(pData->ratelimiter, pData->ratelimitInterval, pData->ratelimitBurst); + ratelimitSetNoTimeCache(pData->ratelimiter); + } + + setupInstStatsCtrs(pData); + +CODE_STD_FINALIZERnewActInst + cnfparamvalsDestruct(pvals, &actpblk); +ENDnewActInst + + +BEGINparseSelectorAct + uchar *q; + int i; + rsRetVal localRet; + struct addrinfo; + TCPFRAMINGMODE tcp_framing = TCP_FRAMING_OCTET_STUFFING; +CODESTARTparseSelectorAct +CODE_STD_STRING_REQUESTparseSelectorAct(1) + if(*p != '@') + ABORT_FINALIZE(RS_RET_CONFLINE_UNPROCESSED); + + CHKiRet(createInstance(&pData)); + pData->tcp_framingDelimiter = '\n'; + + ++p; /* eat '@' */ + if(*p == '@') { /* indicator for TCP! */ + localRet = loadTCPSupport(); + if(localRet != RS_RET_OK) { + LogError(0, localRet, "could not activate network stream modules for TCP " + "(internal error %d) - are modules missing?", localRet); + ABORT_FINALIZE(localRet); + } + pData->protocol = FORW_TCP; + ++p; /* eat this '@', too */ + } else { + pData->protocol = FORW_UDP; + } + /* we are now after the protocol indicator. Now check if we should + * use compression. We begin to use a new option format for this: + * @(option,option)host:port + * The first option defined is "z[0..9]" where the digit indicates + * the compression level. If it is not given, 9 (best compression) is + * assumed. An example action statement might be: + * @@(z5,o)127.0.0.1:1400 + * Which means send via TCP with medium (5) compresion (z) to the local + * host on port 1400. The '0' option means that octet-couting (as in + * IETF I-D syslog-transport-tls) is to be used for framing (this option + * applies to TCP-based syslog only and is ignored when specified with UDP). + * That is not yet implemented. + * rgerhards, 2006-12-07 + * In order to support IPv6 addresses, we must introduce an extension to + * the hostname. If it is in square brackets, whatever is in them is treated as + * the hostname - without any exceptions ;) -- rgerhards, 2008-08-05 + */ + if(*p == '(') { + /* at this position, it *must* be an option indicator */ + do { + ++p; /* eat '(' or ',' (depending on when called) */ + /* check options */ + if(*p == 'z') { /* compression */ + ++p; /* eat */ + if(isdigit((int) *p)) { + int iLevel; + iLevel = *p - '0'; + ++p; /* eat */ + pData->compressionLevel = iLevel; + pData->compressionMode = COMPRESS_SINGLE_MSG; + } else { + LogError(0, NO_ERRCODE, "Invalid compression level '%c' specified in " + "forwarding action - NOT turning on compression.", + *p); + } + } else if(*p == 'o') { /* octet-couting based TCP framing? */ + ++p; /* eat */ + /* no further options settable */ + tcp_framing = TCP_FRAMING_OCTET_COUNTING; + } else { /* invalid option! Just skip it... */ + LogError(0, NO_ERRCODE, "Invalid option %c in forwarding action - ignoring.", *p); + ++p; /* eat invalid option */ + } + /* the option processing is done. We now do a generic skip + * to either the next option or the end of the option + * block. + */ + while(*p && *p != ')' && *p != ',') + ++p; /* just skip it */ + } while(*p && *p == ','); /* Attention: do.. while() */ + if(*p == ')') + ++p; /* eat terminator, on to next */ + else + /* we probably have end of string - leave it for the rest + * of the code to handle it (but warn the user) + */ + LogError(0, NO_ERRCODE, "Option block not terminated in forwarding action."); + } + + /* extract the host first (we do a trick - we replace the ';' or ':' with a '\0') + * now skip to port and then template name. rgerhards 2005-07-06 + */ + if(*p == '[') { /* everything is hostname upto ']' */ + ++p; /* skip '[' */ + for(q = p ; *p && *p != ']' ; ++p) + /* JUST SKIP */; + if(*p == ']') { + *p = '\0'; /* trick to obtain hostname (later)! */ + ++p; /* eat it */ + } + } else { /* traditional view of hostname */ + for(q = p ; *p && *p != ';' && *p != ':' && *p != '#' ; ++p) + /* JUST SKIP */; + } + + pData->tcp_framing = tcp_framing; + pData->port = NULL; + pData->networkNamespace = NULL; + if(*p == ':') { /* process port */ + uchar * tmp; + + *p = '\0'; /* trick to obtain hostname (later)! */ + tmp = ++p; + for(i=0 ; *p && isdigit((int) *p) ; ++p, ++i) + /* SKIP AND COUNT */; + pData->port = malloc(i + 1); + if(pData->port == NULL) { + LogError(0, NO_ERRCODE, "Could not get memory to store syslog forwarding port, " + "using default port, results may not be what you intend"); + /* we leave f_forw.port set to NULL, this is then handled below */ + } else { + memcpy(pData->port, tmp, i); + *(pData->port + i) = '\0'; + } + } + /* check if no port is set. If so, we use the IANA-assigned port of 514 */ + if(pData->port == NULL) { + CHKmalloc(pData->port = strdup("514")); + } + + /* now skip to template */ + while(*p && *p != ';' && *p != '#' && !isspace((int) *p)) + ++p; /*JUST SKIP*/ + + if(*p == ';' || *p == '#' || isspace(*p)) { + uchar cTmp = *p; + *p = '\0'; /* trick to obtain hostname (later)! */ + CHKmalloc(pData->target = strdup((char*) q)); + *p = cTmp; + } else { + CHKmalloc(pData->target = strdup((char*) q)); + } + + /* copy over config data as needed */ + pData->iRebindInterval = (pData->protocol == FORW_TCP) ? + cs.iTCPRebindInterval : cs.iUDPRebindInterval; + + pData->bKeepAlive = cs.bKeepAlive; + pData->iKeepAliveProbes = cs.iKeepAliveProbes; + pData->iKeepAliveIntvl = cs.iKeepAliveIntvl; + pData->iKeepAliveTime = cs.iKeepAliveTime; + pData->iConErrSkip = cs.iConErrSkip; + + /* process template */ + CHKiRet(cflineParseTemplateName(&p, *ppOMSR, 0, OMSR_NO_RQD_TPL_OPTS, getDfltTpl())); + + if(pData->protocol == FORW_TCP) { + pData->bResendLastOnRecon = cs.bResendLastOnRecon; + pData->iStrmDrvrMode = cs.iStrmDrvrMode; + if(cs.pPermPeers != NULL) { + pData->pPermPeers = cs.pPermPeers; + cs.pPermPeers = NULL; + } + } +CODE_STD_FINALIZERparseSelectorAct +ENDparseSelectorAct + + +/* a common function to free our configuration variables - used both on exit + * and on $ResetConfig processing. -- rgerhards, 2008-05-16 + */ +static void +freeConfigVars(void) +{ + free(cs.pszStrmDrvr); + cs.pszStrmDrvr = NULL; + free(cs.pszStrmDrvrAuthMode); + cs.pszStrmDrvrAuthMode = NULL; + free(cs.pPermPeers); + cs.pPermPeers = NULL; /* TODO: fix in older builds! */ +} + + +BEGINmodExit +CODESTARTmodExit + /* release what we no longer need */ + objRelease(glbl, CORE_COMPONENT); + objRelease(net, LM_NET_FILENAME); + objRelease(netstrm, LM_NETSTRMS_FILENAME); + objRelease(netstrms, LM_NETSTRMS_FILENAME); + objRelease(tcpclt, LM_TCPCLT_FILENAME); + objRelease(statsobj, CORE_COMPONENT); + freeConfigVars(); +ENDmodExit + + +BEGINqueryEtryPt +CODESTARTqueryEtryPt +CODEqueryEtryPt_STD_OMODTX_QUERIES +CODEqueryEtryPt_STD_OMOD8_QUERIES +CODEqueryEtryPt_STD_CONF2_QUERIES +CODEqueryEtryPt_STD_CONF2_setModCnf_QUERIES +CODEqueryEtryPt_STD_CONF2_OMOD_QUERIES +ENDqueryEtryPt + + +/* Reset config variables for this module to default values. + * rgerhards, 2008-03-28 + */ +static rsRetVal resetConfigVariables(uchar __attribute__((unused)) *pp, void __attribute__((unused)) *pVal) +{ + freeConfigVars(); + + /* we now must reset all non-string values */ + cs.iStrmDrvrMode = 0; + cs.bResendLastOnRecon = 0; + cs.iUDPRebindInterval = 0; + cs.iTCPRebindInterval = 0; + cs.bKeepAlive = 0; + cs.iKeepAliveProbes = 0; + cs.iKeepAliveIntvl = 0; + cs.iKeepAliveTime = 0; + cs.iConErrSkip = 0; + + return RS_RET_OK; +} + + +BEGINmodInit(Fwd) +CODESTARTmodInit +INITLegCnfVars + *ipIFVersProvided = CURR_MOD_IF_VERSION; /* we only support the current interface specification */ +CODEmodInit_QueryRegCFSLineHdlr + CHKiRet(objUse(glbl, CORE_COMPONENT)); + CHKiRet(objUse(net,LM_NET_FILENAME)); + CHKiRet(objUse(statsobj, CORE_COMPONENT)); + + CHKiRet(regCfSysLineHdlr((uchar *)"actionforwarddefaulttemplate", 0, eCmdHdlrGetWord, + setLegacyDfltTpl, NULL, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendtcprebindinterval", 0, eCmdHdlrInt, + NULL, &cs.iTCPRebindInterval, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendudprebindinterval", 0, eCmdHdlrInt, + NULL, &cs.iUDPRebindInterval, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendtcpkeepalive", 0, eCmdHdlrBinary, + NULL, &cs.bKeepAlive, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendtcpkeepalive_probes", 0, eCmdHdlrInt, + NULL, &cs.iKeepAliveProbes, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendtcpkeepalive_intvl", 0, eCmdHdlrInt, + NULL, &cs.iKeepAliveIntvl, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendtcpkeepalive_time", 0, eCmdHdlrInt, + NULL, &cs.iKeepAliveTime, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendstreamdriver", 0, eCmdHdlrGetWord, + NULL, &cs.pszStrmDrvr, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendstreamdrivermode", 0, eCmdHdlrInt, + NULL, &cs.iStrmDrvrMode, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendstreamdriverauthmode", 0, eCmdHdlrGetWord, + NULL, &cs.pszStrmDrvrAuthMode, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendstreamdriverpermittedpeer", 0, eCmdHdlrGetWord, + setPermittedPeer, NULL, NULL)); + CHKiRet(regCfSysLineHdlr((uchar *)"actionsendresendlastmsgonreconnect", 0, eCmdHdlrBinary, + NULL, &cs.bResendLastOnRecon, NULL)); + CHKiRet(omsdRegCFSLineHdlr((uchar *)"resetconfigvariables", 1, eCmdHdlrCustomHandler, + resetConfigVariables, NULL, STD_LOADABLE_MODULE_ID)); +ENDmodInit |