path: root/runtime/prop.c

/* prop.c - rsyslog's prop object
 *
 * This object is meant to support message properties that are stored
 * seperately from the message. The main intent is to support properties
 * that are "constant" during a period of time, so that many messages may
 * contain a reference to the same property. It is important, though, that
 * properties are destroyed when they are no longer needed.
 *
 * Please note that this is a performance-critical part of the software and
 * as such we may use some methods in here which do not look elegant, but
 * which are fast...
 *
 * Module begun 2009-06-17 by Rainer Gerhards
 *
 * Copyright 2009-2016 Adiscon GmbH.
 *
 * This file is part of the rsyslog runtime library.
 *
 * 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 <stdlib.h>
#include <assert.h>
#include <string.h>

#include "rsyslog.h"
#include "obj.h"
#include "obj-types.h"
#include "unicode-helper.h"
#include "atomic.h"
#include "prop.h"

/* static data */
DEFobjStaticHelpers

//extern uchar *propGetSzStr(prop_t *pThis); /* expand inline function here */

/* Standard-Constructor
 */
BEGINobjConstruct(prop) /* be sure to specify the object type also in END macro! */
	pThis->iRefCount = 1;
	INIT_ATOMIC_HELPER_MUT(pThis->mutRefCount);
ENDobjConstruct(prop)


/* destructor for the prop object */
BEGINobjDestruct(prop) /* be sure to specify the object type also in END and CODESTART macros! */
	int currRefCount;
CODESTARTobjDestruct(prop)
	currRefCount = ATOMIC_DEC_AND_FETCH(&pThis->iRefCount, &pThis->mutRefCount);
	if(currRefCount == 0) {
		/* (only) in this case we need to actually destruct the object */
		if(pThis->len >= CONF_PROP_BUFSIZE)
			free(pThis->szVal.psz);
		DESTROY_ATOMIC_HELPER_MUT(pThis->mutRefCount);
	} else {
		pThis = NULL; /* tell framework NOT to destructing the object! */
	}
ENDobjDestruct(prop)

/* set string, we make our own private copy! This MUST only be called BEFORE
 * ConstructFinalize()!
 */
static rsRetVal SetString(prop_t *pThis, const uchar *psz, const int len)
{
	DEFiRet;
	ISOBJ_TYPE_assert(pThis, prop);
	if(pThis->len >= CONF_PROP_BUFSIZE)
		free(pThis->szVal.psz);
	pThis->len = len;
	if(len < CONF_PROP_BUFSIZE) {
		memcpy(pThis->szVal.sz, psz, len + 1);
	} else {
		if(pThis->szVal.psz != NULL) {
			free(pThis->szVal.psz);
		}
		CHKmalloc(pThis->szVal.psz = malloc(len + 1));
		memcpy(pThis->szVal.psz, psz, len + 1);
	}

finalize_it:
	RETiRet;
}


/* get string length */
static int GetStringLen(prop_t *pThis)
{
	return pThis->len;
}


/* get string */
static rsRetVal GetString(prop_t *pThis, uchar **ppsz, int *plen)
{
	ISOBJ_TYPE_assert(pThis, prop);
	if(pThis->len < CONF_PROP_BUFSIZE) {
		*ppsz = pThis->szVal.sz;
	} else {
		*ppsz = pThis->szVal.psz;
	}
	*plen = pThis->len;
	return RS_RET_OK;
}


/* ConstructionFinalizer
 * rgerhards, 2008-01-09
 */
static rsRetVal
propConstructFinalize(prop_t __attribute__((unused)) *pThis)
{
	DEFiRet;
	ISOBJ_TYPE_assert(pThis, prop);
	RETiRet;
}


/* add a new reference. It is VERY IMPORTANT to call this function whenever
 * the property is handed over to some entitiy that later call Destruct() on it.
 */
static rsRetVal AddRef(prop_t *pThis)
{
	if(pThis == NULL)  {
		DBGPRINTF("prop/AddRef is passed a NULL ptr - ignoring it "
			"- further problems may occur\n");
		FINALIZE;
	}
	ATOMIC_INC(&pThis->iRefCount, &pThis->mutRefCount);
finalize_it:
	return RS_RET_OK;
}


/* this is a "do it all in one shot" function that creates a new property,
 * assigns the provided string to it and finalizes the property. Among the
 * convenience, it is also (very, very) slightly faster.
 * rgerhards, 2009-07-01
 */
static rsRetVal CreateStringProp(prop_t **ppThis, const uchar* psz, const int len)
{
	prop_t *pThis = NULL;
	DEFiRet;

	CHKiRet(propConstruct(&pThis));
	CHKiRet(SetString(pThis, psz, len));
	CHKiRet(propConstructFinalize(pThis));
	*ppThis = pThis;
finalize_it:
	if(iRet != RS_RET_OK) {
		if(pThis != NULL)
			propDestruct(&pThis);
	}

	RETiRet;
}

/* another one-stop function, quite useful: it takes a property pointer and
 * a string. If the string is already contained in the property, nothing happens.
 * If the string is different (or the pointer NULL), the current property
 * is destructed and a new one created. This can be used to get a specific
 * name in those cases where there is a good chance that the property
 * immediatly previously processed already contained the value we need - in
 * which case we save us all the creation overhead by just reusing the already
 * existing property).
 * rgerhards, 2009-07-01
 */
static rsRetVal CreateOrReuseStringProp(prop_t **ppThis, const uchar *psz, const int len)
{
	uchar *pszPrev;
	int lenPrev;
	DEFiRet;
	assert(ppThis != NULL);

	if(*ppThis == NULL) {
		/* we need to create a property */
		CHKiRet(CreateStringProp(ppThis, psz, len));
	} else {
		/* already exists, check if we can re-use it */
		GetString(*ppThis, &pszPrev, &lenPrev);
		if(len != lenPrev || ustrcmp(psz, pszPrev)) {
			/* different, need to discard old & create new one */
			propDestruct(ppThis);
			CHKiRet(CreateStringProp(ppThis, psz, len));
		} /* else we can re-use the existing one! */
	}

finalize_it:
	RETiRet;
}


/* debugprint for the prop object */
BEGINobjDebugPrint(prop) /* be sure to specify the object type also in END and CODESTART macros! */
CODESTARTobjDebugPrint(prop)
	dbgprintf("prop object %p - no further debug info implemented\n", pThis);
ENDobjDebugPrint(prop)


/* queryInterface function
 * rgerhards, 2008-02-21
 */
BEGINobjQueryInterface(prop)
CODESTARTobjQueryInterface(prop)
	if(pIf->ifVersion != propCURR_IF_VERSION) { /* check for current version, increment on each change */
		ABORT_FINALIZE(RS_RET_INTERFACE_NOT_SUPPORTED);
	}

	/* ok, we have the right interface, so let's fill it
	 * Please note that we may also do some backwards-compatibility
	 * work here (if we can support an older interface version - that,
	 * of course, also affects the "if" above).
	 */
	pIf->Construct = propConstruct;
	pIf->ConstructFinalize = propConstructFinalize;
	pIf->Destruct = propDestruct;
	pIf->DebugPrint = propDebugPrint;
	pIf->SetString = SetString;
	pIf->GetString = GetString;
	pIf->GetStringLen = GetStringLen;
	pIf->AddRef = AddRef;
	pIf->CreateStringProp = CreateStringProp;
	pIf->CreateOrReuseStringProp = CreateOrReuseStringProp;

finalize_it:
ENDobjQueryInterface(prop)


/* Exit the prop class.
 * rgerhards, 2009-04-06
 */
BEGINObjClassExit(prop, OBJ_IS_CORE_MODULE) /* class, version */
ENDObjClassExit(prop)


/* Initialize the prop class. Must be called as the very first method
 * before anything else is called inside this class.
 * rgerhards, 2008-02-19
 */
BEGINObjClassInit(prop, 1, OBJ_IS_CORE_MODULE) /* class, version */
	/* request objects we use */

	/* set our own handlers */
	OBJSetMethodHandler(objMethod_DEBUGPRINT, propDebugPrint);
	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, propConstructFinalize);
ENDObjClassInit(prop)

/* vi:set ai:
 */