/* Sets the string object to the classigal sz-string provided.
* Any previously stored vlaue is discarded. If a NULL pointer
* the the new value (pszNew) is provided, an empty string is
* created (this is NOT an error!).
* rgerhards, 2005-10-18
*/
rsRetVal rsCStrSetSzStr(cstr_t *pThis, uchar *pszNew)
{
rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
free(pThis->pBuf);
free(pThis->pszBuf);
if(pszNew == NULL) {
pThis->iStrLen = 0;
pThis->iBufSize = 0;
pThis->pBuf = NULL;
pThis->pszBuf = NULL;
} else {
pThis->iStrLen = strlen((char*)pszNew);
pThis->iBufSize = pThis->iStrLen;
pThis->pszBuf = NULL;
/* now save the new value */
if((pThis->pBuf = (uchar*) MALLOC(sizeof(uchar) * pThis->iStrLen)) == NULL) {
RSFREEOBJ(pThis);
return RS_RET_OUT_OF_MEMORY;
}
/* we do NOT need to copy the \0! */
memcpy(pThis->pBuf, pszNew, pThis->iStrLen);
}
return RS_RET_OK;
}
/* Converts the CStr object to a classical zero-terminated C string,
* returns that string and destroys the CStr object. The returned string
* MUST be freed by the caller. The function might return NULL if
* no memory can be allocated.
*
* This is the NEW replacement for rsCStrConvSzStrAndDestruct which does
* no longer utilize a special buffer but soley works on pBuf (and also
* assumes that cstrFinalize had been called).
*
* Parameters are as follows:
* pointer to the object, pointer to string-pointer to receive string and
* bRetNULL: 0 - must not return NULL on empty string, return "" in that
* case, 1 - return NULL instead of an empty string.
* PLEASE NOTE: the caller must free the memory returned in ppSz in any case
* (except, of course, if it is NULL).
*/
rsRetVal cstrConvSzStrAndDestruct(cstr_t *pThis, uchar **ppSz, int bRetNULL)
{
DEFiRet;
uchar* pRetBuf;
rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
assert(ppSz != NULL);
assert(bRetNULL == 0 || bRetNULL == 1);
if(pThis->pBuf == NULL) {
if(bRetNULL == 0) {
CHKmalloc(pRetBuf = MALLOC(sizeof(uchar)));
*pRetBuf = '\0';
} else {
pRetBuf = NULL;
}
} else
pRetBuf = pThis->pBuf;
*ppSz = pRetBuf;
finalize_it:
/* We got it, now free the object ourselfs. Please note
* that we can NOT use the rsCStrDestruct function as it would
* also free the sz String buffer, which we pass on to the user.
*/
RSFREEOBJ(pThis);
RETiRet;
}
/* a helper function for rsCStr*Strf()
*/
static rsRetVal rsCStrConstructFromszStrv(cstr_t **ppThis, uchar *fmt, va_list ap)
{
DEFiRet;
cstr_t *pThis;
va_list ap2;
int len;
assert(ppThis != NULL);
va_copy(ap2, ap);
len = vsnprintf(NULL, 0, (char*)fmt, ap2);
va_end(ap2);
if(len < 0)
ABORT_FINALIZE(RS_RET_ERR);
CHKiRet(rsCStrConstruct(&pThis));
pThis->iBufSize = pThis->iStrLen = len;
len++; /* account for the \0 written by vsnprintf */
if((pThis->pBuf = (uchar*) MALLOC(sizeof(uchar) * len)) == NULL) {
RSFREEOBJ(pThis);
ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
}
vsnprintf((char*)pThis->pBuf, len, (char*)fmt, ap);
*ppThis = pThis;
finalize_it:
RETiRet;
}
void rsCStrDestruct(cstr_t **ppThis)
{
cstr_t *pThis = *ppThis;
free(pThis->pBuf);
RSFREEOBJ(pThis);
*ppThis = NULL;
}
/**
* Destruct a rsPars object and its associated string.
* rgerhards, 2005-09-26
*/
rsRetVal rsParsDestruct(rsParsObj *pThis)
{
rsCHECKVALIDOBJECT(pThis, OIDrsPars);
if(pThis->pCStr != NULL)
rsCStrDestruct(&pThis->pCStr);
RSFREEOBJ(pThis);
return RS_RET_OK;
}
/* construct from sz string
* rgerhards 2005-09-15
*/
rsRetVal rsCStrConstructFromszStr(cstr_t **ppThis, uchar *sz)
{
DEFiRet;
cstr_t *pThis;
assert(ppThis != NULL);
CHKiRet(rsCStrConstruct(&pThis));
pThis->iBufSize = pThis->iStrLen = strlen((char *) sz);
if((pThis->pBuf = (uchar*) MALLOC(sizeof(uchar) * pThis->iStrLen)) == NULL) {
RSFREEOBJ(pThis);
ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
}
/* we do NOT need to copy the \0! */
memcpy(pThis->pBuf, sz, pThis->iStrLen);
*ppThis = pThis;
finalize_it:
RETiRet;
}
/* construct from CStr object. only the counted string is
* copied, not the szString.
* rgerhards 2005-10-18
*/
rsRetVal rsCStrConstructFromCStr(cstr_t **ppThis, cstr_t *pFrom)
{
DEFiRet;
cstr_t *pThis;
assert(ppThis != NULL);
rsCHECKVALIDOBJECT(pFrom, OIDrsCStr);
CHKiRet(rsCStrConstruct(&pThis));
pThis->iBufSize = pThis->iStrLen = pFrom->iStrLen;
if((pThis->pBuf = (uchar*) MALLOC(sizeof(uchar) * pThis->iStrLen)) == NULL) {
RSFREEOBJ(pThis);
ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
}
/* copy properties */
memcpy(pThis->pBuf, pFrom->pBuf, pThis->iStrLen);
*ppThis = pThis;
finalize_it:
RETiRet;
}
/* construct from es_str_t string
* rgerhards 2010-12-03
*/
rsRetVal
cstrConstructFromESStr(cstr_t **ppThis, es_str_t *str)
{
DEFiRet;
cstr_t *pThis;
CHKiRet(rsCStrConstruct(&pThis));
pThis->iStrLen = es_strlen(str);
pThis->iBufSize = pThis->iStrLen + 1;
if((pThis->pBuf = (uchar*) MALLOC(pThis->iBufSize)) == NULL) {
RSFREEOBJ(pThis);
ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
}
/* we do NOT need to copy the \0! */
memcpy(pThis->pBuf, es_getBufAddr(str), pThis->iStrLen);
*ppThis = pThis;
finalize_it:
RETiRet;
}
