Imported Upstream version 7.1.9upstream/7.1.9

1 files changed, 380 insertions, 150 deletions

diff --git a/tools/omfile.c b/tools/omfile.c
index fbd263c..1ccd4a5 100644
--- a/tools/omfile.c
+++ b/tools/omfile.c
@@ -71,6 +71,10 @@
 
 MODULE_TYPE_OUTPUT
 MODULE_TYPE_NOKEEP
+MODULE_CNFNAME("omfile")
+
+/* forward definitions */
+static rsRetVal resetConfigVariables(uchar __attribute__((unused)) *pp, void __attribute__((unused)) *pVal);
 
 /* internal structures
  */
@@ -117,43 +121,21 @@ struct s_dynaFileCacheEntry {
 typedef struct s_dynaFileCacheEntry dynaFileCacheEntry;
 
 
-#define IOBUF_DFLT_SIZE 1024	/* default size for io buffers */
+#define IOBUF_DFLT_SIZE 4096	/* default size for io buffers */
 #define FLUSH_INTRVL_DFLT 1 	/* default buffer flush interval (in seconds) */
 #define USE_ASYNCWRITER_DFLT 0 	/* default buffer use async writer */
 #define FLUSHONTX_DFLT 1 	/* default for flush on TX end */
 
-#define DFLT_bForceChown 0
-/* globals for default values */
-static int iDynaFileCacheSize = 10; /* max cache for dynamic files */
-static int fCreateMode = 0644; /* mode to use when creating files */
-static int fDirCreateMode = 0700; /* mode to use when creating files */
-static int	bFailOnChown;	/* fail if chown fails? */
-static int	bForceChown = DFLT_bForceChown;	/* Force chown() on existing files? */
-static uid_t	fileUID;	/* UID to be used for newly created files */
-static uid_t	fileGID;	/* GID to be used for newly created files */
-static uid_t	dirUID;		/* UID to be used for newly created directories */
-static uid_t	dirGID;		/* GID to be used for newly created directories */
-static int	bCreateDirs = 1;/* auto-create directories for dynaFiles: 0 - no, 1 - yes */
-static int	bEnableSync = 0;/* enable syncing of files (no dash in front of pathname in conf): 0 - no, 1 - yes */
-static int	iZipLevel = 0;	/* zip compression mode (0..9 as usual) */
-static sbool	bFlushOnTXEnd = FLUSHONTX_DFLT;/* flush write buffers when transaction has ended? */
-static int64	iIOBufSize = IOBUF_DFLT_SIZE;	/* size of an io buffer */
-static int	iFlushInterval = FLUSH_INTRVL_DFLT; 	/* how often flush the output buffer on inactivity? */
-static int	bUseAsyncWriter = USE_ASYNCWRITER_DFLT;	/* should we enable asynchronous writing? */
-uchar	*pszFileDfltTplName = NULL; /* name of the default template to use */
-/* end globals for default values */
-
 
 typedef struct _instanceData {
-	uchar	f_fname[MAXFNAME];/* file or template name (display only) */
+	uchar	*f_fname;	/* file or template name (display only) */
+	uchar 	*tplName;	/* name of assigned template */
 	strm_t	*pStrm;		/* our output stream */
-	strmType_t strmType;	/* stream type, used for named pipes */
 	char	bDynamicName;	/* 0 - static name, 1 - dynamic name (with properties) */
 	int	fCreateMode;	/* file creation mode for open() */
 	int	fDirCreateMode;	/* creation mode for mkdir() */
 	int	bCreateDirs;	/* auto-create directories? */
 	int	bSyncFile;	/* should the file by sync()'ed? 1- yes, 0- no */
-	sbool	bForceChown;	/* force chown() on existing files? */
 	uid_t	fileUID;	/* IDs for creation */
 	uid_t	dirUID;
 	gid_t	fileGID;
@@ -177,6 +159,95 @@ typedef struct _instanceData {
 } instanceData;
 
 
+typedef struct configSettings_s {
+	int iDynaFileCacheSize; /* max cache for dynamic files */
+	int fCreateMode; /* mode to use when creating files */
+	int fDirCreateMode; /* mode to use when creating files */
+	int	bFailOnChown;	/* fail if chown fails? */
+	uid_t	fileUID;	/* UID to be used for newly created files */
+	uid_t	fileGID;	/* GID to be used for newly created files */
+	uid_t	dirUID;		/* UID to be used for newly created directories */
+	uid_t	dirGID;		/* GID to be used for newly created directories */
+	int	bCreateDirs;/* auto-create directories for dynaFiles: 0 - no, 1 - yes */
+	int	bEnableSync;/* enable syncing of files (no dash in front of pathname in conf): 0 - no, 1 - yes */
+	int	iZipLevel;	/* zip compression mode (0..9 as usual) */
+	sbool	bFlushOnTXEnd;/* flush write buffers when transaction has ended? */
+	int64	iIOBufSize;	/* size of an io buffer */
+	int	iFlushInterval; 	/* how often flush the output buffer on inactivity? */
+	int	bUseAsyncWriter;	/* should we enable asynchronous writing? */
+	EMPTY_STRUCT
+} configSettings_t;
+static configSettings_t cs;
+uchar	*pszFileDfltTplName; /* name of the default template to use */
+
+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 */
+
+/* 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[] = {
+	{ "dynafilecachesize", eCmdHdlrInt, 0 }, /* legacy: dynafilecachesize */
+	{ "ziplevel", eCmdHdlrInt, 0 }, /* legacy: omfileziplevel */
+	{ "flushinterval", eCmdHdlrInt, 0 }, /* legacy: omfileflushinterval */
+	{ "asyncwriting", eCmdHdlrBinary, 0 }, /* legacy: omfileasyncwriting */
+	{ "flushontxend", eCmdHdlrBinary, 0 }, /* legacy: omfileflushontxend */
+	{ "iobuffersize", eCmdHdlrSize, 0 }, /* legacy: omfileiobuffersize */
+	{ "dirowner", eCmdHdlrUID, 0 }, /* legacy: dirowner */
+	{ "dirgroup", eCmdHdlrGID, 0 }, /* legacy: dirgroup */
+	{ "fileowner", eCmdHdlrUID, 0 }, /* legacy: fileowner */
+	{ "filegroup", eCmdHdlrGID, 0 }, /* legacy: filegroup */
+	{ "dircreatemode", eCmdHdlrFileCreateMode, 0 }, /* legacy: dircreatemode */
+	{ "filecreatemode", eCmdHdlrFileCreateMode, 0 }, /* legacy: filecreatemode */
+	{ "failonchownfailure", eCmdHdlrBinary, 0 }, /* legacy: failonchownfailure */
+	{ "createdirs", eCmdHdlrBinary, 0 }, /* legacy: createdirs */
+	{ "sync", eCmdHdlrBinary, 0 }, /* legacy: actionfileenablesync */
+	{ "file", eCmdHdlrString, 0 },     /* either "file" or ... */
+	{ "dynafile", eCmdHdlrString, 0 }, /* "dynafile" MUST be present */
+	{ "template", eCmdHdlrGetWord, 0 },
+};
+static struct cnfparamblk actpblk =
+	{ CNFPARAMBLK_VERSION,
+	  sizeof(actpdescr)/sizeof(struct cnfparamdescr),
+	  actpdescr
+	};
+
+
+/* this function gets the default template. It coordinates action between
+ * old-style and new-style configuration parts.
+ */
+static inline uchar*
+getDfltTpl(void)
+{
+	if(loadModConf != NULL && loadModConf->tplName != NULL)
+		return loadModConf->tplName;
+	else if(pszFileDfltTplName == NULL)
+		return (uchar*)"RSYSLOG_FileFormat";
+	else
+		return pszFileDfltTplName;
+}
+
+
+BEGINinitConfVars		/* (re)set config variables to default values */
+CODESTARTinitConfVars 
+	pszFileDfltTplName = NULL; /* make sure this can be free'ed! */
+	iRet = resetConfigVariables(NULL, NULL); /* params are dummies */
+ENDinitConfVars
+
 BEGINisCompatibleWithFeature
 CODESTARTisCompatibleWithFeature
 	if(eFeat == sFEATURERepeatedMsgReduction)
@@ -190,7 +261,7 @@ CODESTARTdbgPrintInstInfo
 		dbgprintf("[dynamic]\n");
 	} else { /* regular file */
 		dbgprintf("%s%s\n", pData->f_fname,
-			  (pData->pStrm == NULL) ? " (unused)" : "");
+			  (pData->pStrm == NULL) ? " (closed)" : "");
 	}
 
 	dbgprintf("\ttemplate='%s'\n", pData->f_fname);
@@ -200,7 +271,6 @@ CODESTARTdbgPrintInstInfo
 	dbgprintf("\tfile cache size=%d\n", pData->iDynaFileCacheSize);
 	dbgprintf("\tcreate directories: %s\n", pData->bCreateDirs ? "yes" : "no");
 	dbgprintf("\tfile owner %d, group %d\n", (int) pData->fileUID, (int) pData->fileGID);
-	dbgprintf("\tforce chown() for all files: %s\n", pData->bForceChown ? "yes" : "no"); 
 	dbgprintf("\tdirectory owner %d, group %d\n", (int) pData->dirUID, (int) pData->dirGID);
 	dbgprintf("\tdir create mode 0%3.3o, file create mode 0%3.3o\n",
 		  pData->fDirCreateMode, pData->fCreateMode);
@@ -208,6 +278,31 @@ CODESTARTdbgPrintInstInfo
 ENDdbgPrintInstInfo
 
 
+
+/* 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.
+ */
+rsRetVal
+setLegacyDfltTpl(void __attribute__((unused)) *pVal, uchar* newVal)
+{
+	DEFiRet;
+
+	if(loadModConf != NULL && loadModConf->tplName != NULL) {
+		free(newVal);
+		errmsg.LogError(0, RS_RET_ERR, "omfile default template already set via module "
+			"global parameter - can no longer be changed");
+		ABORT_FINALIZE(RS_RET_ERR);
+	}
+	free(pszFileDfltTplName);
+	pszFileDfltTplName = newVal;
+finalize_it:
+	RETiRet;
+}
+
+
 /* set the dynaFile cache size. Does some limit checking.
  * rgerhards, 2007-07-31
  */
@@ -232,7 +327,7 @@ rsRetVal setDynaFileCacheSize(void __attribute__((unused)) *pVal, int iNewVal)
 		iNewVal = 1000;
 	}
 
-	iDynaFileCacheSize = iNewVal;
+	cs.iDynaFileCacheSize = iNewVal;
 	DBGPRINTF("DynaFileCacheSize changed to %d.\n", iNewVal);
 
 	RETiRet;
@@ -288,15 +383,14 @@ static rsRetVal cflineParseOutchannel(instanceData *pData, uchar* p, omodStringR
 	}
 
 	/* OK, we finally got a correct template. So let's use it... */
-	ustrncpy(pData->f_fname, pOch->pszFileTemplate, MAXFNAME);
+	pData->f_fname = ustrdup(pOch->pszFileTemplate);
 	pData->iSizeLimit = pOch->uSizeLimit;
 	/* WARNING: It is dangerous "just" to pass the pointer. As we
 	 * never rebuild the output channel description, this is acceptable here.
 	 */
 	pData->pszSizeLimitCmd = pOch->cmdOnSizeLimit;
 
-	iRet = cflineParseTemplateName(&p, pOMSR, iEntry, iTplOpts,
-				       (pszFileDfltTplName == NULL) ? (uchar*)"RSYSLOG_FileFormat" : pszFileDfltTplName);
+	iRet = cflineParseTemplateName(&p, pOMSR, iEntry, iTplOpts, getDfltTpl());
 
 finalize_it:
 	RETiRet;
@@ -389,22 +483,7 @@ prepareFile(instanceData *pData, uchar *newFileName)
 	DEFiRet;
 
 	pData->pStrm = NULL;
-	if(access((char*)newFileName, F_OK) == 0) {
-		if(pData->bForceChown) {
-			/* Try to fix wrong ownership set by someone else. Note that this code
-			 * will no longer work once we have made the $PrivDrop code fully secure.
-			 * This change is based on an idea of Michael Terry, provided as part of
-			 * the effort to make rsyslogd the Ubuntu default syslogd.
-			 * rgerhards, 2009-09-11
-			 */
-			if(chown((char*)newFileName, pData->fileUID, pData->fileGID) != 0) {
-				if(pData->bFailOnChown) {
-					int eSave = errno;
-					errno = eSave;
-				}
-			}
-		}
-	} else {
+	if(access((char*)newFileName, F_OK) != 0) {
 		/* file does not exist, create it (and eventually parent directories */
 		if(pData->bCreateDirs) {
 			/* We first need to create parent dirs if they are missing.
@@ -424,7 +503,7 @@ prepareFile(instanceData *pData, uchar *newFileName)
 				pData->fCreateMode);
 		if(fd != -1) {
 			/* check and set uid/gid */
-			if(pData->bForceChown || pData->fileUID != (uid_t)-1 || pData->fileGID != (gid_t) -1) {
+			if(pData->fileUID != (uid_t)-1 || pData->fileGID != (gid_t) -1) {
 				/* we need to set owner/group */
 				if(fchown(fd, pData->fileUID, pData->fileGID) != 0) {
 					if(pData->bFailOnChown) {
@@ -459,9 +538,9 @@ prepareFile(instanceData *pData, uchar *newFileName)
 	CHKiRet(strm.SetiZipLevel(pData->pStrm, pData->iZipLevel));
 	CHKiRet(strm.SetsIOBufSize(pData->pStrm, (size_t) pData->iIOBufSize));
 	CHKiRet(strm.SettOperationsMode(pData->pStrm, STREAMMODE_WRITE_APPEND));
-	CHKiRet(strm.SettOpenMode(pData->pStrm, fCreateMode));
+	CHKiRet(strm.SettOpenMode(pData->pStrm, cs.fCreateMode));
 	CHKiRet(strm.SetbSync(pData->pStrm, pData->bSyncFile));
-	CHKiRet(strm.SetsType(pData->pStrm, pData->strmType));
+	CHKiRet(strm.SetsType(pData->pStrm, STREAMTYPE_FILE_SINGLE));
 	CHKiRet(strm.SetiSizeLimit(pData->pStrm, pData->iSizeLimit));
 	/* set the flush interval only if we actually use it - otherwise it will activate
 	 * async processing, which is a real performance waste if we do not do buffered
@@ -624,7 +703,7 @@ doWrite(instanceData *pData, uchar *pszBuf, int lenBuf)
 	ASSERT(pData != NULL);
 	ASSERT(pszBuf != NULL);
 
-dbgprintf("write to stream, pData->pStrm %p, lenBuf %d\n", pData->pStrm, lenBuf);
+	DBGPRINTF("write to stream, pData->pStrm %p, lenBuf %d\n", pData->pStrm, lenBuf);
 	if(pData->pStrm != NULL){
 		CHKiRet(strm.Write(pData->pStrm, pszBuf, lenBuf));
 		FINALIZE;
@@ -654,21 +733,85 @@ writeFile(uchar **ppString, unsigned iMsgOpts, instanceData *pData)
 	} else { /* "regular", non-dynafile */
 		if(pData->pStrm == NULL) {
 			CHKiRet(prepareFile(pData, pData->f_fname));
+			if(pData->pStrm == NULL) {
+				errmsg.LogError(0, RS_RET_NO_FILE_ACCESS, "Could no open output file '%s'", pData->f_fname);
+			}
 		}
 	}
 
 	CHKiRet(doWrite(pData, ppString[0], strlen(CHAR_CONVERT(ppString[0]))));
 
 finalize_it:
-	if(iRet != RS_RET_OK) {
-		/* in v5, we shall return different states for message-caused failure (but only there!) */
-		if(pData->strmType == STREAMTYPE_NAMED_PIPE)
-			iRet = RS_RET_DISABLE_ACTION; /* this is the traditional semantic -- rgerhards, 2010-01-15 */
-	}
 	RETiRet;
 }
 
 
+BEGINbeginCnfLoad
+CODESTARTbeginCnfLoad
+	loadModConf = pModConf;
+	pModConf->pConf = pConf;
+	pModConf->tplName = NULL;
+ENDbeginCnfLoad
+
+BEGINsetModCnf
+	struct cnfparamvals *pvals = NULL;
+	int i;
+CODESTARTsetModCnf
+	pvals = nvlstGetParams(lst, &modpblk, NULL);
+	if(pvals == NULL) {
+		errmsg.LogError(0, RS_RET_MISSING_CNFPARAMS, "error processing module "
+				"config parameters [module(...)]");
+		ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS);
+	}
+
+	if(Debug) {
+		dbgprintf("module (global) param blk for omfile:\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(pszFileDfltTplName != NULL) {
+				errmsg.LogError(0, RS_RET_DUP_PARAM, "omfile: warning: default template "
+						"was already set via legacy directive - may lead to inconsistent "
+						"results.");
+			}
+		} else {
+			dbgprintf("omfile: 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(pszFileDfltTplName);
+	pszFileDfltTplName = NULL;
+ENDendCnfLoad
+
+BEGINcheckCnf
+CODESTARTcheckCnf
+ENDcheckCnf
+
+BEGINactivateCnf
+CODESTARTactivateCnf
+	runModConf = pModConf;
+ENDactivateCnf
+
+BEGINfreeCnf
+CODESTARTfreeCnf
+	free(pModConf->tplName);
+ENDfreeCnf
+
+
 BEGINcreateInstance
 CODESTARTcreateInstance
 	pData->pStrm = NULL;
@@ -677,6 +820,7 @@ ENDcreateInstance
 
 BEGINfreeInstance
 CODESTARTfreeInstance
+	free(pData->f_fname);
 	if(pData->bDynamicName) {
 		dynaFileFreeCache(pData);
 	} else if(pData->pStrm != NULL)
@@ -717,7 +861,128 @@ finalize_it:
 ENDdoAction
 
 
+static inline void
+setInstParamDefaults(instanceData *pData)
+{
+	pData->f_fname = NULL;
+	pData->tplName = NULL;
+	pData->fileUID = -1;
+	pData->fileGID = -1;
+	pData->dirUID = -1;
+	pData->dirGID = -1;
+	pData->bFailOnChown = 1;
+	pData->iDynaFileCacheSize = 10;
+	pData->fCreateMode = 0644;
+	pData->fDirCreateMode = 0700;
+	pData->bCreateDirs = 1;
+	pData->bSyncFile = 0;
+	pData->iZipLevel = 0;
+	pData->bFlushOnTXEnd = FLUSHONTX_DFLT;
+	pData->iIOBufSize = IOBUF_DFLT_SIZE;
+	pData->iFlushInterval = FLUSH_INTRVL_DFLT;
+	pData->bUseAsyncWriter = USE_ASYNCWRITER_DFLT;
+}
+
+BEGINnewActInst
+	struct cnfparamvals *pvals;
+	uchar *tplToUse;
+	int i;
+CODESTARTnewActInst
+	DBGPRINTF("newActInst (omfile)\n");
+
+	pvals = nvlstGetParams(lst, &actpblk, NULL);
+	if(pvals == NULL) {
+		errmsg.LogError(0, RS_RET_MISSING_CNFPARAMS, "omfile: either the \"file\" or "
+				"\"dynfile\" parameter must be given");
+		ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS);
+	}
+
+	if(Debug) {
+		dbgprintf("action param blk in omfile:\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, "dynafilecachesize")) {
+			pData->iDynaFileCacheSize = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "ziplevel")) {
+			pData->iZipLevel = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "flushinterval")) {
+			pData->iFlushInterval = pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "asyncwriting")) {
+			pData->bUseAsyncWriter = pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "flushontxend")) {
+			pData->bFlushOnTXEnd = pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "iobuffersize")) {
+			pData->iIOBufSize = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "dirowner")) {
+			pData->dirUID = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "dirgroup")) {
+			pData->dirGID = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "fileowner")) {
+			pData->fileUID = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "filegroup")) {
+			pData->fileGID = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "dircreatemode")) {
+			pData->fDirCreateMode = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "filecreatemode")) {
+			pData->fCreateMode = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "failonchownfailure")) {
+			pData->bFailOnChown = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "sync")) {
+			pData->bSyncFile = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "createdirs")) {
+			pData->bCreateDirs = (int) pvals[i].val.d.n;
+		} else if(!strcmp(actpblk.descr[i].name, "file")) {
+			pData->f_fname = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL);
+			CODE_STD_STRING_REQUESTnewActInst(1)
+			pData->bDynamicName = 0;
+		} else if(!strcmp(actpblk.descr[i].name, "dynafile")) {
+			pData->f_fname = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL);
+			CODE_STD_STRING_REQUESTnewActInst(2)
+			pData->bDynamicName = 1;
+		} else if(!strcmp(actpblk.descr[i].name, "template")) {
+			pData->tplName = (uchar*)es_str2cstr(pvals[i].val.d.estr, NULL);
+		} else {
+			dbgprintf("omfile: program error, non-handled "
+			  "param '%s'\n", actpblk.descr[i].name);
+		}
+	}
+
+	if(pData->f_fname == NULL) {
+		errmsg.LogError(0, RS_RET_MISSING_CNFPARAMS, "omfile: either the \"file\" or "
+				"\"dynfile\" parameter must be given");
+		ABORT_FINALIZE(RS_RET_MISSING_CNFPARAMS);
+	}
+
+	tplToUse = (pData->tplName == NULL) ? ustrdup(getDfltTpl()) : pData->tplName;
+	CHKiRet(OMSRsetEntry(*ppOMSR, 0, tplToUse, OMSR_NO_RQD_TPL_OPTS));
+
+	if(pData->bDynamicName) {
+		/* "filename" is actually a template name, we need this as string 1. So let's add it
+		 * to the pOMSR. -- rgerhards, 2007-07-27
+		 */
+		CHKiRet(OMSRsetEntry(*ppOMSR, 1, ustrdup(pData->f_fname), OMSR_NO_RQD_TPL_OPTS));
+		// TODO: create unified code for this (legacy+v6 system)
+		/* we now allocate the cache table */
+		CHKmalloc(pData->dynCache = (dynaFileCacheEntry**)
+				calloc(cs.iDynaFileCacheSize, sizeof(dynaFileCacheEntry*)));
+		pData->iCurrElt = -1;		  /* no current element */
+	}
+// TODO: add	pData->iSizeLimit = 0; /* default value, use outchannels to configure! */
+
+CODE_STD_FINALIZERnewActInst
+	cnfparamvalsDestruct(pvals, &actpblk);
+ENDnewActInst
+
+
 BEGINparseSelectorAct
+	uchar fname[MAXFNAME];
 CODESTARTparseSelectorAct
 	/* Note: the indicator sequence permits us to use '$' to signify
 	 * outchannel, what otherwise is not possible due to truely 
@@ -726,13 +991,6 @@ CODESTARTparseSelectorAct
 	 */
 	if(!strncmp((char*) p, ":omfile:", sizeof(":omfile:") - 1)) {
 		p += sizeof(":omfile:") - 1;
-	} else {
-		if(*p == '$') {
-			errmsg.LogError(0, RS_RET_OUTDATED_STMT,
-				"action '%s' treated as ':omfile:%s' - please "
-				"change syntax, '%s' will not be supported in "
-				"rsyslog v6 and above.", p, p, p);
-		}
 	} 
 	if(!(*p == '$' || *p == '?' || *p == '/' || *p == '.' || *p == '-'))
 		ABORT_FINALIZE(RS_RET_CONFLINE_UNPROCESSED);
@@ -743,7 +1001,7 @@ CODESTARTparseSelectorAct
 		pData->bSyncFile = 0;
 		p++;
 	} else {
-		pData->bSyncFile = bEnableSync;
+		pData->bSyncFile = cs.bEnableSync;
 	}
 	pData->iSizeLimit = 0; /* default value, use outchannels to configure! */
 
@@ -766,39 +1024,24 @@ CODESTARTparseSelectorAct
 		   */
 		CODE_STD_STRING_REQUESTparseSelectorAct(2)
 		++p; /* eat '?' */
-		CHKiRet(cflineParseFileName(p, (uchar*) pData->f_fname, *ppOMSR, 0, OMSR_NO_RQD_TPL_OPTS,
-				               (pszFileDfltTplName == NULL) ? (uchar*)"RSYSLOG_FileFormat" : pszFileDfltTplName));
+		CHKiRet(cflineParseFileName(p, fname, *ppOMSR, 0, OMSR_NO_RQD_TPL_OPTS, getDfltTpl()));
+		pData->f_fname = ustrdup(fname);
+		pData->bDynamicName = 1;
+		pData->iCurrElt = -1;		  /* no current element */
 		/* "filename" is actually a template name, we need this as string 1. So let's add it
 		 * to the pOMSR. -- rgerhards, 2007-07-27
 		 */
 		CHKiRet(OMSRsetEntry(*ppOMSR, 1, ustrdup(pData->f_fname), OMSR_NO_RQD_TPL_OPTS));
-
-		pData->bDynamicName = 1;
-		pData->iCurrElt = -1;		  /* no current element */
 		/* we now allocate the cache table */
 		CHKmalloc(pData->dynCache = (dynaFileCacheEntry**)
-				calloc(iDynaFileCacheSize, sizeof(dynaFileCacheEntry*)));
+				calloc(cs.iDynaFileCacheSize, sizeof(dynaFileCacheEntry*)));
 		break;
 
-        /* case '|': while pipe support has been removed, I leave the code in in case we 
-	 *           need high-performance pipes at a later stage (unlikely). -- rgerhards, 2010-02-28
-	 */
 	case '/':
 	case '.':
 		CODE_STD_STRING_REQUESTparseSelectorAct(1)
-		/* we now have *almost* the same semantics for files and pipes, but we still need
-		 * to know we deal with a pipe, because we must do non-blocking opens in that case
-		 * (to keep consistent with traditional semantics and prevent rsyslog from hanging).
-		 */
-		if(*p == '|') {
-			++p;
-			pData->strmType = STREAMTYPE_NAMED_PIPE;
-		} else {
-			pData->strmType = STREAMTYPE_FILE_SINGLE;
-		}
-
-		CHKiRet(cflineParseFileName(p, (uchar*) pData->f_fname, *ppOMSR, 0, OMSR_NO_RQD_TPL_OPTS,
-				               (pszFileDfltTplName == NULL) ? (uchar*)"RSYSLOG_FileFormat" : pszFileDfltTplName));
+		CHKiRet(cflineParseFileName(p, fname, *ppOMSR, 0, OMSR_NO_RQD_TPL_OPTS, getDfltTpl()));
+		pData->f_fname = ustrdup(fname);
 		pData->bDynamicName = 0;
 		break;
 	default:
@@ -806,33 +1049,20 @@ CODESTARTparseSelectorAct
 	}
 
 	/* freeze current paremeters for this action */
-	pData->iDynaFileCacheSize = iDynaFileCacheSize;
-	pData->fCreateMode = fCreateMode;
-	pData->fDirCreateMode = fDirCreateMode;
-	pData->bCreateDirs = bCreateDirs;
-	pData->bFailOnChown = bFailOnChown;
-	pData->bForceChown = bForceChown;
-	pData->fileUID = fileUID;
-	pData->fileGID = fileGID;
-	pData->dirUID = dirUID;
-	pData->dirGID = dirGID;
-	pData->iZipLevel = iZipLevel;
-	pData->bFlushOnTXEnd = bFlushOnTXEnd;
-	pData->iIOBufSize = (int) iIOBufSize;
-	pData->iFlushInterval = iFlushInterval;
-	pData->bUseAsyncWriter = bUseAsyncWriter;
-
-	if(pData->bDynamicName == 0) {
-		/* try open and emit error message if not possible. At this stage, we ignore the
-		 * return value of prepareFile, this is taken care of in later steps.
-		 */
-		prepareFile(pData, pData->f_fname);
-		        
-	  	if(pData->pStrm == NULL) {
-			DBGPRINTF("Error opening log file: %s\n", pData->f_fname);
-			errmsg.LogError(0, RS_RET_NO_FILE_ACCESS, "Could not open output file '%s'", pData->f_fname);
-		}
-	}
+	pData->iDynaFileCacheSize = cs.iDynaFileCacheSize;
+	pData->fCreateMode = cs.fCreateMode;
+	pData->fDirCreateMode = cs.fDirCreateMode;
+	pData->bCreateDirs = cs.bCreateDirs;
+	pData->bFailOnChown = cs.bFailOnChown;
+	pData->fileUID = cs.fileUID;
+	pData->fileGID = cs.fileGID;
+	pData->dirUID = cs.dirUID;
+	pData->dirGID = cs.dirGID;
+	pData->iZipLevel = cs.iZipLevel;
+	pData->bFlushOnTXEnd = cs.bFlushOnTXEnd;
+	pData->iIOBufSize = (int) cs.iIOBufSize;
+	pData->iFlushInterval = cs.iFlushInterval;
+	pData->bUseAsyncWriter = cs.bUseAsyncWriter;
 CODE_STD_FINALIZERparseSelectorAct
 ENDparseSelectorAct
 
@@ -842,26 +1072,23 @@ ENDparseSelectorAct
  */
 static rsRetVal resetConfigVariables(uchar __attribute__((unused)) *pp, void __attribute__((unused)) *pVal)
 {
-	fileUID = -1;
-	fileGID = -1;
-	dirUID = -1;
-	dirGID = -1;
-	bFailOnChown = 1;
-	bForceChown = DFLT_bForceChown;
-	iDynaFileCacheSize = 10;
-	fCreateMode = 0644;
-	fDirCreateMode = 0700;
-	bCreateDirs = 1;
-	bEnableSync = 0;
-	iZipLevel = 0;
-	bFlushOnTXEnd = FLUSHONTX_DFLT;
-	iIOBufSize = IOBUF_DFLT_SIZE;
-	iFlushInterval = FLUSH_INTRVL_DFLT;
-	bUseAsyncWriter = USE_ASYNCWRITER_DFLT;
-	if(pszFileDfltTplName != NULL) {
-		free(pszFileDfltTplName);
-		pszFileDfltTplName = NULL;
-	}
+	cs.fileUID = -1;
+	cs.fileGID = -1;
+	cs.dirUID = -1;
+	cs.dirGID = -1;
+	cs.bFailOnChown = 1;
+	cs.iDynaFileCacheSize = 10;
+	cs.fCreateMode = 0644;
+	cs.fDirCreateMode = 0700;
+	cs.bCreateDirs = 1;
+	cs.bEnableSync = 0;
+	cs.iZipLevel = 0;
+	cs.bFlushOnTXEnd = FLUSHONTX_DFLT;
+	cs.iIOBufSize = IOBUF_DFLT_SIZE;
+	cs.iFlushInterval = FLUSH_INTRVL_DFLT;
+	cs.bUseAsyncWriter = USE_ASYNCWRITER_DFLT;
+	free(pszFileDfltTplName);
+	pszFileDfltTplName = NULL;
 
 	return RS_RET_OK;
 }
@@ -884,7 +1111,6 @@ BEGINmodExit
 CODESTARTmodExit
 	objRelease(errmsg, CORE_COMPONENT);
 	objRelease(strm, CORE_COMPONENT);
-	free(pszFileDfltTplName);
 	DESTROY_ATOMIC_HELPER_MUT(mutClock);
 ENDmodExit
 
@@ -892,6 +1118,9 @@ ENDmodExit
 BEGINqueryEtryPt
 CODESTARTqueryEtryPt
 CODEqueryEtryPt_STD_OMOD_QUERIES
+CODEqueryEtryPt_STD_CONF2_QUERIES
+CODEqueryEtryPt_STD_CONF2_setModCnf_QUERIES
+CODEqueryEtryPt_STD_CONF2_OMOD_QUERIES
 CODEqueryEtryPt_TXIF_OMOD_QUERIES /* we support the transactional interface! */
 CODEqueryEtryPt_doHUP
 ENDqueryEtryPt
@@ -901,6 +1130,7 @@ BEGINmodInit(File)
 CODESTARTmodInit
 	*ipIFVersProvided = CURR_MOD_IF_VERSION; /* we only support the current interface specification */
 CODEmodInit_QueryRegCFSLineHdlr
+INITLegCnfVars
 	CHKiRet(objUse(errmsg, CORE_COMPONENT));
 	CHKiRet(objUse(strm, CORE_COMPONENT));
 
@@ -909,22 +1139,22 @@ CODEmodInit_QueryRegCFSLineHdlr
 	INITChkCoreFeature(bCoreSupportsBatching, CORE_FEATURE_BATCHING);
 	DBGPRINTF("omfile: %susing transactional output interface.\n", bCoreSupportsBatching ? "" : "not ");
 	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dynafilecachesize", 0, eCmdHdlrInt, (void*) setDynaFileCacheSize, NULL, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileziplevel", 0, eCmdHdlrInt, NULL, &iZipLevel, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileflushinterval", 0, eCmdHdlrInt, NULL, &iFlushInterval, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileasyncwriting", 0, eCmdHdlrBinary, NULL, &bUseAsyncWriter, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileflushontxend", 0, eCmdHdlrBinary, NULL, &bFlushOnTXEnd, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileiobuffersize", 0, eCmdHdlrSize, NULL, &iIOBufSize, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dirowner", 0, eCmdHdlrUID, NULL, &dirUID, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dirgroup", 0, eCmdHdlrGID, NULL, &dirGID, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"fileowner", 0, eCmdHdlrUID, NULL, &fileUID, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"filegroup", 0, eCmdHdlrGID, NULL, &fileGID, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dircreatemode", 0, eCmdHdlrFileCreateMode, NULL, &fDirCreateMode, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"filecreatemode", 0, eCmdHdlrFileCreateMode, NULL, &fCreateMode, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"createdirs", 0, eCmdHdlrBinary, NULL, &bCreateDirs, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"failonchownfailure", 0, eCmdHdlrBinary, NULL, &bFailOnChown, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileForceChown", 0, eCmdHdlrBinary, NULL, &bForceChown, STD_LOADABLE_MODULE_ID));
-	CHKiRet(omsdRegCFSLineHdlr((uchar *)"actionfileenablesync", 0, eCmdHdlrBinary, NULL, &bEnableSync, STD_LOADABLE_MODULE_ID));
-	CHKiRet(regCfSysLineHdlr((uchar *)"actionfiledefaulttemplate", 0, eCmdHdlrGetWord, NULL, &pszFileDfltTplName, NULL));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileziplevel", 0, eCmdHdlrInt, NULL, &cs.iZipLevel, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileflushinterval", 0, eCmdHdlrInt, NULL, &cs.iFlushInterval, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileasyncwriting", 0, eCmdHdlrBinary, NULL, &cs.bUseAsyncWriter, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileflushontxend", 0, eCmdHdlrBinary, NULL, &cs.bFlushOnTXEnd, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileiobuffersize", 0, eCmdHdlrSize, NULL, &cs.iIOBufSize, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dirowner", 0, eCmdHdlrUID, NULL, &cs.dirUID, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dirgroup", 0, eCmdHdlrGID, NULL, &cs.dirGID, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"fileowner", 0, eCmdHdlrUID, NULL, &cs.fileUID, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"filegroup", 0, eCmdHdlrGID, NULL, &cs.fileGID, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"dircreatemode", 0, eCmdHdlrFileCreateMode, NULL, &cs.fDirCreateMode, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"filecreatemode", 0, eCmdHdlrFileCreateMode, NULL, &cs.fCreateMode, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"createdirs", 0, eCmdHdlrBinary, NULL, &cs.bCreateDirs, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"failonchownfailure", 0, eCmdHdlrBinary, NULL, &cs.bFailOnChown, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"omfileforcechown", 0, eCmdHdlrGoneAway, NULL, NULL, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"actionfileenablesync", 0, eCmdHdlrBinary, NULL, &cs.bEnableSync, STD_LOADABLE_MODULE_ID));
+	CHKiRet(omsdRegCFSLineHdlr((uchar *)"actionfiledefaulttemplate", 0, eCmdHdlrGetWord, setLegacyDfltTpl, NULL, STD_LOADABLE_MODULE_ID));
 	CHKiRet(omsdRegCFSLineHdlr((uchar *)"resetconfigvariables", 1, eCmdHdlrCustomHandler, resetConfigVariables, NULL, STD_LOADABLE_MODULE_ID));
 ENDmodInit
 /* vi:set ai: