/*
* 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 <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include "structs/structs.h"
#include "structs/type/array.h"
#include "structs/type/string.h"
#include "util/typed_mem.h"
/*********************************************************************
DYNAMICALLY ALLOCATED STRING TYPE
*********************************************************************/
int
structs_string_init(const struct structs_type *type, void *data)
{
return (structs_string_binify(type, "", data, NULL, 0));
}
int
structs_string_equal(const struct structs_type *type,
const void *v1, const void *v2)
{
const int as_null = type->args[1].i;
const char *const s1 = *((const char *const *)v1);
const char *const s2 = *((const char *const *)v2);
int empty1;
int empty2;
if (!as_null)
return (strcmp(s1, s2) == 0);
empty1 = (s1 == NULL) || *s1 == '\0';
empty2 = (s2 == NULL) || *s2 == '\0';
if (empty1 ^ empty2)
return (0);
if (empty1)
return (1);
return (strcmp(s1, s2) == 0);
}
char *
structs_string_ascify(const struct structs_type *type,
const char *mtype, const void *data)
{
const int as_null = type->args[1].i;
const char *s = *((const char *const *)data);
if (as_null && s == NULL)
s = "";
return (STRDUP(mtype, s));
}
int
structs_string_binify(const struct structs_type *type,
const char *ascii, void *data, char *ebuf, size_t emax)
{
const char *mtype = type->args[0].s;
const int as_null = type->args[1].i;
char *s;
(void)ebuf;
(void)emax;
if (as_null && *ascii == '\0')
s = NULL;
else if ((s = STRDUP(mtype, ascii)) == NULL)
return (-1);
*((char **)data) = s;
return (0);
}
/*
* This can be used by any type that wishes to encode its
* value using its ASCII string representation.
*/
int
structs_string_encode(const struct structs_type *type, const char *mtype,
struct structs_data *code, const void *data)
{
if ((code->data = (u_char *)structs_get_string(type,
NULL, data, mtype)) == NULL)
return (-1);
code->length = strlen((char *)code->data) + 1;
return (0);
}
/*
* This can be used by any type that wishes to encode its
* value using its ASCII string representation.
*/
int
structs_string_decode(const struct structs_type *type,
const u_char *code, size_t cmax, void *data, char *ebuf, size_t emax)
{
size_t slen;
/* Determine length of string */
for (slen = 0; slen < cmax && code[slen] != '\0'; slen++);
if (slen == cmax) {
strlcpy(ebuf, "encoded string is truncated", emax);
errno = EINVAL;
return (-1);
}
/* Set string value */
if ((*type->binify)(type, (const char *)code, data, ebuf, emax) == -1)
return (-1);
/* Done */
return (slen + 1);
}
void
structs_string_free(const struct structs_type *type, void *data)
{
const char *mtype = type->args[0].s;
char *const s = *((char **)data);
if (s != NULL) {
FREE(mtype, s);
*((char **)data) = NULL;
}
}
const struct structs_type structs_type_string
= STRUCTS_STRING_TYPE(STRUCTS_TYPE_STRING_MTYPE, 0);
const struct structs_type structs_type_string_null
= STRUCTS_STRING_TYPE(STRUCTS_TYPE_STRING_MTYPE, 1);
/*********************************************************************
BOUNDED LENGTH STRING TYPE
*********************************************************************/
int
structs_bstring_equal(const struct structs_type *type,
const void *v1, const void *v2)
{
const char *const s1 = v1;
const char *const s2 = v2;
(void)type;
return (strcmp(s1, s2) == 0);
}
char *
structs_bstring_ascify(const struct structs_type *type,
const char *mtype, const void *data)
{
const char *const s = data;
(void)type;
return (STRDUP(mtype, s));
}
int
structs_bstring_binify(const struct structs_type *type,
const char *ascii, void *data, char *ebuf, size_t emax)
{
const size_t alen = strlen(ascii);
if (alen + 1 > type->size) {
strlcpy(ebuf,
"string is too long for bounded length buffer", emax);
return (-1);
}
memcpy(data, ascii, alen + 1);
return (0);
}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>