[thirdparty/lldpd.git] / src / marshal.c

/* -*- mode: c; c-file-style: "openbsd" -*- */
/*
 * Copyright (c) 2012 Vincent Bernat <bernat@luffy.cx>
 *
 * Permission to use, copy, modify, and/or 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.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#define MARSHAL_EXPORT
#include "marshal.h"

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <string.h>

#include "compat/compat.h"
#include "log.h"

#include "lldpd-structs.h"

/* Stolen from CCAN */
#if HAVE_ALIGNOF
#  define ALIGNOF(t) (__alignof__(t))
#else
#  define ALIGNOF(t)               \
    ((sizeof(t) > 1) ?             \
	    ((char *)(&((struct {  \
  char c;                          \
  t _h;                            \
	    } *)0)                 \
			   ->_h) - \
		(char *)0) :       \
	    1)
#endif

/* A serialized object */
struct marshal_serialized {
	void *orig; /* Original reference. Also enforce alignment. */
	size_t size;
	unsigned char object[0];
};

struct marshal_info marshal_info_string = {
	.name = "null string",
	.size = 0,
	.pointers = { MARSHAL_SUBINFO_NULL },
};
struct marshal_info marshal_info_fstring = {
	.name = "fixed string",
	.size = 0,
	.pointers = { MARSHAL_SUBINFO_NULL },
};
struct marshal_info marshal_info_ignore = {
	.name = "ignored",
	.size = 0,
	.pointers = { MARSHAL_SUBINFO_NULL },
};

/* List of already seen pointers */
struct ref {
	TAILQ_ENTRY(ref) next;
	void *pointer;
	uintptr_t dummy; /* To renumerate pointers */
};
TAILQ_HEAD(ref_l, ref);

/* Serialize the given object. */
ssize_t
marshal_serialize_(struct marshal_info *mi, void *unserialized, void **input, int skip,
    void *_refs, int osize)
{
	struct ref_l *refs = _refs;
	struct ref *cref;
	int size;
	size_t len;
	struct marshal_subinfo *current;
	struct marshal_serialized *new = NULL, *serialized = NULL;
	uintptr_t dummy = 1;

	log_debug("marshal", "start serialization of %s", mi->name);

	/* Check if we have already serialized this one. */
	if (!refs) {
		refs = calloc(1, sizeof(struct ref_l));
		if (!refs) {
			log_warnx("marshal",
			    "unable to allocate memory for list of references");
			return -1;
		}
		TAILQ_INIT(refs);
	}
	TAILQ_FOREACH (cref, refs, next) {
		if (unserialized == cref->pointer) return 0;
		/* dummy should be higher than any existing dummy */
		if (cref->dummy >= dummy) dummy = cref->dummy + 1;
	}

	/* Handle special cases. */
	size = mi->size;
	if (!strcmp(mi->name, "null string")) /* We know we can't be called with NULL */
		size = strlen((char *)unserialized) + 1;
	else if (!strcmp(mi->name, "fixed string"))
		size = osize;

	/* Allocate serialized structure */
	len = sizeof(struct marshal_serialized) + (skip ? 0 : size);
	serialized = calloc(1, len);
	if (!serialized) {
		log_warnx("marshal",
		    "unable to allocate memory to serialize structure %s", mi->name);
		len = -1;
		goto marshal_error;
	}
	/* We don't use the original pointer but a dummy one. */
	serialized->orig = (unsigned char *)dummy;

	/* Append the new reference */
	if (!(cref = calloc(1, sizeof(struct ref)))) {
		log_warnx("marshal",
		    "unable to allocate memory for list of references");
		free(serialized);
		len = -1;
		goto marshal_error;
	}
	cref->pointer = unserialized;
	cref->dummy = dummy;
	TAILQ_INSERT_TAIL(refs, cref, next);

	/* First, serialize the main structure */
	if (!skip) memcpy(serialized->object, unserialized, size);

	/* Then, serialize inner structures */
	for (current = mi->pointers; current->mi; current++) {
		size_t sublen;
		size_t padlen;
		void *source;
		void *target = NULL;
		if (current->kind == ignore) continue;
		if (current->kind == pointer) {
			memcpy(&source, (unsigned char *)unserialized + current->offset,
			    sizeof(void *));
			if (source == NULL) continue;
		} else
			source =
			    (void *)((unsigned char *)unserialized + current->offset);
		if (current->offset2)
			memcpy(&osize, (unsigned char *)unserialized + current->offset2,
			    sizeof(int));
		target = NULL;
		sublen = marshal_serialize_(current->mi, source, &target,
		    current->kind == substruct, refs, osize);
		if (sublen == -1) {
			log_warnx("marshal",
			    "unable to serialize substructure %s for %s",
			    current->mi->name, mi->name);
			free(serialized);
			return -1;
		}
		/* We want to put the renumerated pointer instead of the real one. */
		if (current->kind == pointer && !skip) {
			TAILQ_FOREACH (cref, refs, next) {
				if (source == cref->pointer) {
					void *fakepointer =
					    (unsigned char *)cref->dummy;
					memcpy((unsigned char *)serialized->object +
						current->offset,
					    &fakepointer, sizeof(void *));
					break;
				}
			}
		}
		if (sublen == 0) continue; /* This was already serialized */
		/* Append the result, force alignment to be able to unserialize it */
		padlen = ALIGNOF(struct marshal_serialized);
		padlen = (padlen - (len % padlen)) % padlen;
		new = realloc(serialized, len + padlen + sublen);
		if (!new) {
			log_warnx("marshal",
			    "unable to allocate more memory to serialize structure %s",
			    mi->name);
			free(serialized);
			free(target);
			len = -1;
			goto marshal_error;
		}
		memset((unsigned char *)new + len, 0, padlen);
		memcpy((unsigned char *)new + len + padlen, target, sublen);
		free(target);
		len += sublen + padlen;
		serialized = (struct marshal_serialized *)new;
	}

	serialized->size = len;
	*input = serialized;
marshal_error:
	if (refs && !_refs) {
		struct ref *cref, *cref_next;
		for (cref = TAILQ_FIRST(refs); cref != NULL; cref = cref_next) {
			cref_next = TAILQ_NEXT(cref, next);
			TAILQ_REMOVE(refs, cref, next);
			free(cref);
		}
		free(refs);
	}
	return len;
}

/* This structure is used to track memory allocation when serializing */
struct gc {
	TAILQ_ENTRY(gc) next;
	void *pointer;
	void *orig; /* Original reference (not valid anymore !) */
};
TAILQ_HEAD(gc_l, gc);

static void *
marshal_alloc(struct gc_l *pointers, size_t len, void *orig)
{
	struct gc *gpointer = NULL;

	void *result = calloc(1, len);
	if (!result) return NULL;
	if ((gpointer = (struct gc *)calloc(1, sizeof(struct gc))) == NULL) {
		free(result);
		return NULL;
	}
	gpointer->pointer = result;
	gpointer->orig = orig;
	TAILQ_INSERT_TAIL(pointers, gpointer, next);
	return result;
}
static void
marshal_free(struct gc_l *pointers, int gconly)
{
	struct gc *pointer, *pointer_next;
	for (pointer = TAILQ_FIRST(pointers); pointer != NULL; pointer = pointer_next) {
		pointer_next = TAILQ_NEXT(pointer, next);
		TAILQ_REMOVE(pointers, pointer, next);
		if (!gconly) free(pointer->pointer);
		free(pointer);
	}
}

/* Unserialize the given object. */
size_t
marshal_unserialize_(struct marshal_info *mi, void *buffer, size_t len, void **output,
    void *_pointers, int skip, int osize)
{
	int total_len = sizeof(struct marshal_serialized) + (skip ? 0 : mi->size);
	struct marshal_serialized *serialized = buffer;
	struct gc_l *pointers = _pointers;
	int size, already, extra = 0;
	void *new;
	struct marshal_subinfo *current;
	struct gc *apointer;

	log_debug("marshal", "start unserialization of %s", mi->name);

	if (len < sizeof(struct marshal_serialized) || len < total_len) {
		log_warnx("marshal",
		    "data to deserialize is too small (%zu) for structure %s", len,
		    mi->name);
		return 0;
	}

	/* Initialize garbage collection */
	if (!pointers) {
		pointers = calloc(1, sizeof(struct gc_l));
		if (!pointers) {
			log_warnx("marshal",
			    "unable to allocate memory for garbage collection");
			return 0;
		}
		TAILQ_INIT(pointers);
	}

	/* Special cases */
	size = mi->size;
	if (!strcmp(mi->name, "null string") || !strcmp(mi->name, "fixed string")) {
		switch (mi->name[0]) {
		case 'n':
			size = strnlen((char *)serialized->object,
				   len - sizeof(struct marshal_serialized)) +
			    1;
			break;
		case 'f':
			size = osize;
			extra = 1;
			break; /* The extra byte is to ensure that
				  the string is null terminated. */
		}
		if (size > len - sizeof(struct marshal_serialized)) {
			log_warnx("marshal",
			    "data to deserialize contains a string too long");
			total_len = 0;
			goto unmarshal_error;
		}
		total_len += size;
	}

	/* First, the main structure */
	if (!skip) {
		if ((*output = marshal_alloc(pointers, size + extra,
			 serialized->orig)) == NULL) {
			log_warnx("marshal",
			    "unable to allocate memory to unserialize structure %s",
			    mi->name);
			total_len = 0;
			goto unmarshal_error;
		}
		memcpy(*output, serialized->object, size);
	}

	/* Then, each substructure */
	for (current = mi->pointers; current->mi; current++) {
		size_t sublen;
		size_t padlen;
		new = (unsigned char *)*output + current->offset;
		if (current->kind == ignore) {
			memset((unsigned char *)*output + current->offset, 0,
			    sizeof(void *));
			continue;
		}
		if (current->kind == pointer) {
			if (*(void **)new == NULL) continue;

			/* Did we already see this reference? */
			already = 0;
			TAILQ_FOREACH (apointer, pointers, next)
				if (apointer->orig == *(void **)new) {
					memcpy((unsigned char *)*output +
						current->offset,
					    &apointer->pointer, sizeof(void *));
					already = 1;
					break;
				}
			if (already) continue;
		}
		/* Deserialize */
		if (current->offset2)
			memcpy(&osize, (unsigned char *)*output + current->offset2,
			    sizeof(int));
		padlen = ALIGNOF(struct marshal_serialized);
		padlen = (padlen - (total_len % padlen)) % padlen;
		if (len < total_len + padlen ||
		    ((sublen = marshal_unserialize_(current->mi,
			  (unsigned char *)buffer + total_len + padlen,
			  len - total_len - padlen, &new, pointers,
			  current->kind == substruct, osize)) == 0)) {
			log_warnx("marshal",
			    "unable to serialize substructure %s for %s",
			    current->mi->name, mi->name);
			total_len = 0;
			goto unmarshal_error;
		}
		/* Link the result */
		if (current->kind == pointer)
			memcpy((unsigned char *)*output + current->offset, &new,
			    sizeof(void *));
		total_len += sublen + padlen;
	}

unmarshal_error:
	if (pointers && !_pointers) {
		marshal_free(pointers, (total_len > 0));
		free(pointers);
	}
	return total_len;
}
Commit	Line	Data
	1	/* -- mode: c; c-file-style: "openbsd" -- */
	2	/*
	3	* Copyright (c) 2012 Vincent Bernat <bernat@luffy.cx>
	4	*
	5	* Permission to use, copy, modify, and/or distribute this software for any
	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	10	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	11	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	12	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	13	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	14	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	15	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	16	*/
	17
	18	#define MARSHAL_EXPORT
	19	#include "marshal.h"
	20
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <sys/types.h>
	24	#include <sys/queue.h>
	25	#include <string.h>
	26
	27	#include "compat/compat.h"
	28	#include "log.h"
	29
	30	#include "lldpd-structs.h"
	31
	32	/* Stolen from CCAN */
	33	#if HAVE_ALIGNOF
	34	# define ALIGNOF(t) (__alignof__(t))
	35	#else
	36	# define ALIGNOF(t) \
	37	((sizeof(t) > 1) ? \
	38	((char *)(&((struct { \
	39	char c; \
	40	t _h; \
	41	} *)0) \
	42	->_h) - \
	43	(char *)0) : \
	44	1)
	45	#endif
	46
	47	/* A serialized object */
	48	struct marshal_serialized {
	49	void orig; / Original reference. Also enforce alignment. */
	50	size_t size;
	51	unsigned char object[0];
	52	};
	53
	54	struct marshal_info marshal_info_string = {
	55	.name = "null string",
	56	.size = 0,
	57	.pointers = { MARSHAL_SUBINFO_NULL },
	58	};
	59	struct marshal_info marshal_info_fstring = {
	60	.name = "fixed string",
	61	.size = 0,
	62	.pointers = { MARSHAL_SUBINFO_NULL },
	63	};
	64	struct marshal_info marshal_info_ignore = {
	65	.name = "ignored",
	66	.size = 0,
	67	.pointers = { MARSHAL_SUBINFO_NULL },
	68	};
	69
	70	/* List of already seen pointers */
	71	struct ref {
	72	TAILQ_ENTRY(ref) next;
	73	void *pointer;
	74	uintptr_t dummy; /* To renumerate pointers */
	75	};
	76	TAILQ_HEAD(ref_l, ref);
	77
	78	/* Serialize the given object. */
	79	ssize_t
	80	marshal_serialize_(struct marshal_info mi, void unserialized, void **input, int skip,
	81	void *_refs, int osize)
	82	{
	83	struct ref_l *refs = _refs;
	84	struct ref *cref;
	85	int size;
	86	size_t len;
	87	struct marshal_subinfo *current;
	88	struct marshal_serialized new = NULL, serialized = NULL;
	89	uintptr_t dummy = 1;
	90
	91	log_debug("marshal", "start serialization of %s", mi->name);
	92
	93	/* Check if we have already serialized this one. */
	94	if (!refs) {
	95	refs = calloc(1, sizeof(struct ref_l));
	96	if (!refs) {
	97	log_warnx("marshal",
	98	"unable to allocate memory for list of references");
	99	return -1;
	100	}
	101	TAILQ_INIT(refs);
	102	}
	103	TAILQ_FOREACH (cref, refs, next) {
	104	if (unserialized == cref->pointer) return 0;
	105	/* dummy should be higher than any existing dummy */
	106	if (cref->dummy >= dummy) dummy = cref->dummy + 1;
	107	}
	108
	109	/* Handle special cases. */
	110	size = mi->size;
	111	if (!strcmp(mi->name, "null string")) /* We know we can't be called with NULL */
	112	size = strlen((char *)unserialized) + 1;
	113	else if (!strcmp(mi->name, "fixed string"))
	114	size = osize;
	115
	116	/* Allocate serialized structure */
	117	len = sizeof(struct marshal_serialized) + (skip ? 0 : size);
	118	serialized = calloc(1, len);
	119	if (!serialized) {
	120	log_warnx("marshal",
	121	"unable to allocate memory to serialize structure %s", mi->name);
	122	len = -1;
	123	goto marshal_error;
	124	}
	125	/* We don't use the original pointer but a dummy one. */
	126	serialized->orig = (unsigned char *)dummy;
	127
	128	/* Append the new reference */
	129	if (!(cref = calloc(1, sizeof(struct ref)))) {
	130	log_warnx("marshal",
	131	"unable to allocate memory for list of references");
	132	free(serialized);
	133	len = -1;
	134	goto marshal_error;
	135	}
	136	cref->pointer = unserialized;
	137	cref->dummy = dummy;
	138	TAILQ_INSERT_TAIL(refs, cref, next);
	139
	140	/* First, serialize the main structure */
	141	if (!skip) memcpy(serialized->object, unserialized, size);
	142
	143	/* Then, serialize inner structures */
	144	for (current = mi->pointers; current->mi; current++) {
	145	size_t sublen;
	146	size_t padlen;
	147	void *source;
	148	void *target = NULL;
	149	if (current->kind == ignore) continue;
	150	if (current->kind == pointer) {
	151	memcpy(&source, (unsigned char *)unserialized + current->offset,
	152	sizeof(void *));
	153	if (source == NULL) continue;
	154	} else
	155	source =
	156	(void )((unsigned char )unserialized + current->offset);
	157	if (current->offset2)
	158	memcpy(&osize, (unsigned char *)unserialized + current->offset2,
	159	sizeof(int));
	160	target = NULL;
	161	sublen = marshal_serialize_(current->mi, source, &target,
	162	current->kind == substruct, refs, osize);
	163	if (sublen == -1) {
	164	log_warnx("marshal",
	165	"unable to serialize substructure %s for %s",
	166	current->mi->name, mi->name);
	167	free(serialized);
	168	return -1;
	169	}
	170	/* We want to put the renumerated pointer instead of the real one. */
	171	if (current->kind == pointer && !skip) {
	172	TAILQ_FOREACH (cref, refs, next) {
	173	if (source == cref->pointer) {
	174	void *fakepointer =
	175	(unsigned char *)cref->dummy;
	176	memcpy((unsigned char *)serialized->object +
	177	current->offset,
	178	&fakepointer, sizeof(void *));
	179	break;
	180	}
	181	}
	182	}
	183	if (sublen == 0) continue; /* This was already serialized */
	184	/* Append the result, force alignment to be able to unserialize it */
	185	padlen = ALIGNOF(struct marshal_serialized);
	186	padlen = (padlen - (len % padlen)) % padlen;
	187	new = realloc(serialized, len + padlen + sublen);
	188	if (!new) {
	189	log_warnx("marshal",
	190	"unable to allocate more memory to serialize structure %s",
	191	mi->name);
	192	free(serialized);
	193	free(target);
	194	len = -1;
	195	goto marshal_error;
	196	}
	197	memset((unsigned char *)new + len, 0, padlen);
	198	memcpy((unsigned char *)new + len + padlen, target, sublen);
	199	free(target);
	200	len += sublen + padlen;
	201	serialized = (struct marshal_serialized *)new;
	202	}
	203
	204	serialized->size = len;
	205	*input = serialized;
	206	marshal_error:
	207	if (refs && !_refs) {
	208	struct ref cref, cref_next;
	209	for (cref = TAILQ_FIRST(refs); cref != NULL; cref = cref_next) {
	210	cref_next = TAILQ_NEXT(cref, next);
	211	TAILQ_REMOVE(refs, cref, next);
	212	free(cref);
	213	}
	214	free(refs);
	215	}
	216	return len;
	217	}
	218
	219	/* This structure is used to track memory allocation when serializing */
	220	struct gc {
	221	TAILQ_ENTRY(gc) next;
	222	void *pointer;
	223	void orig; / Original reference (not valid anymore !) */
	224	};
	225	TAILQ_HEAD(gc_l, gc);
	226
	227	static void *
	228	marshal_alloc(struct gc_l pointers, size_t len, void orig)
	229	{
	230	struct gc *gpointer = NULL;
	231
	232	void *result = calloc(1, len);
	233	if (!result) return NULL;
	234	if ((gpointer = (struct gc *)calloc(1, sizeof(struct gc))) == NULL) {
	235	free(result);
	236	return NULL;
	237	}
	238	gpointer->pointer = result;
	239	gpointer->orig = orig;
	240	TAILQ_INSERT_TAIL(pointers, gpointer, next);
	241	return result;
	242	}
	243	static void
	244	marshal_free(struct gc_l *pointers, int gconly)
	245	{
	246	struct gc pointer, pointer_next;
	247	for (pointer = TAILQ_FIRST(pointers); pointer != NULL; pointer = pointer_next) {
	248	pointer_next = TAILQ_NEXT(pointer, next);
	249	TAILQ_REMOVE(pointers, pointer, next);
	250	if (!gconly) free(pointer->pointer);
	251	free(pointer);
	252	}
	253	}
	254
	255	/* Unserialize the given object. */
	256	size_t
	257	marshal_unserialize_(struct marshal_info mi, void buffer, size_t len, void **output,
	258	void *_pointers, int skip, int osize)
	259	{
	260	int total_len = sizeof(struct marshal_serialized) + (skip ? 0 : mi->size);
	261	struct marshal_serialized *serialized = buffer;
	262	struct gc_l *pointers = _pointers;
	263	int size, already, extra = 0;
	264	void *new;
	265	struct marshal_subinfo *current;
	266	struct gc *apointer;
	267
	268	log_debug("marshal", "start unserialization of %s", mi->name);
	269
	270	if (len < sizeof(struct marshal_serialized) \|\| len < total_len) {
	271	log_warnx("marshal",
	272	"data to deserialize is too small (%zu) for structure %s", len,
	273	mi->name);
	274	return 0;
	275	}
	276
	277	/* Initialize garbage collection */
	278	if (!pointers) {
	279	pointers = calloc(1, sizeof(struct gc_l));
	280	if (!pointers) {
	281	log_warnx("marshal",
	282	"unable to allocate memory for garbage collection");
	283	return 0;
	284	}
	285	TAILQ_INIT(pointers);
	286	}
	287
	288	/* Special cases */
	289	size = mi->size;
	290	if (!strcmp(mi->name, "null string") \|\| !strcmp(mi->name, "fixed string")) {
	291	switch (mi->name[0]) {
	292	case 'n':
	293	size = strnlen((char *)serialized->object,
	294	len - sizeof(struct marshal_serialized)) +
	295	1;
	296	break;
	297	case 'f':
	298	size = osize;
	299	extra = 1;
	300	break; /* The extra byte is to ensure that
	301	the string is null terminated. */
	302	}
	303	if (size > len - sizeof(struct marshal_serialized)) {
	304	log_warnx("marshal",
	305	"data to deserialize contains a string too long");
	306	total_len = 0;
	307	goto unmarshal_error;
	308	}
	309	total_len += size;
	310	}
	311
	312	/* First, the main structure */
	313	if (!skip) {
	314	if ((*output = marshal_alloc(pointers, size + extra,
	315	serialized->orig)) == NULL) {
	316	log_warnx("marshal",
	317	"unable to allocate memory to unserialize structure %s",
	318	mi->name);
	319	total_len = 0;
	320	goto unmarshal_error;
	321	}
	322	memcpy(*output, serialized->object, size);
	323	}
	324
	325	/* Then, each substructure */
	326	for (current = mi->pointers; current->mi; current++) {
	327	size_t sublen;
	328	size_t padlen;
	329	new = (unsigned char )output + current->offset;
	330	if (current->kind == ignore) {
	331	memset((unsigned char )output + current->offset, 0,
	332	sizeof(void *));
	333	continue;
	334	}
	335	if (current->kind == pointer) {
	336	if ((void *)new == NULL) continue;
	337
	338	/* Did we already see this reference? */
	339	already = 0;
	340	TAILQ_FOREACH (apointer, pointers, next)
	341	if (apointer->orig == (void *)new) {
	342	memcpy((unsigned char )output +
	343	current->offset,
	344	&apointer->pointer, sizeof(void *));
	345	already = 1;
	346	break;
	347	}
	348	if (already) continue;
	349	}
	350	/* Deserialize */
	351	if (current->offset2)
	352	memcpy(&osize, (unsigned char )output + current->offset2,
	353	sizeof(int));
	354	padlen = ALIGNOF(struct marshal_serialized);
	355	padlen = (padlen - (total_len % padlen)) % padlen;
	356	if (len < total_len + padlen \|\|
	357	((sublen = marshal_unserialize_(current->mi,
	358	(unsigned char *)buffer + total_len + padlen,
	359	len - total_len - padlen, &new, pointers,
	360	current->kind == substruct, osize)) == 0)) {
	361	log_warnx("marshal",
	362	"unable to serialize substructure %s for %s",
	363	current->mi->name, mi->name);
	364	total_len = 0;
	365	goto unmarshal_error;
	366	}
	367	/* Link the result */
	368	if (current->kind == pointer)
	369	memcpy((unsigned char )output + current->offset, &new,
	370	sizeof(void *));
	371	total_len += sublen + padlen;
	372	}
	373
	374	unmarshal_error:
	375	if (pointers && !_pointers) {
	376	marshal_free(pointers, (total_len > 0));
	377	free(pointers);
	378	}
	379	return total_len;
	380	}