ossp-pkg/l2/l2_ut_fmtcb.c
/*
** OSSP l2 - Flexible Logging
** Copyright (c) 2001-2005 Cable & Wireless <http://www.cw.com/>
** Copyright (c) 2001-2005 The OSSP Project <http://www.ossp.org/>
** Copyright (c) 2001-2005 Ralf S. Engelschall <rse@engelschall.com>
**
** This file is part of OSSP l2, a flexible logging library which
** can be found at http://www.ossp.org/pkg/lib/l2/.
**
** Permission to use, copy, modify, and distribute this software for
** any purpose with or without fee is hereby granted, provided that
** the above copyright notice and this permission notice appear in all
** copies.
**
** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
** SUCH DAMAGE.
**
** l2_format.c: extra formatters
*/
#include <ctype.h>
#include "l2.h"
#include <errno.h>
l2_result_t
l2_util_fmt_string(
l2_context_t *ctx, const char id, const char *param,
char *bufptr, size_t bufsize, size_t *buflen, va_list *ap)
{
char *cpStr;
size_t nStr;
cpStr = va_arg(*ap, char *);
nStr = (size_t)va_arg(*ap, int);
if (cpStr == NULL)
return L2_ERR_ARG;
if (nStr > bufsize)
return L2_ERR_MEM;
memcpy(bufptr, cpStr, nStr);
*buflen = nStr;
return L2_OK;
}
l2_result_t
l2_util_fmt_dump(
l2_context_t *ctx, const char id, const char *param,
char *bufptr, size_t bufsize, size_t *buflen, va_list *ap)
{
static const char hex_table[] = "0123456789abcdef";
static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
unsigned char base64_in[3];
unsigned char base64_out[4];
size_t nData;
unsigned char *ucpData;
unsigned char uc;
unsigned char *cpO;
unsigned char *cpI;
int i;
int n;
/* fetch data pointer and data size from argument list */
ucpData = va_arg(*ap, unsigned char *);
nData = (size_t)va_arg(*ap, int);
/* argument sanity check */
if (ucpData == NULL)
return L2_ERR_ARG;
/*
* textual dumping: "foo\1bar" -> "foo\x01bar"
*/
if (strcmp(param, "text") == 0 || param[0] == '\0') {
cpI = ucpData;
cpO = (unsigned char *)bufptr;
while (cpI < (ucpData+nData)) {
uc = *cpI++;
if (isprint((int)uc)) {
if ((char *)cpO >= (bufptr+bufsize))
return L2_ERR_MEM;
*cpO++ = uc;
}
else if (uc == '\\') {
if ((char *)(cpO+1) >= (bufptr+bufsize))
return L2_ERR_MEM;
*cpO++ = '\\';
*cpO++ = '\\';
}
else if (uc == '\t' || uc == '\r' || uc == '\n') {
if ((char *)(cpO+1) >= (bufptr+bufsize))
return L2_ERR_MEM;
*cpO++ = '\\';
switch ((int)uc) {
case '\t': *cpO++ = 't'; break;
case '\r': *cpO++ = 'r'; break;
case '\n': *cpO++ = 'n'; break;
default: break;
}
}
else {
if ((char *)(cpO+3) >= (bufptr+bufsize))
return L2_ERR_MEM;
*cpO++ = '\\';
*cpO++ = 'x';
*cpO++ = hex_table[(uc >> 4) & 0xf];
*cpO++ = hex_table[uc & 0xf];
}
}
*buflen = ((char *)cpO - bufptr);
}
/*
* hexadecimal dumping: "foo\1bar" -> "66:6f:6f:01:62:61:72"
*/
else if (strcmp(param, "hex") == 0) {
if (((nData * 3) - 1) > bufsize)
return L2_ERR_MEM;
cpO = (unsigned char *)bufptr;
for (i = 0; i < nData; i++) {
uc = *ucpData++;
*cpO++ = hex_table[(uc >> 4) & 0xf];
*cpO++ = hex_table[uc & 0xf];
if (i < (nData - 1))
*cpO++ = ':';
}
*buflen = (nData * 3) - 1;
}
/*
* Base64 dumping: "foo\1bar" -> "Zm9vAWJhcg=="
*/
else if (strcmp(param, "base64") == 0) {
/* bulk encoding */
n = 0;
while (nData >= 3) {
base64_in[0] = *ucpData++;
base64_in[1] = *ucpData++;
base64_in[2] = *ucpData++;
nData -= 3;
base64_out[0] = ( base64_in[0] >> 2);
base64_out[1] = ((base64_in[0] & 0x03) << 4) + (base64_in[1] >> 4);
base64_out[2] = ((base64_in[1] & 0x0f) << 2) + (base64_in[2] >> 6);
base64_out[3] = ( base64_in[2] & 0x3f);
if (n + 4 > bufsize)
return L2_ERR_MEM;
bufptr[n++] = base64_table[base64_out[0]];
bufptr[n++] = base64_table[base64_out[1]];
bufptr[n++] = base64_table[base64_out[2]];
bufptr[n++] = base64_table[base64_out[3]];
}
/* now worry about padding with remaining 1 or 2 bytes */
if (nData != 0) {
base64_in[0] = base64_in[1] = base64_in[2] = '\0';
for (i = 0; i < nData; i++)
base64_in[i] = *ucpData++;
base64_out[0] = ( base64_in[0] >> 2);
base64_out[1] = ((base64_in[0] & 0x03) << 4) + (base64_in[1] >> 4);
base64_out[2] = ((base64_in[1] & 0x0f) << 2) + (base64_in[2] >> 6);
if (n + 4 > bufsize)
return L2_ERR_MEM;
bufptr[n++] = base64_table[base64_out[0]];
bufptr[n++] = base64_table[base64_out[1]];
if (nData == 1)
bufptr[n++] = '=';
else
bufptr[n++] = base64_table[base64_out[2]];
bufptr[n++] = '=';
}
if (n >= bufsize)
return L2_ERR_MEM;
*buflen = n;
}
/* anything else is an unknown dumping method... */
else
return L2_ERR_ARG;
return L2_OK;
}
l2_result_t
l2_util_fmt_errno(
l2_context_t *ctx, const char id, const char *param,
char *bufptr, size_t bufsize, size_t *buflen, va_list *ap)
{
sprintf(bufptr, "(%d) %s", errno, strerror(errno));
*buflen = strlen(bufptr);
return L2_OK;
}
