moved files to the runtime

there are still some files left which could go into the
runtime, but I think we will delete most of them once we
are done with the full modularization.

1 files changed, 0 insertions, 405 deletions

diff --git a/obj-types.h b/obj-types.h
deleted file mode 100644
index 4cd45153..00000000
--- a/obj-types.h
+++ /dev/null
@@ -1,405 +0,0 @@
-/* Some type definitions and macros for the obj object.
- * I needed to move them out of the main obj.h, because obj.h's
- * prototypes use other data types. However, their .h's rely
- * on some of the obj.h data types and macros. So I needed to break
- * that loop somehow and I've done that by moving the typedefs
- * into this file here.
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of rsyslog.
- *
- * Rsyslog is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Rsyslog is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Rsyslog.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- */
-
-#ifndef OBJ_TYPES_H_INCLUDED
-#define OBJ_TYPES_H_INCLUDED
-
-#include "stringbuf.h"
-#include "syslogd-types.h"
-
-/* property types for obj[De]Serialize() */
-typedef enum {
-	PROPTYPE_NONE = 0, /* currently no value set */
-	PROPTYPE_PSZ = 1,
-	PROPTYPE_SHORT = 2,
-	PROPTYPE_INT = 3,
-	PROPTYPE_LONG = 4,
-	PROPTYPE_INT64 = 5,
-	PROPTYPE_CSTR = 6,
-	PROPTYPE_SYSLOGTIME = 7
-} propType_t;
-
-typedef unsigned objID_t;
-
-typedef enum {	/* IDs of base methods supported by all objects - used for jump table, so
-		 * they must start at zero and be incremented. -- rgerhards, 2008-01-04
-		 */
-	objMethod_CONSTRUCT = 0,
-	objMethod_DESTRUCT = 1,
-	objMethod_SERIALIZE = 2,
-	objMethod_DESERIALIZE = 3,
-	objMethod_SETPROPERTY = 4,
-	objMethod_CONSTRUCTION_FINALIZER = 5,
-	objMethod_GETSEVERITY = 6,
-	objMethod_DEBUGPRINT = 7
-} objMethod_t;
-#define OBJ_NUM_METHODS 8	/* must be updated to contain the max number of methods supported */
-
-
-/* the base data type for interfaces
- * This MUST be in sync with the ifBEGIN macro
- */
-typedef struct interface_s {
-	int ifVersion;	/* must be set to version requested */ 
-	int ifIsLoaded; /* is the interface loaded? (0-no, 1-yes, 2-load failed; if not 1, functions can NOT be called! */
-} interface_t;
-
-
-typedef struct objInfo_s {
-	uchar *pszID; /* the object ID as a string */
-	size_t lenID; /* length of the ID string */
-	int iObjVers;
-	uchar *pszName;
-	rsRetVal (*objMethods[OBJ_NUM_METHODS])();
-	rsRetVal (*QueryIF)(interface_t*);
-	struct modInfo_s *pModInfo;
-} objInfo_t;
-
-
-typedef struct obj {	/* the dummy struct that each derived class can be casted to */
-	objInfo_t *pObjInfo;
-#ifndef NDEBUG /* this means if debug... */
-	unsigned int iObjCooCKiE; /* must always be 0xBADEFEE for a valid object */
-#endif
-	uchar *pszName;		/* the name of *this* specific object instance */
-} obj_t;
-
-
-/* macros which must be gloablly-visible (because they are used during definition of
- * other objects.
- */
-#ifndef NDEBUG /* this means if debug... */
-#include <string.h>
-#	define BEGINobjInstance \
-		obj_t objData
-#	define ISOBJ_assert(pObj) \
-		do { \
-		ASSERT((pObj) != NULL); \
-		ASSERT((unsigned) ((obj_t*)(pObj))->iObjCooCKiE == (unsigned) 0xBADEFEE); \
-		} while(0);
-#	define ISOBJ_TYPE_assert(pObj, objType) \
-		do { \
-		ASSERT(pObj != NULL); \
-		ASSERT((unsigned) ((obj_t*) (pObj))->iObjCooCKiE == (unsigned) 0xBADEFEE); \
-		ASSERT(!strcmp((char*)(((obj_t*)pObj)->pObjInfo->pszID), #objType)); \
-		} while(0);
-#else /* non-debug mode, no checks but much faster */
-#	define BEGINobjInstance obj_t objData
-#	define ISOBJ_TYPE_assert(pObj, objType)
-#	define ISOBJ_assert(pObj)
-#endif
-
-#define DEFpropSetMethPTR(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType *pVal)\
-	{ \
-		/* DEV debug: dbgprintf("%sSet%s()\n", #obj, #prop); */\
-		pThis->prop = pVal; \
-		return RS_RET_OK; \
-	}
-#define PROTOTYPEpropSetMethPTR(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType*)
-#define DEFpropSetMeth(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType pVal)\
-	{ \
-		/* DEV debug: dbgprintf("%sSet%s()\n", #obj, #prop); */\
-		pThis->prop = pVal; \
-		return RS_RET_OK; \
-	}
-#define DEFpropSetMethFP(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType)\
-	{ \
-		/* DEV debug: dbgprintf("%sSet%s()\n", #obj, #prop); */\
-		pThis->prop = pVal; \
-		return RS_RET_OK; \
-	}
-#define PROTOTYPEpropSetMethFP(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType)
-#define DEFpropSetMeth(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType pVal)\
-	{ \
-		/* DEV debug: dbgprintf("%sSet%s()\n", #obj, #prop); */\
-		pThis->prop = pVal; \
-		return RS_RET_OK; \
-	}
-#define PROTOTYPEpropSetMeth(obj, prop, dataType)\
-	rsRetVal obj##Set##prop(obj##_t *pThis, dataType pVal)
-#define INTERFACEpropSetMeth(obj, prop, dataType)\
-	rsRetVal (*Set##prop)(obj##_t *pThis, dataType)
-/* class initializer */
-#define PROTOTYPEObjClassInit(objName) rsRetVal objName##ClassInit(struct modInfo_s*)
-/* below: objName must be the object name (e.g. vm, strm, ...) and ISCORE must be
- * 1 if the module is a statically linked core module and 0 if it is a
- * dynamically loaded one. -- rgerhards, 2008-02-29
- */
-#define OBJ_IS_CORE_MODULE 1 /* This should better be renamed to something like "OBJ_IS_NOT_LIBHEAD" or so... ;) */
-#define OBJ_IS_LOADABLE_MODULE 0
-#define BEGINObjClassInit(objName, objVers, objType) \
-rsRetVal objName##ClassInit(struct modInfo_s *pModInfo) \
-{ \
-	DEFiRet; \
-	if(objType == OBJ_IS_CORE_MODULE) { /* are we a core module? */ \
-		CHKiRet(objGetObjInterface(&obj)); /* this provides the root pointer for all other queries */ \
-	} \
-	CHKiRet(obj.InfoConstruct(&pObjInfoOBJ, (uchar*) #objName, objVers, \
-	                         (rsRetVal (*)(void*))objName##Construct,\
-				 (rsRetVal (*)(void*))objName##Destruct,\
-				 (rsRetVal (*)(interface_t*))objName##QueryInterface, pModInfo)); \
-
-#define ENDObjClassInit(objName) \
-	iRet = obj.RegisterObj((uchar*)#objName, pObjInfoOBJ); \
-finalize_it: \
-	RETiRet; \
-}
-
-/* ... and now the same for abstract classes.
- * TODO: consolidate the two -- rgerhards, 2008-02-29
- */
-#define BEGINAbstractObjClassInit(objName, objVers, objType) \
-rsRetVal objName##ClassInit(struct modInfo_s *pModInfo) \
-{ \
-	DEFiRet; \
-	if(objType == OBJ_IS_CORE_MODULE) { /* are we a core module? */ \
-		CHKiRet(objGetObjInterface(&obj)); /* this provides the root pointer for all other queries */ \
-	} \
-	CHKiRet(obj.InfoConstruct(&pObjInfoOBJ, (uchar*) #objName, objVers, \
-	                         NULL,\
-				 NULL,\
-				 (rsRetVal (*)(interface_t*))objName##QueryInterface, pModInfo)); 
-
-#define ENDObjClassInit(objName) \
-	iRet = obj.RegisterObj((uchar*)#objName, pObjInfoOBJ); \
-finalize_it: \
-	RETiRet; \
-}
-
-
-/* now come the class exit. This is to be called immediately before the class is 
- * unloaded (actual unload for plugins, program termination for core modules)
- * gerhards, 2008-03-10
- */
-#define PROTOTYPEObjClassExit(objName) rsRetVal objName##ClassExit(void)
-#define BEGINObjClassExit(objName, objType) \
-rsRetVal objName##ClassExit(void) \
-{ \
-	DEFiRet;
-
-#define CODESTARTObjClassExit(objName)
-
-#define ENDObjClassExit(objName) \
-	iRet = obj.UnregisterObj((uchar*)#objName); \
-	RETiRet; \
-}
-
-/* this defines both the constructor and initializer
- * rgerhards, 2008-01-10
- */
-#define BEGINobjConstruct(obj) \
-	rsRetVal obj##Initialize(obj##_t __attribute__((unused)) *pThis) \
-	{ \
-		DEFiRet;
-
-#define ENDobjConstruct(obj) \
-		/* use finalize_it: before calling the macro (if you need it)! */ \
-		RETiRet; \
-	} \
-	rsRetVal obj##Construct(obj##_t **ppThis) \
-	{ \
-		DEFiRet; \
-		obj##_t *pThis; \
-	 \
-		ASSERT(ppThis != NULL); \
-	 \
-		if((pThis = (obj##_t *)calloc(1, sizeof(obj##_t))) == NULL) { \
-			ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY); \
-		} \
-		objConstructSetObjInfo(pThis); \
-	 \
-		obj##Initialize(pThis); \
-	\
-	finalize_it: \
-		OBJCONSTRUCT_CHECK_SUCCESS_AND_CLEANUP \
-		RETiRet; \
-	} 
-
-
-/* this defines the destructor. The important point is that the base object
- * destructor is called. The upper-level class shall destruct all of its
- * properties, but not the instance itself. This is freed here by the 
- * framework (we need an intact pointer because we need to free the
- * obj_t structures inside it). A pointer to the object pointer must be
- * parse, because it is re-set to NULL (this, for example, is important in
- * cancellation handlers). The object pointer is always named pThis.
- * The object is always freed, even if there is some error while
- * Cancellation is blocked during destructors, as this could have fatal
- * side-effects. However, this also means the upper-level object should
- * not perform any lenghty processing.
- * IMPORTANT: if the upper level object requires some situations where the
- * object shall not be destructed (e.g. via reference counting), then
- * it shall set pThis to NULL, which prevents destruction of the
- * object.
- * processing.
- * rgerhards, 2008-01-30
- */
-#define BEGINobjDestruct(OBJ) \
-	rsRetVal OBJ##Destruct(OBJ##_t **ppThis) \
-	{ \
-		DEFiRet; \
-		int iCancelStateSave; \
-		OBJ##_t *pThis; 
-
-#define CODESTARTobjDestruct(OBJ) \
-		ASSERT(ppThis != NULL); \
-		pThis = *ppThis; \
-		ISOBJ_TYPE_assert(pThis, OBJ); \
-		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &iCancelStateSave);
-
-#define ENDobjDestruct(OBJ) \
-	 	goto finalize_it; /* prevent compiler warning ;) */ \
-	 	/* no more code here! */ \
-	finalize_it: \
-		if(pThis != NULL) { \
-			obj.DestructObjSelf((obj_t*) pThis); \
-			free(pThis); \
-			*ppThis = NULL; \
-		} \
-		pthread_setcancelstate(iCancelStateSave, NULL); \
-		RETiRet; \
-	} 
-
-
-/* this defines the debug print entry point. DebugPrint is optional. If
- * it is provided, the object should output some meaningful information
- * via the debug system.
- * rgerhards, 2008-02-20
- */
-#define PROTOTYPEObjDebugPrint(obj) rsRetVal obj##DebugPrint(obj##_t *pThis)
-#define INTERFACEObjDebugPrint(obj) rsRetVal (*DebugPrint)(obj##_t *pThis)
-#define BEGINobjDebugPrint(obj) \
-	rsRetVal obj##DebugPrint(obj##_t *pThis) \
-	{ \
-		DEFiRet; \
-
-#define CODESTARTobjDebugPrint(obj) \
-		ASSERT(pThis != NULL); \
-		ISOBJ_TYPE_assert(pThis, obj); \
-
-#define ENDobjDebugPrint(obj) \
-		RETiRet; \
-	} 
-
-/* ------------------------------ object loader system ------------------------------ *
- * The following code is the early beginning of a dynamic object loader system. The 
- * root idea is that all objects will become dynamically loadable libraries over time,
- * which is necessary to get a clean plug-in interface where every plugin can access
- * rsyslog's rich object model via simple and quite portable methods.
- *
- * To do so, each object defines one or more interfaces. They are essentially structures
- * with function (method) pointers. Anyone interested in calling an object must first
- * obtain the interface and can then call through it.
- *
- * The interface data type must always be called <obj>_if_t, as this is expected
- * by the macros. Having consitent naming is also easier for the programmer. By default,
- * macros create a static variable named like the object in each calling objects
- * static data block.
- *
- * To facilitate moving to this system, I begin to implement some hooks, which
- * allows to use interfaces today (when the rest of the infrastructure is not yet
- * there). This is in the hope that it will ease migration to the full-fledged system
- * once we are ready to work on that.
- * rgerhards, 2008-02-21
- */
-
-/* this defines the QueryInterface print entry point. Over time, it should be
- * present in all objects.
- */
-//#define PROTOTYPEObjQueryInterface(obj) rsRetVal obj##QueryInterface(obj##_if_t *pThis)
-#define BEGINobjQueryInterface(obj) \
-	rsRetVal obj##QueryInterface(obj##_if_t *pIf) \
-	{ \
-		DEFiRet; \
-
-#define CODESTARTobjQueryInterface(obj) \
-		ASSERT(pIf != NULL);
-
-#define ENDobjQueryInterface(obj) \
-		RETiRet; \
-	} 
-
-
-/* the following macros should be used to define interfaces inside the
- * header files.
- */
-#define BEGINinterface(obj) \
-	typedef struct obj##_if_s {\
-		ifBEGIN;		/* This MUST always be the first interface member */
-#define ENDinterface(obj) \
-	} obj##_if_t;
-	
-/* the following macro is used to get access to an object (not an instance,
- * just the class itself!). It must be called before any of the object's
- * methods can be accessed. The MYLIB part is the name of my library, or NULL if
- * the caller is a core module. Using the right value here is important to get
- * the reference counting correct (object accesses from the same library must
- * not be counted because that would cause a library plugin to never unload, as
- * its ClassExit() entry points are only called if no object is referenced, which
- * would never happen as the library references itself.
- * rgerhards, 2008-03-11
- */
-#define CORE_COMPONENT NULL /* use this to indicate this is a core component */
-#define DONT_LOAD_LIB NULL /* do not load a library to obtain object interface (currently same as CORE_COMPONENT) */
-/*#define objUse(objName, MYLIB, FILENAME) \
-	obj.UseObj(__FILE__, (uchar*)#objName, MYLIB, (uchar*)FILENAME, (void*) &objName)
-*/
-#define objUse(objName, FILENAME) \
-	obj.UseObj(__FILE__, (uchar*)#objName, (uchar*)FILENAME, (void*) &objName)
-#define objRelease(objName, FILENAME) \
-	obj.ReleaseObj(__FILE__, (uchar*)#objName, (uchar*) FILENAME, (void*) &objName)
-
-/* defines data that must always be present at the very begin of the interface structure */
-#define ifBEGIN \
-	int ifVersion;	/* must be set to version requested */ \
-	int ifIsLoaded; /* is the interface loaded? (0-no, 1-yes; if no, functions can NOT be called! */
-
-
-/* use the following define some place in your static data (suggested right at
- * the beginning
- */
-#define DEFobjCurrIf(obj) \
-		static obj##_if_t obj = { .ifVersion = obj##CURR_IF_VERSION, .ifIsLoaded = 0 };
- 
-/* define the prototypes for a class - when we use interfaces, we just have few
- * functions that actually need to be non-static.
- */
-#define PROTOTYPEObj(obj) \
-	PROTOTYPEObjClassInit(obj); \
-	PROTOTYPEObjClassExit(obj);
-
-/* ------------------------------ end object loader system ------------------------------ */
-
-
-#include "modules.h"
-#endif /* #ifndef OBJ_TYPES_H_INCLUDED */