/*
* Copyright (c) 2001-2002 Packet Design, LLC.
* All rights reserved.
*
* Subject to the following obligations and disclaimer of warranty,
* use and redistribution of this software, in source or object code
* forms, with or without modifications are expressly permitted by
* Packet Design; provided, however, that:
*
* (i) Any and all reproductions of the source or object code
* must include the copyright notice above and the following
* disclaimer of warranties; and
* (ii) No rights are granted, in any manner or form, to use
* Packet Design trademarks, including the mark "PACKET DESIGN"
* on advertising, endorsements, or otherwise except as such
* appears in the above copyright notice or in the software.
*
* THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
* TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
* REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
* THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
* OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
* OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
* OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
* RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
* LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
* OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
* DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
* USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER 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 PACKET DESIGN IS ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
* Author: Archie Cobbs <archie@freebsd.org>
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/ethernet.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <time.h>
#include "structs/structs.h"
#include "structs/type/array.h"
#include "structs/type/data.h"
#include "io/filter.h"
#include "io/base64.h"
#include "util/typed_mem.h"
#define HEXVAL(c) (isdigit(c) ? (c) - '0' : tolower(c) - 'a' + 10)
static const char hexchars[] = "0123456789abcdef";
/*********************************************************************
BINARY DATA TYPE
*********************************************************************/
int
structs_data_copy(const struct structs_type *type, const void *from, void *to)
{
const char *const mtype = type->args[1].v;
const struct structs_data *const fdata = from;
struct structs_data *const tdata = to;
u_char *copy;
if (fdata->length == 0) {
memset(tdata, 0, sizeof(*tdata));
return (0);
}
if ((copy = MALLOC(mtype, fdata->length)) == NULL)
return (-1);
memcpy(copy, fdata->data, fdata->length);
tdata->data = copy;
tdata->length = fdata->length;
return (0);
}
int
structs_data_equal(const struct structs_type *type,
const void *v1, const void *v2)
{
const struct structs_data *const d1 = v1;
const struct structs_data *const d2 = v2;
return (d1->length == d2->length
&& memcmp(d1->data, d2->data, d1->length) == 0);
}
char *
structs_data_ascify(const struct structs_type *type,
const char *mtype, const void *data)
{
const char *const charmap = type->args[0].v;
const struct structs_data *const d = data;
struct filter *encoder;
char *edata;
int elen;
int i;
/* Handle hex encoding */
if (charmap != NULL && *charmap == '\0') {
if ((edata = MALLOC(mtype, d->length * 2 + 1)) == NULL)
return (NULL);
for (i = 0; i < d->length; i++) {
edata[i * 2] = hexchars[(d->data[i] >> 4) & 0x0f];
edata[i * 2 + 1] = hexchars[d->data[i] & 0x0f];
}
edata[i * 2] = '\0';
return (edata);
}
/* Get encoding filter */
if ((encoder = b64_encoder_create(charmap)) == NULL)
return (NULL);
/* Encode data */
elen = filter_process(encoder, d->data,
d->length, 1, (u_char **)&edata, mtype);
filter_destroy(&encoder);
if (elen == -1)
return (NULL);
/* Return encoded data as a string */
edata[elen] = '\0';
return (edata);
}
int
structs_data_binify(const struct structs_type *type,
const char *ascii, void *data, char *ebuf, size_t emax)
{
const char *const charmap = type->args[0].v;
const char *const mtype = type->args[1].v;
struct structs_data *const d = data;
struct filter *decoder;
u_char *bdata;
int blen;
int i;
/* Handle hex encoding */
if (charmap != NULL && *charmap == '\0') {
if ((bdata = MALLOC(mtype, (strlen(ascii) + 1) / 2)) == NULL)
return (-1);
for (blen = 0; *ascii != '\0'; blen++) {
while (isspace(*ascii))
ascii++;
if (*ascii == '\0')
break;
bdata[blen] = 0;
for (i = 4; i >= 0; i -= 4) {
if (!isxdigit(*ascii)) {
strlcpy(ebuf, *ascii == '\0' ?
"odd length hex sequence" :
"non-hex character seen", emax);
FREE(mtype, bdata);
return (-1);
}
bdata[blen] |= HEXVAL(*ascii) << i;
ascii++;
}
}
goto done;
}
/* Get decoding filter */
if ((decoder = b64_decoder_create(charmap, 1)) == NULL)
return (-1);
/* Decode data */
blen = filter_process(decoder, ascii, strlen(ascii), 1, &bdata, mtype);
filter_destroy(&decoder);
if (blen == -1) {
strlcpy(ebuf, "invalid encoded binary data", emax);
return (-1);
}
done:
/* Fill in structure */
d->length = blen;
d->data = bdata;
return (0);
}
void
structs_data_free(const struct structs_type *type, void *data)
{
const char *const mtype = type->args[1].v;
struct structs_data *const d = data;
FREE(mtype, d->data);
memset(d, 0, sizeof(*d));
}
int
structs_data_encode(const struct structs_type *type, const char *mtype,
struct structs_data *code, const void *data)
{
const struct structs_data *const d = data;
u_int32_t elength;
if ((code->data = MALLOC(mtype, 4 + d->length)) == NULL)
return (-1);
elength = htonl(d->length);
memcpy(code->data, &elength, 4);
memcpy(code->data + 4, d->data, d->length);
code->length = 4 + d->length;
return (0);
}
int
structs_data_decode(const struct structs_type *type, const u_char *code,
size_t cmax, void *data, char *ebuf, size_t emax)
{
const char *const mtype = type->args[1].v;
struct structs_data *const d = data;
u_int32_t elength;
if (cmax < 4)
goto bogus;
memcpy(&elength, code, 4);
d->length = ntohl(elength);
if (cmax < d->length) {
bogus: strlcpy(ebuf, "encoded data is corrupted", emax);
errno = EINVAL;
return (-1);
}
if ((d->data = MALLOC(mtype, d->length)) == NULL)
return (-1);
memcpy(d->data, code + 4, d->length);
return (4 + d->length);
}
const struct structs_type structs_type_data =
STRUCTS_DATA_TYPE(NULL, STRUCTS_DATA_MEMTYPE);
const struct structs_type structs_type_hexdata =
STRUCTS_DATA_TYPE("", STRUCTS_DATA_MEMTYPE);
/*********************************************************************
FIXED LENGTH BINARY DATA TYPE
*********************************************************************/
char *
structs_fixeddata_ascify(const struct structs_type *type,
const char *mtype, const void *data)
{
const u_char *bytes = data;
char *s;
int i;
if ((s = MALLOC(mtype, type->size * 2 + 1)) == NULL)
return (NULL);
for (i = 0; i < type->size; i++) {
s[i * 2] = hexchars[(bytes[i] >> 4) & 0x0f];
s[i * 2 + 1] = hexchars[bytes[i] & 0x0f];
}
s[i * 2] = '\0';
return (s);
}
int
structs_fixeddata_binify(const struct structs_type *type,
const char *ascii, void *data, char *ebuf, size_t emax)
{
u_char *bytes = data;
int i;
int j;
for (i = 0; i < type->size; i++) {
bytes[i] = 0;
for (j = 4; j >= 0; j -= 4) {
while (isspace(*ascii))
ascii++;
if (!isxdigit(*ascii)) {
strlcpy(ebuf, *ascii == '\0' ?
"hex string is too short" :
"non-hex character seen", emax);
goto fail;
}
bytes[i] |= HEXVAL(*ascii) << j;
ascii++;
}
}
while (isspace(*ascii))
ascii++;
if (*ascii != '\0') {
strlcpy(ebuf, "hex string is too long", emax);
fail: errno = EINVAL;
return (-1);
}
return (0);
}
int
structs_fixeddata_encode(const struct structs_type *type, const char *mtype,
struct structs_data *code, const void *data)
{
if ((code->data = MALLOC(mtype, type->size)) == NULL)
return (-1);
memcpy(code->data, data, type->size);
code->length = type->size;
return (0);
}
int
structs_fixeddata_decode(const struct structs_type *type, const u_char *code,
size_t cmax, void *data, char *ebuf, size_t emax)
{
if (cmax < type->size) {
strlcpy(ebuf, "encoded data is truncated", emax);
errno = EINVAL;
return (-1);
}
memcpy(data, code, type->size);
return (type->size);
}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>