From: Jiri Vymazal <jvymazal@redhat.com>

Date: Mon, 28 Jun 2018 15:07:55 +0100

Subject: Imfile rewrite with symlink support

This commit greatly refactors imfile internal workings. It changes the

handling of inotify, FEN, and polling modes. Mostly unchanged is the

processing of the way a file is read and state files are kept.

This is about a 50% rewrite of the module.

Polling, inotify, and FEN modes now use greatly unified code. Some

differences still exists and may be changed with further commits. The

internal handling of wildcards and file detection has been completely

re-written from scratch. For example, previously when multi-level

wildcards were used these were not reliably detected. The code also

now provides much of the same functionality in all modes, most importantly

wildcards are now also supported in polling mode.

The refactoring sets ground for further enhancements and smaller

refactorings. This commit provides the same feature set that imfile

had previously.

Some specific changes:

bugfix: imfile did not pick up all files when not present

at startup

bugfix: directories only support "*" wildcard, no others

bugfix: parameter "sortfiles" did only work in FEN mode

provides the ability to dynamically add and remove files via

multi-level wildcards

the state file name currently has been changed to inode number

We change it to json and also change the way it is stored and loaded.

This sets base to additional improvements in imfile.

When imfile rewrites state files, it does not truncate previous

content. If the new content is smaller than the existing one, the

existing part will not be overwritten, resulting in invalid json.

That in turn can lead to some other failures.

This introduces symlink detection and following as well

as monitoring changes on them.

stream/bugfix: memory leak on stream open if filename as already generated - 

this can happen if imfile reads a state file. On each open, memory for the

file name can be lost.

(cherry picked from commit a03dccf8484d621fe06cb2d11816fbe921751e54 - https://gitlab.cee.redhat.com/rsyslog/rsyslog)

---

 plugins/imfile/imfile.c                          | 2264 ++++++++++++++++++++++---------------------

 runtime/msg.c                                    |   22 ++++++++++++++++++++++

 runtime/msg.h                                    |    1 +

 runtime/stream.c                                 |  136 ++++++++++++++++++++-------

 runtime/stream.h                                 |   17 ++++++++++++++---

 5 files changed, 1303 insertions(+), 1137 deletitions(-)

diff --git a/plugins/imfile/imfile.c b/plugins/imfile/imfile.c

index b0bc860bcd16beaecd67ce1b7c61991356ea5471..f8225d7068d8fc98edde7bbed194be1105b1696b 100644

--- a/plugins/imfile/imfile.c

+++ b/plugins/imfile/imfile.c

@@ -35,6 +35,7 @@

 #include <unistd.h>

 #include <glob.h>

 #include <poll.h>

+#include <json.h>

 #include <fnmatch.h>

 #ifdef HAVE_SYS_INOTIFY_H

 #include <sys/inotify.h>

@@ -56,6 +57,7 @@

 #include "stringbuf.h"

 #include "ruleset.h"

 #include "ratelimit.h"

+#include "parserif.h"

 #include <regex.h> // TODO: fix via own module

@@ -77,50 +81,19 @@ static int bLegacyCnfModGlobalsPermitted;/* are legacy module-global config para

 #define NUM_MULTISUB 1024 /* default max number of submits */

 #define DFLT_PollInterval 10

-

-#define INIT_FILE_TAB_SIZE 4 /* default file table size - is extended as needed, use 2^x value */

-#define INIT_FILE_IN_DIR_TAB_SIZE 1 /* initial size for "associated files tab" in directory table */

 #define INIT_WDMAP_TAB_SIZE 1 /* default wdMap table size - is extended as needed, use 2^x value */

-

 #define ADD_METADATA_UNSPECIFIED -1

+#define CONST_LEN_CEE_COOKIE 5

+#define CONST_CEE_COOKIE "@cee:"

+

+/* If set to 1, fileTableDisplay will be compiled and used for debugging */

+#define ULTRA_DEBUG 0

+

+/* Setting GLOB_BRACE to ZERO which disables support for GLOB_BRACE if not available on current platform */

+#ifndef GLOB_BRACE

+	#define GLOB_BRACE 0

+#endif

-/* this structure is used in pure polling mode as well one of the support

- * structures for inotify.

- */

-typedef struct lstn_s {

-	struct lstn_s *next, *prev;

-	struct lstn_s *masterLstn;/* if dynamic file (via wildcard), this points to the configured

-				 * master entry. For master entries, it is always NULL. Only

-				 * dynamic files can be deleted from the "files" list. */

-	uchar *pszFileName;

-	uchar *pszDirName;

-	uchar *pszBaseName;

-	uchar *pszTag;

-	size_t lenTag;

-	uchar *pszStateFile; /* file in which state between runs is to be stored (dynamic if NULL) */

-	int readTimeout;

-	int iFacility;

-	int iSeverity;

-	int maxLinesAtOnce;

-	uint32_t trimLineOverBytes;

-	int nRecords; /**< How many records did we process before persisting the stream? */

-	int iPersistStateInterval; /**< how often should state be persisted? (0=on close only) */

-	strm_t *pStrm;	/* its stream (NULL if not assigned) */

-	sbool bRMStateOnDel;

-	sbool hasWildcard;

-	uint8_t readMode;	/* which mode to use in ReadMulteLine call? */

-	uchar *startRegex;	/* regex that signifies end of message (NULL if unset) */

-	regex_t end_preg;	/* compiled version of startRegex */

-	uchar *prevLineSegment;	/* previous line segment (in regex mode) */

-	sbool escapeLF;	/* escape LF inside the MSG content? */

-	sbool reopenOnTruncate;

-	sbool addMetadata;

-	sbool addCeeTag;

-	sbool freshStartTail; /* read from tail of file on fresh start? */

-	ruleset_t *pRuleset;	/* ruleset to bind listener to (use system default if unspecified) */

-	ratelimit_t *ratelimiter;

-	multi_submit_t multiSub;

-} lstn_t;

 static struct configSettings_s {

 	uchar *pszFileName;

@@ -138,9 +111,11 @@ static struct configSettings_s {

 struct instanceConf_s {

 	uchar *pszFileName;

+	uchar *pszFileName_forOldStateFile; /* we unfortunately needs this to read old state files */

 	uchar *pszDirName;

 	uchar *pszFileBaseName;

 	uchar *pszTag;

+	size_t lenTag;

 	uchar *pszStateFile;

 	uchar *pszBindRuleset;

 	int nMultiSub;

@@ -151,11 +126,15 @@ struct instanceConf_s {

 	sbool bRMStateOnDel;

 	uint8_t readMode;

 	uchar *startRegex;

+	regex_t end_preg;	/* compiled version of startRegex */

+	sbool discardTruncatedMsg;

+	sbool msgDiscardingError;

 	sbool escapeLF;

 	sbool reopenOnTruncate;

 	sbool addCeeTag;

 	sbool addMetadata;

 	sbool freshStartTail;

+	sbool fileNotFoundError;

 	int maxLinesAtOnce;

 	uint32_t trimLineOverBytes;

 	ruleset_t *pBindRuleset;	/* ruleset to bind listener to (use system default if unspecified) */

@@ -163,9 +142,54 @@ struct instanceConf_s {

 };

+/* file system objects */

+typedef struct fs_edge_s fs_edge_t;

+typedef struct fs_node_s fs_node_t;

+typedef struct act_obj_s act_obj_t;

+struct act_obj_s {

+	act_obj_t *prev;

+	act_obj_t *next;

+	fs_edge_t *edge;	/* edge which this object belongs to */

+	char *name;		/* full path name of active object */

+	char *basename;		/* only basename */ //TODO: remove when refactoring rename support

+	char *source_name;  /* if this object is target of a symlink, source_name is its name (else NULL) */

+	//char *statefile;	/* base name of state file (for move operations) */

+	int wd;

+	time_t timeoutBase; /* what time to calculate the timeout against? */

+	/* file dynamic data */

+	int in_move;	/* workaround for inotify move: if set, state file must not be deleted */

+	ino_t ino;	/* current inode nbr */

+	strm_t *pStrm;	/* its stream (NULL if not assigned) */

+	int nRecords; /**< How many records did we process before persisting the stream? */

+	ratelimit_t *ratelimiter;

+	multi_submit_t multiSub;

+	int is_symlink;

+};

+struct fs_edge_s {

+	fs_node_t *parent;

+	fs_node_t *node;	/* node this edge points to */

+	fs_edge_t *next;

+	uchar *name;

+	uchar *path;

+	act_obj_t *active;

+	int is_file;

+	int ninst;	/* nbr of instances in instarr */

+	instanceConf_t **instarr;

+};

+struct fs_node_s {

+	fs_edge_t *edges;

+	fs_node_t *root;

+};

+

+

 /* forward definitions */

-static rsRetVal persistStrmState(lstn_t *pInfo);

+static rsRetVal persistStrmState(act_obj_t *);

 static rsRetVal resetConfigVariables(uchar __attribute__((unused)) *pp, void __attribute__((unused)) *pVal);

+static rsRetVal pollFile(act_obj_t *act);

+static int getBasename(uchar *const __restrict__ basen, uchar *const __restrict__ path);

+static void act_obj_unlink(act_obj_t *act);

+static uchar * getStateFileName(const act_obj_t *, uchar *, const size_t);

+static int getFullStateFileName(const uchar *const, uchar *const pszout, const size_t ilenout);

 #define OPMODE_POLLING 0

@@ -178,57 +200,23 @@ struct modConfData_s {

 	int readTimeout;

 	int timeoutGranularity;		/* value in ms */

 	instanceConf_t *root, *tail;

-	lstn_t *pRootLstn;

-	lstn_t *pTailLstn;

+	fs_node_t *conf_tree;

 	uint8_t opMode;

 	sbool configSetViaV2Method;

+	sbool sortFiles;

+	sbool normalizePath;	/* normalize file system pathes (all start with root dir) */

 	sbool haveReadTimeouts;	/* use special processing if read timeouts exist */

+	sbool bHadFileData;	/* actually a global variable:

+				   1 - last call to pollFile() had data

+				   0 - last call to pollFile() had NO data

+				   Must be manually reset to 0 if desired. Helper for

+				   polling mode.

+				 */

 };

 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 load process */

 #ifdef HAVE_INOTIFY_INIT

-/* support for inotify mode */

-

-/* we need to track directories */

-struct dirInfoFiles_s { /* associated files */

-	lstn_t *pLstn;

-	int refcnt;	/* due to inotify's async nature, we may have multiple

-			 * references to a single file inside our cache - e.g. when

-			 * inodes are removed, and the file name is re-created BUT another

-			 * process (like rsyslogd ;)) holds open the old inode.

-			 */

-};

-typedef struct dirInfoFiles_s dirInfoFiles_t;

-

-/* This structure is a dynamic table to track file entries */

-struct fileTable_s {

-	dirInfoFiles_t *listeners;

-	int currMax;

-	int allocMax;

-};

-typedef struct fileTable_s fileTable_t;

-

-/* The dirs table (defined below) contains one entry for each directory that

- * is to be monitored. For each directory, it contains array which point to

- * the associated *active* files as well as *configured* files. Note that

- * the configured files may currently not exist, but will be processed

- * when they are created.

- */

-struct dirInfo_s {

-	uchar *dirName;

-	fileTable_t active; /* associated active files */

-	fileTable_t configured; /* associated configured files */

-};

-typedef struct dirInfo_s dirInfo_t;

-static dirInfo_t *dirs = NULL;

-static int allocMaxDirs;

-static int currMaxDirs;

-/* the following two macros are used to select the correct file table */

-#define ACTIVE_FILE 1

-#define CONFIGURED_FILE 0

-

-

 /* We need to map watch descriptors to our actual objects. Unfortunately, the

  * inotify API does not provide us with any cookie, so a simple O(1) algorithm

  * cannot be done (what a shame...). We assume that maintaining the array is much

@@ -238,9 +226,7 @@ static int currMaxDirs;

  */

 struct wd_map_s {

 	int wd;		/* ascending sort key */

-	lstn_t *pLstn;	/* NULL, if this is a dir entry, otherwise pointer into listener(file) table */

-	int dirIdx;	/* index into dirs table, undefined if pLstn == NULL */

-	time_t timeoutBase; /* what time to calculate the timeout against? */

+	act_obj_t *act; /* point to related active object */

 };

 typedef struct wd_map_s wd_map_t;

 static wd_map_t *wdmap = NULL;

@@ -257,6 +243,8 @@ static struct cnfparamdescr modpdescr[] = {

 	{ "pollinginterval", eCmdHdlrPositiveInt, 0 },

 	{ "readtimeout", eCmdHdlrPositiveInt, 0 },

 	{ "timeoutgranularity", eCmdHdlrPositiveInt, 0 },

+	{ "sortfiles", eCmdHdlrBinary, 0 },

+	{ "normalizepath", eCmdHdlrBinary, 0 },

 	{ "mode", eCmdHdlrGetWord, 0 }

 };

 static struct cnfparamblk modpblk =

@@ -286,7 +274,8 @@ static struct cnfparamdescr inppdescr[] = {

 	{ "addceetag", eCmdHdlrBinary, 0 },

 	{ "statefile", eCmdHdlrString, CNFPARAM_DEPRECATED },

 	{ "readtimeout", eCmdHdlrPositiveInt, 0 },

-	{ "freshstarttail", eCmdHdlrBinary, 0}

+	{ "freshstarttail", eCmdHdlrBinary, 0},

+	{ "filenotfounderror", eCmdHdlrBinary, 0}

 };

 static struct cnfparamblk inppblk =

 	{ CNFPARAMBLK_VERSION,

@@ -297,18 +286,106 @@ static struct cnfparamblk inppblk =

 #include "im-helper.h" /* must be included AFTER the type definitions! */

-#ifdef HAVE_INOTIFY_INIT

-/* support for inotify mode */

+/* Support for "old cruft" state files will potentially become optional in the

+ * future (hopefully). To prepare so, we use conditional compilation with a

+ * fixed-true condition ;-) -- rgerhards, 2018-03-28

+ * reason: https://github.com/rsyslog/rsyslog/issues/2231#issuecomment-376862280

+ */

+#define ENABLE_V1_STATE_FILE_FORMAT_SUPPORT 1

+#ifdef ENABLE_V1_STATE_FILE_FORMAT_SUPPORT

+static uchar *

+OLD_getStateFileName(const instanceConf_t *const inst,

+	 uchar *const __restrict__ buf,

+	 const size_t lenbuf)

+{

+	DBGPRINTF("OLD_getStateFileName trying '%s'\n", inst->pszFileName_forOldStateFile);

+	snprintf((char*)buf, lenbuf - 1, "imfile-state:%s", inst->pszFileName_forOldStateFile);

+	buf[lenbuf-1] = '\0'; /* be on the safe side... */

+	uchar *p = buf;

+	for( ; *p ; ++p) {

+		if(*p == '/')

+			*p = '-';

+	}

+	return buf;

+}

-#if 0 /* enable if you need this for debugging */

+/* try to open an old-style state file for given file. If the state file does not

+ * exist or cannot be read, an error is returned.

+ */

+static rsRetVal

+OLD_openFileWithStateFile(act_obj_t *const act)

+{

+	DEFiRet;

+	strm_t *psSF = NULL;

+	uchar pszSFNam[MAXFNAME];

+	size_t lenSFNam;

+	struct stat stat_buf;

+	uchar statefile[MAXFNAME];

+	const instanceConf_t *const inst = act->edge->instarr[0];// TODO: same file, multiple instances?

+

+	uchar *const statefn = OLD_getStateFileName(inst, statefile, sizeof(statefile));

+	DBGPRINTF("OLD_openFileWithStateFile: trying to open state for '%s', state file '%s'\n",

+		  act->name, statefn);

+

+	/* Get full path and file name */

+	lenSFNam = getFullStateFileName(statefn, pszSFNam, sizeof(pszSFNam));

+

+	/* check if the file exists */

+	if(stat((char*) pszSFNam, &stat_buf) == -1) {

+		if(errno == ENOENT) {

+			DBGPRINTF("OLD_openFileWithStateFile: NO state file (%s) exists for '%s'\n",

+				pszSFNam, act->name);

+			ABORT_FINALIZE(RS_RET_FILE_NOT_FOUND);

+		} else {

+			char errStr[1024];

+			rs_strerror_r(errno, errStr, sizeof(errStr));

+			DBGPRINTF("OLD_openFileWithStateFile: error trying to access state "

+				"file for '%s':%s\n", act->name, errStr);

+			ABORT_FINALIZE(RS_RET_IO_ERROR);

+		}

+	}

+

+	/* If we reach this point, we have a state file */

+

+	DBGPRINTF("old state file found - instantiating from it\n");

+	CHKiRet(strm.Construct(&psSF));

+	CHKiRet(strm.SettOperationsMode(psSF, STREAMMODE_READ));

+	CHKiRet(strm.SetsType(psSF, STREAMTYPE_FILE_SINGLE));

+	CHKiRet(strm.SetFName(psSF, pszSFNam, lenSFNam));

+	CHKiRet(strm.SetFileNotFoundError(psSF, inst->fileNotFoundError));

+	CHKiRet(strm.ConstructFinalize(psSF));

+

+	/* read back in the object */

+	CHKiRet(obj.Deserialize(&act->pStrm, (uchar*) "strm", psSF, NULL, act));

+	free(act->pStrm->pszFName);

+	CHKmalloc(act->pStrm->pszFName = ustrdup(act->name));

+

+	strm.CheckFileChange(act->pStrm);

+	CHKiRet(strm.SeekCurrOffs(act->pStrm));

+

+	/* we now persist the new state file and delete the old one, so we will

+	 * never have to deal with the old one. */

+	persistStrmState(act);

+	unlink((char*)pszSFNam);

+

+finalize_it:

+	if(psSF != NULL)

+		strm.Destruct(&psSF);

+	RETiRet;

+}

+#endif /* #ifdef ENABLE_V1_STATE_FILE_FORMAT_SUPPORT */

+

+

+#ifdef HAVE_INOTIFY_INIT

+#if ULTRA_DEBUG == 1

 static void

-dbg_wdmapPrint(char *msg)

+dbg_wdmapPrint(const char *msg)

 {

 	int i;

 	DBGPRINTF("%s\n", msg);

 	for(i = 0 ; i < nWdmap ; ++i)

-		DBGPRINTF("wdmap[%d]: wd: %d, file %d, dir %d\n", i,

-			  wdmap[i].wd, wdmap[i].fIdx, wdmap[i].dirIdx);

+		DBGPRINTF("wdmap[%d]: wd: %d, act %p, name: %s\n",

+			i, wdmap[i].wd, wdmap[i].act, wdmap[i].act->name);

 }

 #endif

@@ -324,48 +401,10 @@ finalize_it:

 	RETiRet;

 }

-/* looks up a wdmap entry by dirIdx and returns it's index if found

- * or -1 if not found.

- */

-static int

-wdmapLookupListner(lstn_t* pLstn)

-{

-	int i = 0;

-	int wd = -1;

-	/* Loop through */

-	for(i = 0 ; i < nWdmap; ++i) {

-		if (wdmap[i].pLstn == pLstn)

-			wd = wdmap[i].wd;

-	}

-

-	return wd;

-}

-

-/* compare function for bsearch() */

-static int

-wdmap_cmp(const void *k, const void *a)

-{

-	int key = *((int*) k);

-	wd_map_t *etry = (wd_map_t*) a;

-	if(key < etry->wd)

-		return -1;

-	else if(key > etry->wd)

-		return 1;

-	else

-		return 0;

-}

-/* looks up a wdmap entry and returns it's index if found

- * or -1 if not found.

- */

-static wd_map_t *

-wdmapLookup(int wd)

-{

-	return bsearch(&wd, wdmap, nWdmap, sizeof(wd_map_t), wdmap_cmp);

-}

 /* note: we search backwards, as inotify tends to return increasing wd's */

 static rsRetVal

-wdmapAdd(int wd, const int dirIdx, lstn_t *const pLstn)

+wdmapAdd(int wd, act_obj_t *const act)

 {

 	wd_map_t *newmap;

 	int newmapsize;

@@ -375,7 +414,7 @@ wdmapAdd(int wd, const int dirIdx, lstn_t *const pLstn)

 	for(i = nWdmap-1 ; i >= 0 && wdmap[i].wd > wd ; --i)

 		; 	/* just scan */

 	if(i >= 0 && wdmap[i].wd == wd) {

-		DBGPRINTF("imfile: wd %d already in wdmap!\n", wd);

+		LogError(0, RS_RET_INTERNAL_ERROR, "imfile: wd %d already in wdmap!", wd);

 		ABORT_FINALIZE(RS_RET_FILE_ALREADY_IN_TABLE);

 	}

 	++i;

@@ -392,17 +431,59 @@ wdmapAdd(int wd, const int dirIdx, lstn_t *const pLstn)

 		memmove(wdmap + i + 1, wdmap + i, sizeof(wd_map_t) * (nWdmap - i));

 	}

 	wdmap[i].wd = wd;

-	wdmap[i].dirIdx = dirIdx;

-	wdmap[i].pLstn = pLstn;

+	wdmap[i].act = act;

 	++nWdmap;

-	DBGPRINTF("imfile: enter into wdmap[%d]: wd %d, dir %d, lstn %s:%s\n",i,wd,dirIdx,

-		  (pLstn == NULL) ? "DIRECTORY" : "FILE",

-	          (pLstn == NULL) ? dirs[dirIdx].dirName : pLstn->pszFileName);

+	DBGPRINTF("add wdmap[%d]: wd %d, act obj %p, path %s\n", i, wd, act, act->name);

 finalize_it:

 	RETiRet;

 }

+/* return wd or -1 on error */

+static int

+in_setupWatch(act_obj_t *const act, const int is_file)

+{

+	int wd = -1;

+	if(runModConf->opMode != OPMODE_INOTIFY)

+		goto done;

+

+	wd = inotify_add_watch(ino_fd, act->name,

+		(is_file) ? IN_MODIFY|IN_DONT_FOLLOW : IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO);

+	if(wd < 0) { /* There is high probability of selinux denial on top-level paths */

+		if (errno != EACCES)

+			LogError(errno, RS_RET_IO_ERROR, "imfile: cannot watch object '%s'", act->name);

+		else

+			DBGPRINTF("Access denied when creating watch on '%s'\n", act->name);

+		goto done;

+	}

+	wdmapAdd(wd, act);

+	DBGPRINTF("in_setupWatch: watch %d added for %s(object %p)\n", wd, act->name, act);

+done:	return wd;

+}

+

+/* compare function for bsearch() */

+static int

+wdmap_cmp(const void *k, const void *a)

+{

+	int key = *((int*) k);

+	wd_map_t *etry = (wd_map_t*) a;

+	if(key < etry->wd)

+		return -1;

+	else if(key > etry->wd)

+		return 1;

+	else

+		return 0;

+}

+/* looks up a wdmap entry and returns it's index if found

+ * or -1 if not found.

+ */

+static wd_map_t *

+wdmapLookup(int wd)

+{

+	return bsearch(&wd, wdmap, nWdmap, sizeof(wd_map_t), wdmap_cmp);

+}

+

+

 static rsRetVal

 wdmapDel(const int wd)

 {

@@ -427,46 +506,570 @@ finalize_it:

 	RETiRet;

 }

-#endif /* #if HAVE_INOTIFY_INIT */

+#endif // #ifdef HAVE_INOTIFY_INIT

+

+static void

+fen_setupWatch(act_obj_t *const __attribute__((unused)) act)

+{

+	DBGPRINTF("fen_setupWatch: DUMMY CALLED - not on Solaris?\n");

+}

+

+static void

+fs_node_print(const fs_node_t *const node, const int level)

+{

+	fs_edge_t *chld;

+	act_obj_t *act;

+	dbgprintf("node print[%2.2d]: %p edges:\n", level, node);

+

+	for(chld = node->edges ; chld != NULL ; chld = chld->next) {

+		dbgprintf("node print[%2.2d]:     child %p '%s' isFile %d, path: '%s'\n",

+			level, chld->node, chld->name, chld->is_file, chld->path);

+		for(int i = 0 ; i < chld->ninst ; ++i) {

+			dbgprintf("\tinst: %p\n", chld->instarr[i]);

+		}

+		for(act = chld->active ; act != NULL ; act = act->next) {

+			dbgprintf("\tact : %p\n", act);

+			dbgprintf("\tact : %p: name '%s', wd: %d\n",

+				act, act->name, act->wd);

+		}

+	}

+	for(chld = node->edges ; chld != NULL ; chld = chld->next) {

+		fs_node_print(chld->node, level+1);

+	}

+}

+

+/* add a new file system object if it not yet exists, ignore call

+ * if it already does.

+ */

+static rsRetVal

+act_obj_add(fs_edge_t *const edge, const char *const name, const int is_file,

+	const ino_t ino, const int is_symlink, const char *const source)

+{

+	act_obj_t *act;

+	char basename[MAXFNAME];

+	DEFiRet;

+	

+	DBGPRINTF("act_obj_add: edge %p, name '%s' (source '%s')\n", edge, name, source? source : "---");

+	for(act = edge->active ; act != NULL ; act = act->next) {

+		if(!strcmp(act->name, name)) {

+                       if (!source || !act->source_name || !strcmp(act->source_name, source)) {

+                               DBGPRINTF("active object '%s' already exists in '%s' - no need to add\n",

+                                       name, edge->path);

+                               FINALIZE;

+                       }

+		}

+	}

+	DBGPRINTF("add new active object '%s' in '%s'\n", name, edge->path);

+	CHKmalloc(act = calloc(sizeof(act_obj_t), 1));

+	CHKmalloc(act->name = strdup(name));

+       if (-1 == getBasename((uchar*)basename, (uchar*)name)) {

+               CHKmalloc(act->basename = strdup(name)); /* assume basename is same as name */

+       } else {

+               CHKmalloc(act->basename = strdup(basename));

+       }

+	act->edge = edge;

+	act->ino = ino;

+	act->is_symlink = is_symlink;

+       if (source) { /* we are target of symlink */

+               CHKmalloc(act->source_name = strdup(source));

+       } else {

+               act->source_name = NULL;

+       }

+	#ifdef HAVE_INOTIFY_INIT

+	act->wd = in_setupWatch(act, is_file);

+	#endif

+	fen_setupWatch(act);

+	if(is_file && !is_symlink) {

+		const instanceConf_t *const inst = edge->instarr[0];// TODO: same file, multiple instances?

+		CHKiRet(ratelimitNew(&act->ratelimiter, "imfile", name));

+		CHKmalloc(act->multiSub.ppMsgs = MALLOC(inst->nMultiSub * sizeof(smsg_t *)));

+		act->multiSub.maxElem = inst->nMultiSub;

+		act->multiSub.nElem = 0;

+		pollFile(act);

+	}

+

+	/* all well, add to active list */

+	if(edge->active != NULL) {

+		edge->active->prev = act;

+	}

+	act->next = edge->active;

+	edge->active = act;

+//dbgprintf("printout of fs tree after act_obj_add for '%s'\n", name);

+//fs_node_print(runModConf->conf_tree, 0);

+//dbg_wdmapPrint("wdmap after act_obj_add");

+finalize_it:

+	if(iRet != RS_RET_OK) {

+		if(act != NULL) {

+			free(act->name);

+			free(act);

+		}

+	}

+	RETiRet;

+}

+

+

+/* this walks an edges active list and detects and acts on any changes

+ * seen there. It does NOT detect newly appeared files, as they are not

+ * inside the active list!

+ */

+static void

+detect_updates(fs_edge_t *const edge)

+{

+	act_obj_t *act;

+	struct stat fileInfo;

+	int restart = 0;

+

+	for(act = edge->active ; act != NULL ; ) {

+		DBGPRINTF("detect_updates checking active obj '%s'\n", act->name);

+		const int r = lstat(act->name, &fileInfo);

+		if(r == -1) { /* object gone away? */

+			DBGPRINTF("object gone away, unlinking: '%s'\n", act->name);

+			act_obj_unlink(act);

+			restart = 1;

+			break;

+		}

+		// TODO: add inode check for change notification!

+

+		/* Note: active nodes may get deleted, so we need to do the

+		 * pointer advancement at the end of the for loop!

+		 */

+		act = act->next;

+	}

+	if (restart)

+		detect_updates(edge);

+}

+

+

+/* check if active files need to be processed. This is only needed in

+ * polling mode.

+ */

+static void

+poll_active_files(fs_edge_t *const edge)

+{

+	if(   runModConf->opMode != OPMODE_POLLING

+	   || !edge->is_file

+	   || glbl.GetGlobalInputTermState() != 0) {

+		return;

+	}

+

+	act_obj_t *act;

+	for(act = edge->active ; act != NULL ; act = act->next) {

+		fen_setupWatch(act);

+		DBGPRINTF("poll_active_files: polling '%s'\n", act->name);

+		pollFile(act);

+	}

+}

+

+static rsRetVal

+process_symlink(fs_edge_t *const chld, const char *symlink)