Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2007 Pekka Riikonen
+ Copyright (C) 1997 - 2008 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/******************************* Formatting *********************************/
-int silc_buffer_format(SilcBuffer dst, ...)
-{
- va_list ap;
- int ret;
-
- va_start(ap, dst);
- ret = silc_buffer_sformat_vp(NULL, dst, ap);
- va_end(ap);
-
- return ret;
-}
-
-int silc_buffer_format_vp(SilcBuffer dst, va_list ap)
-{
- return silc_buffer_sformat_vp(NULL, dst, ap);
-}
-
-int silc_buffer_sformat(SilcStack stack, SilcBuffer dst, ...)
-{
- va_list ap;
- int ret;
-
- va_start(ap, dst);
- ret = silc_buffer_sformat_vp(stack, dst, ap);
- va_end(ap);
-
- return ret;
-}
-
-int silc_buffer_sformat_vp(SilcStack stack, SilcBuffer dst, va_list ap)
+int silc_buffer_sformat_vp_i(SilcStack stack, SilcBuffer dst, va_list ap,
+ SilcBool process)
{
SilcParam fmt;
int flen = 0;
while (1) {
fmt = va_arg(ap, SilcParam);
- SILC_LOG_DEBUG(("Buffer format type %x", fmt));
+ SILC_LOG_DEBUG(("Buffer format type %d", fmt));
switch (fmt) {
case SILC_PARAM_FUNC:
void *val;
void *context;
int tmp_len;
+
func = va_arg(ap, SilcBufferFormatFunc);
val = va_arg(ap, void *);
context = va_arg(ap, void *);
+
+ if (!process)
+ break;
+
tmp_len = func(stack, dst, val, context);
if (tmp_len < 0)
goto fail;
}
}
break;
+
+ case SILC_PARAM_REGEX:
+ {
+ const char *regex = va_arg(ap, char *);
+ SilcBufferRegexFlags rflags = va_arg(ap, SilcUInt32);
+ SilcBufferStruct match, saved;
+ SilcBool match_all = (rflags & SILC_STR_REGEX_ALL) != 0;
+ SilcBool match_nl = (rflags & SILC_STR_REGEX_NL) != 0;
+ SilcBool ret;
+ unsigned char *saved_incl = NULL;
+ int matched = 0, ret_len;
+ va_list cp;
+
+ if (!process)
+ break;
+
+ if (!regex)
+ goto fail;
+
+ memset(&saved, 0, sizeof(saved));
+
+ if (match_nl) {
+ start_nl_match:
+ /* Match for '\n' in the buffer. If not found, treat as line
+ without '\n' (buffer has only one line, or this is last line). */
+ saved = *dst;
+ if (silc_regex_buffer(dst, "\n", &match, NULL))
+ dst->tail = match.tail;
+ }
+
+ start_match:
+ /* Match */
+ ret = silc_regex_buffer(dst, regex, &match, NULL);
+ ret ^= (rflags & SILC_STR_REGEX_NOT) != 0;
+ if (!ret) {
+ if (!matched && rflags & SILC_STR_REGEX_MISMATCH) {
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+ goto fail;
+ }
+ goto end_match;
+ }
+ matched++;
+
+ if (rflags & SILC_STR_REGEX_NOT)
+ match = *dst;
+
+ if (!(rflags & SILC_STR_REGEX_NO_ADVANCE)) {
+ /* Advance buffer after match */
+ flen += (match.data - dst->data);
+ if (!silc_buffer_pull(dst, (match.data - dst->data)))
+ goto fail;
+ }
+
+ if (rflags & SILC_STR_REGEX_INCLUSIVE) {
+ saved_incl = dst->tail;
+ dst->tail = match.tail;
+ }
+
+ /* Recursively format */
+ silc_va_copy(cp, ap);
+ ret_len = silc_buffer_sformat_vp_i(stack, dst, cp, TRUE);
+ va_end(cp);
+ if (ret_len < 0)
+ goto fail;
+
+ if (rflags & SILC_STR_REGEX_INCLUSIVE)
+ dst->tail = saved_incl;
+
+ /* Advance buffer after formatting */
+ flen += ret_len;
+ if (!silc_buffer_pull(dst, ret_len))
+ goto fail;
+
+ if (match_all && (!match_nl || silc_buffer_len(dst) > 1))
+ goto start_match;
+
+ end_match:
+ if (match_nl) {
+ /* Go to next line, it is at the end of the data area. Adjust
+ the tail area of the target buffer to show rest of the buffer. */
+ flen += (dst->tail - dst->data);
+ if (!silc_buffer_pull(dst, (dst->tail - dst->data)))
+ goto fail;
+ if (!silc_buffer_pull_tail(dst, (saved.tail - dst->tail)))
+ goto fail;
+
+ if (silc_buffer_len(dst) > 0)
+ goto start_nl_match;
+ }
+
+ /* Skip to the next SILC_PARAM_END */
+ silc_buffer_sformat_vp_i(NULL, NULL, ap, FALSE);
+ }
+ break;
+
case SILC_PARAM_UI8_STRING:
case SILC_PARAM_UI16_STRING:
case SILC_PARAM_UI32_STRING:
{
char *x = va_arg(ap, char *);
SilcUInt32 tmp_len = x ? strlen(x) : 0;
+
+ if (!process)
+ break;
+
if (x && tmp_len) {
FORMAT_HAS_SPACE(stack, dst, tmp_len);
silc_buffer_put(dst, (unsigned char *)x, tmp_len);
}
break;
}
+
case SILC_PARAM_UI8_NSTRING:
case SILC_PARAM_UI16_NSTRING:
case SILC_PARAM_UI32_NSTRING:
{
unsigned char *x = va_arg(ap, unsigned char *);
SilcUInt32 tmp_len = va_arg(ap, SilcUInt32);
+
+ if (!process)
+ break;
+
if (x && tmp_len) {
FORMAT_HAS_SPACE(stack, dst, tmp_len);
silc_buffer_put(dst, x, tmp_len);
}
break;
}
+
case SILC_PARAM_UINT8:
{
unsigned char x = (unsigned char)va_arg(ap, int);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, 1);
silc_buffer_put(dst, &x, 1);
silc_buffer_pull(dst, 1);
break;
}
+
case SILC_PARAM_UINT16:
{
unsigned char xf[2];
SilcUInt16 x = (SilcUInt16)va_arg(ap, int);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, 2);
SILC_PUT16_MSB(x, xf);
silc_buffer_put(dst, xf, 2);
silc_buffer_pull(dst, 2);
break;
}
+
case SILC_PARAM_UINT32:
{
unsigned char xf[4];
SilcUInt32 x = va_arg(ap, SilcUInt32);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, 4);
SILC_PUT32_MSB(x, xf);
silc_buffer_put(dst, xf, 4);
silc_buffer_pull(dst, 4);
break;
}
+
case SILC_PARAM_UINT64:
{
unsigned char xf[8];
SilcUInt64 x = va_arg(ap, SilcUInt64);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, sizeof(SilcUInt64));
SILC_PUT64_MSB(x, xf);
silc_buffer_put(dst, xf, sizeof(SilcUInt64));
silc_buffer_pull(dst, sizeof(SilcUInt64));
break;
}
+
case SILC_PARAM_SINT8:
{
char x = (char)va_arg(ap, int);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, 1);
silc_buffer_put(dst, (unsigned char *)&x, 1);
silc_buffer_pull(dst, 1);
break;
}
+
case SILC_PARAM_SINT16:
{
unsigned char xf[2];
SilcInt16 x = (SilcInt16)va_arg(ap, int);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, 2);
SILC_PUT16_MSB(x, xf);
silc_buffer_put(dst, xf, 2);
silc_buffer_pull(dst, 2);
break;
}
+
case SILC_PARAM_SINT32:
{
unsigned char xf[4];
SilcInt32 x = va_arg(ap, SilcInt32);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, 4);
SILC_PUT32_MSB(x, xf);
silc_buffer_put(dst, xf, 4);
silc_buffer_pull(dst, 4);
break;
}
+
case SILC_PARAM_SINT64:
{
unsigned char xf[8];
SilcInt64 x = va_arg(ap, SilcInt64);
+
+ if (!process)
+ break;
+
FORMAT_HAS_SPACE(stack, dst, sizeof(SilcInt64));
SILC_PUT64_MSB(x, xf);
silc_buffer_put(dst, xf, sizeof(SilcInt64));
silc_buffer_pull(dst, sizeof(SilcInt64));
break;
}
+
case SILC_PARAM_BUFFER:
case SILC_PARAM_BUFFER | SILC_PARAM_ALLOC:
{
SilcBuffer x = va_arg(ap, SilcBuffer);
unsigned char xf[4];
+
+ if (!process)
+ break;
+
if (x && silc_buffer_len(x)) {
FORMAT_HAS_SPACE(stack, dst, silc_buffer_len(x) + 4);
SILC_PUT32_MSB(silc_buffer_len(x), xf);
}
}
break;
+
case SILC_PARAM_OFFSET:
{
int offst = va_arg(ap, int);
+
+ if (!process)
+ break;
+
if (!offst)
break;
+
if (offst > 1) {
if (offst > silc_buffer_len(dst)) {
silc_set_errno(SILC_ERR_OVERFLOW);
}
break;
}
+
+ case SILC_PARAM_OFFSET_START:
+ if (!process)
+ break;
+ if (!silc_buffer_push(dst, flen))
+ goto fail;
+ flen = 0;
+ break;
+
+ case SILC_PARAM_OFFSET_END:
+ if (!process)
+ break;
+ flen += silc_buffer_len(dst);
+ silc_buffer_pull(dst, silc_buffer_len(dst));
+ break;
+
case SILC_PARAM_ADVANCE:
+ if (!process)
+ break;
advance = TRUE;
break;
+
case SILC_PARAM_END:
goto ok;
break;
+
default:
SILC_LOG_DEBUG(("Bad buffer formatting type `%d'. Could not "
"format the data.", fmt));
fail:
SILC_LOG_DEBUG(("Error occured while formatting data"));
- if (!advance)
+ if (process && !advance)
silc_buffer_push(dst, flen);
return -1;
ok:
/* Push the buffer back to where it belongs. */
- if (!advance)
+ if (process && !advance)
silc_buffer_push(dst, flen);
return flen;
}
-
-/****************************** Unformatting ********************************/
-
-int silc_buffer_unformat(SilcBuffer src, ...)
+int silc_buffer_format(SilcBuffer dst, ...)
{
va_list ap;
int ret;
- va_start(ap, src);
- ret = silc_buffer_sunformat_vp(NULL, src, ap);
+ va_start(ap, dst);
+ ret = silc_buffer_sformat_vp(NULL, dst, ap);
va_end(ap);
return ret;
}
-int silc_buffer_unformat_vp(SilcBuffer src, va_list ap)
+int silc_buffer_format_vp(SilcBuffer dst, va_list ap)
{
- return silc_buffer_sunformat_vp(NULL, src, ap);
+ return silc_buffer_sformat_vp(NULL, dst, ap);
}
-int silc_buffer_sunformat(SilcStack stack, SilcBuffer src, ...)
+int silc_buffer_sformat(SilcStack stack, SilcBuffer dst, ...)
{
va_list ap;
int ret;
- va_start(ap, src);
- ret = silc_buffer_sunformat_vp(stack, src, ap);
+ va_start(ap, dst);
+ ret = silc_buffer_sformat_vp(stack, dst, ap);
va_end(ap);
return ret;
}
-int silc_buffer_sunformat_vp(SilcStack stack, SilcBuffer src, va_list ap)
+int silc_buffer_sformat_vp(SilcStack stack, SilcBuffer dst, va_list ap)
+{
+ return silc_buffer_sformat_vp_i(stack, dst, ap, TRUE);
+}
+
+/****************************** Unformatting ********************************/
+
+int silc_buffer_sunformat_vp_i(SilcStack stack, SilcBuffer src, va_list ap,
+ SilcBool process)
{
SilcParam fmt;
unsigned char *start_ptr = src->data;
while (1) {
fmt = va_arg(ap, SilcParam);
- SILC_LOG_DEBUG(("Buffer unformat type %x", fmt));
+ SILC_LOG_DEBUG(("Buffer unformat type %d", fmt));
switch (fmt) {
case SILC_PARAM_FUNC:
func = va_arg(ap, SilcBufferUnformatFunc);
val = va_arg(ap, void **);
context = va_arg(ap, void *);
+
+ if (!process)
+ break;
+
tmp_len = func(stack, src, val, context);
if (tmp_len < 0)
goto fail;
silc_buffer_pull(src, tmp_len);
}
}
+ break;
+
+ case SILC_PARAM_REGEX:
+ {
+ const char *regex = va_arg(ap, char *);
+ SilcBufferRegexFlags rflags = va_arg(ap, SilcUInt32);
+ SilcBufferStruct match, saved;
+ SilcBool match_all = (rflags & SILC_STR_REGEX_ALL) != 0;
+ SilcBool match_nl = (rflags & SILC_STR_REGEX_NL) != 0;
+ SilcBool ret;
+ unsigned char *saved_incl = NULL;
+ int matched = 0, ret_len;
+ va_list cp;
+
+ if (!process)
+ break;
+
+ if (!regex)
+ goto fail;
+
+ memset(&saved, 0, sizeof(saved));
+
+ if (match_nl) {
+ start_nl_match:
+ /* Match for '\n' in the buffer. If not found, treat as line
+ without '\n' (buffer has only one line, or this is last line). */
+ saved = *src;
+ if (silc_regex_buffer(src, "\n", &match, NULL))
+ src->tail = match.tail;
+ }
+
+ start_match:
+ /* Match */
+ ret = silc_regex_buffer(src, regex, &match, NULL);
+ ret ^= (rflags & SILC_STR_REGEX_NOT) != 0;
+ if (!ret) {
+ if (!matched && rflags & SILC_STR_REGEX_MISMATCH) {
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+ goto fail;
+ }
+ goto end_match;
+ }
+ matched++;
+
+ if (rflags & SILC_STR_REGEX_NOT)
+ match = *src;
+
+ if (!(rflags & SILC_STR_REGEX_NO_ADVANCE)) {
+ /* Advance buffer after match */
+ UNFORMAT_HAS_SPACE(src, (match.data - src->data));
+ if (!silc_buffer_pull(src, (match.data - src->data)))
+ goto fail;
+ }
+
+ if (rflags & SILC_STR_REGEX_INCLUSIVE) {
+ saved_incl = src->tail;
+ src->tail = match.tail;
+ }
+
+ /* Recursively format */
+ silc_va_copy(cp, ap);
+ ret_len = silc_buffer_sunformat_vp_i(stack, src, cp, TRUE);
+ va_end(cp);
+ if (ret_len < 0)
+ goto fail;
+
+ if (rflags & SILC_STR_REGEX_INCLUSIVE)
+ src->tail = saved_incl;
+
+ /* Advance buffer after formatting */
+ UNFORMAT_HAS_SPACE(src, ret_len);
+ if (!silc_buffer_pull(src, ret_len))
+ goto fail;
+
+ if (match_all && (!match_nl || silc_buffer_len(src) > 1))
+ goto start_match;
+
+ end_match:
+ if (match_nl) {
+ /* Go to next line, it is at the end of the data area. Adjust
+ the tail area of the target buffer to show rest of the buffer. */
+ UNFORMAT_HAS_SPACE(src, src->tail - src->data);
+ if (!silc_buffer_pull(src, (src->tail - src->data)))
+ goto fail;
+ if (!silc_buffer_pull_tail(src, (saved.tail - src->tail)))
+ goto fail;
+
+ if (silc_buffer_len(src) > 0)
+ goto start_nl_match;
+ }
+
+ /* Skip to the next SILC_PARAM_END */
+ silc_buffer_sunformat_vp_i(NULL, src, ap, FALSE);
+ }
+ break;
+
case SILC_PARAM_UICHAR:
{
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt32 len2 = va_arg(ap, SilcUInt32);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, len2);
if (silc_likely(len2 && x))
*x = src->data;
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UICHAR | SILC_PARAM_ALLOC:
{
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt32 len2 = va_arg(ap, SilcUInt32);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, len2);
if (silc_likely(len2 && x)) {
*x = silc_scalloc(stack, len2 + 1, sizeof(unsigned char));
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UINT8:
{
unsigned char *x = va_arg(ap, unsigned char *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 1);
if (silc_likely(x))
*x = src->data[0];
silc_buffer_pull(src, 1);
break;
}
+
case SILC_PARAM_UINT16:
{
SilcUInt16 *x = va_arg(ap, SilcUInt16 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 2);
if (silc_likely(x))
SILC_GET16_MSB(*x, src->data);
silc_buffer_pull(src, 2);
break;
}
+
case SILC_PARAM_UINT32:
{
SilcUInt32 *x = va_arg(ap, SilcUInt32 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
if (silc_likely(x))
SILC_GET32_MSB(*x, src->data);
silc_buffer_pull(src, 4);
break;
}
+
case SILC_PARAM_UINT64:
{
SilcUInt64 *x = va_arg(ap, SilcUInt64 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, sizeof(SilcUInt64));
if (silc_likely(x))
SILC_GET64_MSB(*x, src->data);
silc_buffer_pull(src, sizeof(SilcUInt64));
break;
}
+
case SILC_PARAM_SINT8:
{
char *x = va_arg(ap, char *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 1);
if (silc_likely(x))
*x = src->data[0];
silc_buffer_pull(src, 1);
break;
}
+
case SILC_PARAM_SINT16:
{
SilcInt16 *x = va_arg(ap, SilcInt16 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 2);
if (silc_likely(x))
SILC_GET16_MSB(*x, src->data);
silc_buffer_pull(src, 2);
break;
}
+
case SILC_PARAM_SINT32:
{
SilcInt32 *x = va_arg(ap, SilcInt32 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
if (silc_likely(x))
SILC_GET32_MSB(*x, src->data);
silc_buffer_pull(src, 4);
break;
}
+
case SILC_PARAM_SINT64:
{
SilcInt64 *x = va_arg(ap, SilcInt64 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, sizeof(SilcInt64));
if (silc_likely(x))
SILC_GET64_MSB(*x, src->data);
silc_buffer_pull(src, sizeof(SilcInt64));
break;
}
+
case SILC_PARAM_UI8_STRING:
{
SilcUInt8 len2;
unsigned char **x = va_arg(ap, unsigned char **);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 1);
len2 = (SilcUInt8)src->data[0];
silc_buffer_pull(src, 1);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI8_STRING | SILC_PARAM_ALLOC:
{
SilcUInt8 len2;
unsigned char **x = va_arg(ap, unsigned char **);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 1);
len2 = (SilcUInt8)src->data[0];
silc_buffer_pull(src, 1);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI16_STRING:
{
SilcUInt16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
silc_buffer_pull(src, 2);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI16_STRING | SILC_PARAM_ALLOC:
{
SilcUInt16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
silc_buffer_pull(src, 2);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI32_STRING:
{
SilcUInt32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI32_STRING | SILC_PARAM_ALLOC:
{
SilcUInt32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI8_NSTRING:
{
SilcUInt8 len2;
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt8 *len3 = va_arg(ap, SilcUInt8 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 1);
len2 = (SilcUInt8)src->data[0];
silc_buffer_pull(src, 1);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI8_NSTRING | SILC_PARAM_ALLOC:
{
SilcUInt8 len2;
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt8 *len3 = va_arg(ap, SilcUInt8 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 1);
len2 = (SilcUInt8)src->data[0];
silc_buffer_pull(src, 1);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI16_NSTRING:
{
SilcUInt16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt16 *len3 = va_arg(ap, SilcUInt16 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
silc_buffer_pull(src, 2);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI16_NSTRING | SILC_PARAM_ALLOC:
{
SilcUInt16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt16 *len3 = va_arg(ap, SilcUInt16 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
silc_buffer_pull(src, 2);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI32_NSTRING:
{
SilcUInt32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt32 *len3 = va_arg(ap, SilcUInt32 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_UI32_NSTRING | SILC_PARAM_ALLOC:
{
SilcUInt32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
SilcUInt32 *len3 = va_arg(ap, SilcUInt32 *);
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
silc_buffer_pull(src, len2);
break;
}
+
case SILC_PARAM_BUFFER:
{
SilcBuffer x = va_arg(ap, SilcBuffer);
SilcUInt32 len2;
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
silc_buffer_pull(src, len2);
}
break;
+
case SILC_PARAM_BUFFER | SILC_PARAM_ALLOC:
{
SilcBuffer x = va_arg(ap, SilcBuffer);
SilcUInt32 len2;
+
+ if (!process)
+ break;
+
UNFORMAT_HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
silc_buffer_pull(src, len2);
}
break;
+
case SILC_PARAM_OFFSET:
{
int offst = va_arg(ap, int);
+
+ if (!process)
+ break;
+
if (!offst)
break;
+
if (offst > 1) {
UNFORMAT_HAS_SPACE(src, offst);
silc_buffer_pull(src, offst);
}
break;
}
+
+ case SILC_PARAM_OFFSET_START:
+ if (!process)
+ break;
+ silc_buffer_push(src, (src->data - start_ptr));
+ break;
+
+ case SILC_PARAM_OFFSET_END:
+ if (!process)
+ break;
+ silc_buffer_pull(src, silc_buffer_len(src));
+ break;
+
case SILC_PARAM_ADVANCE:
+ if (!process)
+ break;
advance = TRUE;
break;
+
case SILC_PARAM_END:
goto ok;
break;
+
default:
SILC_LOG_DEBUG(("Bad buffer formatting type `%d'. Could not "
"format the data.", fmt));
fail:
SILC_LOG_DEBUG(("Error occured while unformatting buffer, type %d", fmt));
- len = src->data - start_ptr;
- silc_buffer_push(src, len);
+ if (process && !advance) {
+ len = src->data - start_ptr;
+ silc_buffer_push(src, len);
+ }
return -1;
ok:
/* Push the buffer back to the start. */
- if (!advance) {
+ if (process && !advance) {
len = src->data - start_ptr;
silc_buffer_push(src, len);
}
return len;
}
+int silc_buffer_unformat(SilcBuffer src, ...)
+{
+ va_list ap;
+ int ret;
+
+ va_start(ap, src);
+ ret = silc_buffer_sunformat_vp(NULL, src, ap);
+ va_end(ap);
+
+ return ret;
+}
+
+int silc_buffer_unformat_vp(SilcBuffer src, va_list ap)
+{
+ return silc_buffer_sunformat_vp(NULL, src, ap);
+}
+
+int silc_buffer_sunformat(SilcStack stack, SilcBuffer src, ...)
+{
+ va_list ap;
+ int ret;
+
+ va_start(ap, src);
+ ret = silc_buffer_sunformat_vp(stack, src, ap);
+ va_end(ap);
+
+ return ret;
+}
+
+int silc_buffer_sunformat_vp(SilcStack stack, SilcBuffer src, va_list ap)
+{
+ return silc_buffer_sunformat_vp_i(stack, src, ap, TRUE);
+}
/**************************** Utility functions *****************************/
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2007 Pekka Riikonen
+ Copyright (C) 1997 - 2008 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* into specified data types. It is especially useful to encode packets,
* protocol payloads and such.
*
+ * It also provides many advanced features like calling user specified
+ * encoder and decoder functions that are free to do anything to the buffer.
+ * The API also provides powerful regular expression matching capabilities
+ * within the buffer, enabling caller to not only match regular expressions
+ * but to make the API behave like Stream Editor (Sed) and Awk. The buffer
+ * can be matched against regular expression and then edited. Caller can
+ * do anything they want to the buffer after a match. The SILC_STR_REGEX
+ * macro provides many different flags that can change the behavior of the
+ * matching, with capabilities to also mimic Sed behavior.
+ *
* As the SilcBuffer API is not thread-safe these routines may not be used
* in multithreaded environment with a same SilcBuffer context without
* concurrency control.
* if (ret < 0)
* error;
*
+ * // sed 's/foo/bar/', replace first foo with bar
+ * silc_buffer_format(buffer,
+ * SILC_STR_REGEX("foo", 0),
+ * SILC_STR_STRING("bar"),
+ * SILC_STR_END, SILC_STR_END);
+ *
***/
#ifndef SILCBUFFMT_H
#define SILC_STR_SI_INT64(x) SILC_PARAM_SINT64, (x)
#define SILC_STR_UI_INT64(x) SILC_PARAM_UINT64, (x)
+/****d* silcutil/SilcBufferFormatAPI/SILC_STR_STRING
+ *
+ * NAME
+ *
+ * #define SILC_STR_STRING() ...
+ *
+ * DESCRIPTION
+ *
+ * Encode NULL terminated string. Use this only for formatting.
+ *
+ * Formatting: SILC_STR_STRING(char *)
+ *
+ * For unformatting use one of the SILC_STR_*_STRING macros, which
+ * automatically gets the length of the string from the buffer. Note
+ * SILC_STR_STRING does not save the length of the string into the buffer.
+ * The caller must do that in order for the unformatting macros to work.
+ *
+ * Example:
+ *
+ * Formatting: ..., SILC_STR_UINT32(strlen(string)),
+ * SILC_STR_STRING(string), ...
+ * Unformatting: ..., SILC_STR_UI32_STRING(&string), ...
+ *
+ ***/
+#define SILC_STR_STRING(x) SILC_PARAM_UI8_STRING, (x)
+
/****d* silcutil/SilcBufferFormatAPI/SILC_STR_*_STRING
*
* NAME
*
* Unformatting procedure will check for length of the string from the
* buffer before trying to get the string out. Thus, one *must* format the
- * length as UI_INT or UI_SHORT into the buffer *before* formatting the
- * actual string to the buffer, and, in unformatting one must ignore the
+ * length as UINT32 or UINT16 or UINT8 into the buffer *before* formatting
+ * the actual string to the buffer, and, in unformatting one ignores the
* length of the string because unformatting procedure will take it
* automatically.
*
* Example:
*
- * Formatting: ..., SILC_STR_UI_INT(strlen(string)),
+ * Formatting: ..., SILC_STR_UINT32(strlen(string)),
* SILC_STR_UI32_STRING(string), ...
* Unformatting: ..., SILC_STR_UI32_STRING(&string), ...
*
* I.e., you can ignore the formatted length field in unformatting.
*
* UI8, UI16 and UI32 means that the length is considered to be
- * either char (8 bits), short (16 bits) or int (32 bits) in
- * unformatting.
+ * either UINT8, UINT16 or UINT32 in unformatting.
*
* _ALLOC routines automatically allocates memory for the variable sent
* as argument in unformatting.
*
* Unformatting procedure will check for length of the string from the
* buffer before trying to get the string out. Thus, one *must* format the
- * length as UI_INT or UI_SHORT into the buffer *before* formatting the
- * actual string to the buffer, and, in unformatting one must ignore the
+ * length as UINT32 or UINT16 or UINT8 into the buffer *before* formatting
+ * the actual string to the buffer, and, in unformatting one ignores the
* length of the string because unformatting procedure will take it
* automatically.
*
* Example:
*
- * Formatting: ..., SILC_STR_UI_INT(strlen(string)),
+ * Formatting: ..., SILC_STR_UINT32(strlen(string)),
* SILC_STR_UI32_NSTRING(string, strlen(string)), ...
* Unformatting: ..., SILC_STR_UI32_NSTRING(&string, &len), ...
*
* argument (&len in above example).
*
* UI8, UI16 and UI32 means that the length is considered to be
- * either char (8 bits), short (16 bits) or int (32 bits) in
- * unformatting.
+ * either UINT8, UINT16 or UINT32 in unformatting.
*
* _ALLOC routines automatically allocates memory for the variable sent
* as argument in unformatting.
*
* DESCRIPTION
*
- * SilcBuffer formatting.
+ * Formatting and unformatting of arbitrary data.
*
* Formatting: SILC_STR_FUNC(function, void *value, void *context)
* Unformatting: SILC_STR_FUNC(function, void **value, void *context)
#define SILC_STR_FUNC(func, val, context) SILC_PARAM_FUNC, \
func, (val), (context)
+/****d* silcutil/SilcBufferFormatAPI/SilcBufferRegexFlags
+ *
+ * NAME
+ *
+ * typedef enum { ... } SilcBufferRegexFlags;
+ *
+ * DESCRIPTION
+ *
+ * Regular expression flags for SILC_STR_REGEX macro. The flags can be
+ * used to manipulate the behavior of the SILC_STR_REGEX. All flags
+ * may be combined unless otherwise stated.
+ *
+ * SOURCE
+ */
+typedef enum {
+ SILC_STR_REGEX_NONE = 0x00000000,
+
+ /* By default mismatch will be skipped. Set this flag if mismatch should
+ cause error and stopping of the formatting/unformatting. */
+ SILC_STR_REGEX_MISMATCH = 0x00000001,
+
+ /* By default only the first match is found. Set this flag to find
+ all matches. */
+ SILC_STR_REGEX_ALL = 0x00000002,
+
+ /* By default the buffer position is advanced to the position of the
+ first match. Set this flag if the buffer should not be advanced to
+ the match. */
+ SILC_STR_REGEX_NO_ADVANCE = 0x00000004,
+
+ /* By default SILC_STR_REGEX performs the match on the whole buffer. Set
+ this flag to make it behave like sed and match line by line. Each line
+ must end with '\n'. If buffer doesn't have '\n' it is considered to be
+ one line. Note that, any formatting done immediately after SILC_STR_REGEX
+ block with this flag will be formatted to the end of the buffer (after
+ last line). Use SILC_STR_OFFSET* macros to change the position if
+ needed. Also note that, any encoding macro inside the SILC_STR_REGEX
+ block will see only the matched line (including '\n'), instead of whole
+ buffer after the match. */
+ SILC_STR_REGEX_NL = 0x00000008,
+
+ /* Set this flag to not match the regular expression, but to match everything
+ else. When combined with SILC_STR_REGEX_NL this flag matches all other
+ lines except the ones with matching regular expression. */
+ SILC_STR_REGEX_NOT = 0x00000010,
+
+ /* By default the buffer is advanced to the first match and the rest of the
+ buffer remains as is. Set this flag to pass the exact match to the
+ SILC_STR_* macros in the SILC_STR_REGEX block; macros see the start of
+ the match and the end of the match, but not rest of the buffer (ie. with
+ match 'foo' the size of the buffer is 3 bytes). */
+ SILC_STR_REGEX_INCLUSIVE = 0x00000020,
+} SilcBufferRegexFlags;
+/***/
+
+/****d* silcutil/SilcBufferFormatAPI/SILC_STR_REGEX
+ *
+ * NAME
+ *
+ * #define SILC_STR_REGEX() ...
+ *
+ * DESCRIPTION
+ *
+ * Regular expression matching within the buffer.
+ *
+ * Formatting: SILC_STR_REGEX(char *regex, SilcBufferRegexFlags flags)
+ * Unformatting: SILC_STR_REGEX(char *regex, SilcBufferRegexFlags flags)
+ *
+ * SILC_STR_REGEX can be used to do regular expression matching within
+ * the SilcBuffer. When the string in the buffer matches the regular
+ * expression the position of the buffer is advanced to the position of
+ * the first match (rest of the buffer remains intact). If the regular
+ * expression does not match it is skipped, unless the flags specify
+ * otherwise. If flags are not needed they can be set to 0.
+ *
+ * In addition of matching regular expressions it can be used in a
+ * Stream Editor (sed) and Awk like fashion. The regular expression can be
+ * matched and then edited by any of the SILC_STR_* macros. The flags
+ * can be used to perform complex operations on the data. Some sed
+ * features that cannot be directly done with the flags can be done with
+ * SILC_STR_FUNC and other macros (the SILC_STR_FUNC could do anything
+ * after the match).
+ *
+ * The SILC_STR_REGEX itself is used as an opening of a block of encoding
+ * macros and must be closed with SILC_STR_END. This means that for
+ * each SILC_STR_REGEX there must be one SILC_STR_END. See examples for
+ * more information.
+ *
+ * The SILC_STR_REGEX can be used in buffer unformatting also to do
+ * string matching and parsing, but not editing, except with SILC_STR_FUNC
+ * macro, which can do anything caller wants.
+ *
+ * EXAMPLE
+ *
+ * // sed 's/foo/bar/', replace first foo with bar
+ * silc_buffer_format(buffer,
+ * SILC_STR_REGEX("foo", 0),
+ * SILC_STR_STRING("bar"),
+ * SILC_STR_END, SILC_STR_END);
+ *
+ * // sed 's/foo/bar/g', replace all foo's with bar
+ * silc_buffer_format(buffer,
+ * SILC_STR_REGEX("foo", SILC_STR_REGEX_ALL),
+ * SILC_STR_STRING("bar"),
+ * SILC_STR_END, SILC_STR_END);
+ *
+ * // sed '/baz/s/foo/bar/g, replace all foo's with bar on lines with baz
+ * silc_buffer_format(buffer,
+ * SILC_STR_REGEX("baz", SILC_STR_REGEX_NL),
+ * SILC_STR_REGEX("foo", SILC_STR_REGEX_ALL),
+ * SILC_STR_STRING("bar"),
+ * SILC_STR_END,
+ * SILC_STR_END, SILC_STR_END);
+ *
+ * // Print all lines that start with 'R'
+ * int print(SilcStack stack, SilcBuffer buf, void *value, void *context)
+ * {
+ * return fwrite(silc_buffer_data(buf), 1, silc_buffer_len(buf), stdout);
+ * }
+ *
+ * silc_buffer_unformat(buffer,
+ * SILC_STR_REGEX("^R", SILC_STR_REGEX_NL),
+ * SILC_STR_FUNC(print, NULL, NULL),
+ * SILC_STR_END, SILC_STR_END);
+ *
+ ***/
+#define SILC_STR_REGEX(regex, flags) SILC_PARAM_REGEX, (regex), (flags)
+
/****d* silcutil/SilcBufferFormatAPI/SILC_STR_OFFSET
*
* NAME
***/
#define SILC_STR_OFFSET(x) SILC_PARAM_OFFSET, (x)
+/****d* silcutil/SilcBufferFormatAPI/SILC_STR_OFFSET_START
+ *
+ * NAME
+ *
+ * #define SILC_STR_OFFSET_START ...
+ *
+ * DESCRIPTION
+ *
+ * Moves the buffer position to the start of the data area.
+ *
+ * Example:
+ *
+ * ..., SILC_STR_OFFSET_START, ...
+ *
+ ***/
+#define SILC_STR_OFFSET_START SILC_PARAM_OFFSET_START
+
+/****d* silcutil/SilcBufferFormatAPI/SILC_STR_OFFSET_END
+ *
+ * NAME
+ *
+ * #define SILC_STR_OFFSET_END ...
+ *
+ * DESCRIPTION
+ *
+ * Moves the buffer position to the end of the data area.
+ *
+ * Example:
+ *
+ * ..., SILC_STR_OFFSET_END, ...
+ *
+ ***/
+#define SILC_STR_OFFSET_END SILC_PARAM_OFFSET_END
+
/****d* silcutil/SilcBufferFormatAPI/SILC_STR_ADVANCE
*
* NAME
--- /dev/null
+/* Buffer formatting tests */
+
+#include "silc.h"
+
+int print(SilcStack stack, SilcBuffer buf, void *value, void *context)
+{
+ fwrite(silc_buffer_data(buf), 1, silc_buffer_len(buf), stdout);
+ if (!silc_buffer_strchr(buf, '\n', TRUE))
+ printf("\n");
+ fflush(stdout);
+ return silc_buffer_len(buf);
+}
+
+int main(int argc, char **argv)
+{
+ SilcBool success = FALSE;
+ char string[1024];
+ SilcBufferStruct buf;
+
+ if (argc > 1 && !strcmp(argv[1], "-d")) {
+ silc_log_debug(TRUE);
+ silc_log_quick(TRUE);
+ silc_log_debug_hexdump(TRUE);
+ silc_log_set_debug_string("*buf*,*regex*,*errno*");
+ }
+
+ silc_snprintf(string, sizeof(string), "This is foobar");
+ silc_buffer_set(&buf, string, strlen(string));
+ SILC_LOG_DEBUG(("sed 's/foo/bar/'"));
+ SILC_LOG_DEBUG(("string: %s", string));
+ if (silc_buffer_format(&buf,
+ SILC_STR_REGEX("foo", 0),
+ SILC_STR_STRING("bar"),
+ SILC_STR_END,
+ SILC_STR_END) < 0)
+ goto err;
+ SILC_LOG_DEBUG(("string: %s", silc_buffer_data(&buf)));
+ if (strcmp("This is barbar", silc_buffer_data(&buf)))
+ goto err;
+
+ silc_snprintf(string, sizeof(string), "This is foobar\n");
+ silc_buffer_set(&buf, string, strlen(string));
+ SILC_LOG_DEBUG(("sed 's/\\n/\\0/'"));
+ SILC_LOG_DEBUG(("string: %s", string));
+ if (silc_buffer_format(&buf,
+ SILC_STR_REGEX("\n", 0),
+ SILC_STR_UINT8(0),
+ SILC_STR_END,
+ SILC_STR_END) < 0)
+ goto err;
+ SILC_LOG_DEBUG(("string: %s", silc_buffer_data(&buf)));
+ if (strcmp("This is foobar", silc_buffer_data(&buf)))
+ goto err;
+
+ silc_snprintf(string, sizeof(string), "foo\nfoobar\nbarfoofoo\nbar\n\nfoo");
+ silc_buffer_set(&buf, string, strlen(string));
+ SILC_LOG_DEBUG(("sed 's/foo/bar/g'"));
+ SILC_LOG_DEBUG(("string: %s", string));
+ if (silc_buffer_format(&buf,
+ SILC_STR_REGEX("foo", SILC_STR_REGEX_NL |
+ SILC_STR_REGEX_ALL),
+ SILC_STR_STRING("bar"),
+ SILC_STR_END,
+ SILC_STR_END) < 0)
+ goto err;
+ SILC_LOG_DEBUG(("string: %s", silc_buffer_data(&buf)));
+ if (strcmp("bar\nbarbar\nbarbarbar\nbar\n\nbar", silc_buffer_data(&buf)))
+ goto err;
+
+ silc_snprintf(string, sizeof(string),
+ "foo\nbazfoobar\nbarfoofoo\nbar\nbaz\nbazfoo");
+ silc_buffer_set(&buf, string, strlen(string));
+ SILC_LOG_DEBUG(("sed '/baz/s/foo/bar/"));
+ SILC_LOG_DEBUG(("string: %s", string));
+ if (silc_buffer_format(&buf,
+ SILC_STR_REGEX("baz", SILC_STR_REGEX_NL),
+ SILC_STR_REGEX("foo", SILC_STR_REGEX_ALL),
+ SILC_STR_STRING("bar"),
+ SILC_STR_END,
+ SILC_STR_END, SILC_STR_END) < 0)
+ goto err;
+ SILC_LOG_DEBUG(("string: %s", silc_buffer_data(&buf)));
+ if (strcmp("foo\nbazbarbar\nbarfoofoo\nbar\nbaz\nbazbar",
+ silc_buffer_data(&buf)))
+ goto err;
+
+ silc_snprintf(string, sizeof(string),
+ "foo\nbazfoobar\nbarfoofoo\nbar\nbaz\nbazfoo");
+ silc_buffer_set(&buf, string, strlen(string));
+ SILC_LOG_DEBUG(("sed '/baz/!s/foo/bar/"));
+ SILC_LOG_DEBUG(("string: %s", string));
+ if (silc_buffer_format(&buf,
+ SILC_STR_REGEX("baz", SILC_STR_REGEX_NL |
+ SILC_STR_REGEX_NOT),
+ SILC_STR_REGEX("foo", SILC_STR_REGEX_ALL),
+ SILC_STR_STRING("bar"),
+ SILC_STR_END,
+ SILC_STR_END, SILC_STR_END) < 0)
+ goto err;
+ SILC_LOG_DEBUG(("string: %s", silc_buffer_data(&buf)));
+ if (strcmp("bar\nbazfoobar\nbarbarbar\nbar\nbaz\nbazfoo",
+ silc_buffer_data(&buf)))
+ goto err;
+
+ SILC_LOG_DEBUG(("Print all lines starting with 'R'"));
+ silc_snprintf(string, sizeof(string),
+ "Rfoo\nbazfoobar\nRbarfoofoo\nRbar\nbaz\nRbazfoo");
+ silc_buffer_set(&buf, string, strlen(string));
+ SILC_LOG_DEBUG(("string: %s", string));
+ if (silc_buffer_unformat(&buf,
+ SILC_STR_REGEX("^R", SILC_STR_REGEX_NL),
+ SILC_STR_FUNC(print, NULL, NULL),
+ SILC_STR_END, SILC_STR_END) < 0)
+ goto err;
+
+ success = TRUE;
+
+ err:
+ SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
+ fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");
+
+ return success;
+}
projects / runtime.git / commitdiff