1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*! \file stringbuf.h
* \brief The counted string object
*
* This is the byte-counted string class for rsyslog. It is a replacement
* for classical \0 terminated string functions. We introduce it in
* the hope it will make the program more secure, obtain some performance
* and, most importantly, lay they foundation for syslog-protocol, which
* requires strings to be able to handle embedded \0 characters.
*
* \author Rainer Gerhards <rgerhards@adiscon.com>
* \date 2005-09-07
* Initial version begun.
*
* All functions in this "class" start with rsCStr (rsyslog Counted String).
* Copyright 2005
* Rainer Gerhards and Adiscon GmbH. All Rights Reserved.
* This code is placed under the GPL.
*/
#ifndef _STRINGBUF_H_INCLUDED__
#define _STRINGBUF_H_INCLUDED__ 1
/**
* The dynamic string buffer object.
*/
struct rsCStrObject
{
#ifndef NDEBUG
rsObjID OID; /**< object ID */
#endif
unsigned char *pBuf; /**< pointer to the string buffer, may be NULL if string is empty */
unsigned char *pszBuf; /**< pointer to the sz version of the string (after it has been created )*/
int iBufSize; /**< current maximum size of the string buffer */
int iStrLen; /**< length of the string in characters. */
int iAllocIncrement; /**< the amount of bytes the string should be expanded if it needs to */
};
typedef struct rsCStrObject rsCStrObj;
/**
* Construct a rsCStr object.
*/
rsCStrObj *rsCStrConstruct(void);
rsRetVal rsCStrConstructFromszStr(rsCStrObj **ppThis, unsigned char *sz);
rsRetVal rsCStrConstructFromCStr(rsCStrObj **ppThis, rsCStrObj *pFrom);
/**
* Destruct the string buffer object.
*/
void rsCStrDestruct(rsCStrObj *pThis);
/**
* Append a character to an existing string. If necessary, the
* method expands the string buffer.
*
* \param c Character to append to string.
*/
rsRetVal rsCStrAppendChar(rsCStrObj *pThis, unsigned char c);
/**
* Finish the string buffer dynamic allocation.
*/
rsRetVal rsCStrFinish(rsCStrObj *pThis);
/**
* Truncate "n" number of characters from the end of the
* string. The buffer remains unchanged, just the
* string length is manipulated. This is for performance
* reasons.
*/
rsRetVal rsCStrTruncate(rsCStrObj *pThis, int nTrunc);
rsRetVal rsCStrTrimTrailingWhiteSpace(rsCStrObj *pThis);
/**
* Append a string to the buffer. For performance reasons,
* use rsCStrAppenStrWithLen() if you know the length.
*
* \param psz pointer to string to be appended. Must not be NULL.
*/
rsRetVal rsCStrAppendStr(rsCStrObj *pThis, unsigned char* psz);
/**
* Append a string to the buffer.
*
* \param psz pointer to string to be appended. Must not be NULL.
* \param iStrLen the length of the string pointed to by psz
*/
rsRetVal rsCStrAppendStrWithLen(rsCStrObj *pThis, unsigned char* psz, size_t iStrLen);
/**
* Set a new allocation incremet. This will influence
* the allocation the next time the string will be expanded.
* It can be set and changed at any time. If done immediately
* after custructing the StrB object, this will also be
* the inital allocation.
*
* \param iNewIncrement The new increment size
*
* \note It is possible to use a very low increment, e.g. 1 byte.
* This can generate a considerable overhead. We highly
* advise not to use an increment below 32 bytes, except
* if you are very well aware why you are doing it ;)
*/
void rsCStrSetAllocIncrement(rsCStrObj *pThis, int iNewIncrement);
/**
* Append an integer to the string. No special formatting is
* done.
*/
rsRetVal rsCStrAppendInt(rsCStrObj *pThis, int i);
unsigned char* rsCStrGetSzStr(rsCStrObj *pThis);
unsigned char* rsCStrGetSzStrNoNULL(rsCStrObj *pThis);
rsRetVal rsCStrSetSzStr(rsCStrObj *pThis, unsigned char *pszNew);
unsigned char* rsCStrConvSzStrAndDestruct(rsCStrObj *pThis);
int rsCStrCStrCmp(rsCStrObj *pCS1, rsCStrObj *pCS2);
int rsCStrSzStrCmp(rsCStrObj *pCS1, unsigned char *psz, int iLenSz);
int rsCStrOffsetSzStrCmp(rsCStrObj *pCS1, int iOffset, unsigned char *psz, int iLenSz);
int rsCStrLocateSzStr(rsCStrObj *pCStr, unsigned char *sz);
int rsCStrLocateInSzStr(rsCStrObj *pThis, unsigned char *sz);
int rsCStrStartsWithSzStr(rsCStrObj *pCS1, unsigned char *psz, int iLenSz);
int rsCStrSzStrStartsWithCStr(rsCStrObj *pCS1, unsigned char *psz, int iLenSz);
/* now come inline-like functions */
#ifdef NDEBUG
# define rsCStrLen(x) ((x)->iStrLen)
#else
int rsCStrLen(rsCStrObj *pThis);
#endif
#define rsCStrGetBufBeg(x) ((x)->pBuf)
#endif /* single include */
|
