/*
This file is part of GNUnet.
- (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
*/
#include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_container_lib.h"
-#include "gnunet_strings_lib.h"
-#include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"
+#if HAVE_EXTRACTOR_H
#include <extractor.h>
+#endif
#include <zlib.h>
-#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "util-container-meta-data", __VA_ARGS__)
+
+
+
+/**
+ * Try to compress the given block of data using libz. Only returns
+ * the compressed block if compression worked and the new block is
+ * actually smaller. Decompress using #GNUNET_decompress().
+ *
+ * @param data block to compress; if compression
+ * resulted in a smaller block, the first
+ * bytes of data are updated to the compressed
+ * data
+ * @param old_size number of bytes in data
+ * @param[out] result set to the compressed data, if compression worked
+ * @param[out] new_size set to size of result, if compression worked
+ * @return #GNUNET_YES if compression reduce the size,
+ * #GNUNET_NO if compression did not help
+ */
+int
+GNUNET_try_compression (const char *data,
+ size_t old_size,
+ char **result,
+ size_t *new_size)
+{
+ char *tmp;
+ uLongf dlen;
+
+ *result = NULL;
+ *new_size = 0;
+#ifdef compressBound
+ dlen = compressBound (old_size);
+#else
+ dlen = old_size + (old_size / 100) + 20;
+ /* documentation says 100.1% oldSize + 12 bytes, but we
+ * should be able to overshoot by more to be safe */
+#endif
+ tmp = GNUNET_malloc (dlen);
+ if (Z_OK ==
+ compress2 ((Bytef *) tmp,
+ &dlen,
+ (const Bytef *) data,
+ old_size, 9))
+ {
+ if (dlen < old_size)
+ {
+ *result = tmp;
+ *new_size = dlen;
+ return GNUNET_YES;
+ }
+ }
+ GNUNET_free (tmp);
+ return GNUNET_NO;
+}
+
+
+/**
+ * Decompress input, return the decompressed data as output. Dual to
+ * #GNUNET_try_compression(). Caller must set @a output_size to the
+ * number of bytes that were originally compressed.
+ *
+ * @param input compressed data
+ * @param input_size number of bytes in input
+ * @param output_size expected size of the output
+ * @return NULL on error, buffer of @a output_size decompressed bytes otherwise
+ */
+char *
+GNUNET_decompress (const char *input,
+ size_t input_size,
+ size_t output_size)
+{
+ char *output;
+ uLongf olen;
+
+ olen = output_size;
+ output = GNUNET_malloc (olen);
+ if (Z_OK ==
+ uncompress ((Bytef *) output,
+ &olen,
+ (const Bytef *) input,
+ input_size))
+ return output;
+ GNUNET_free (output);
+ return NULL;
+}
+
/**
* Meta data item.
struct MetaItem
{
/**
- * This is a linked list.
+ * This is a doubly linked list.
*/
struct MetaItem *next;
+ /**
+ * This is a doubly linked list.
+ */
+ struct MetaItem *prev;
+
/**
* Name of the extracting plugin.
*/
struct GNUNET_CONTAINER_MetaData
{
/**
- * Linked list of the meta data items.
+ * Head of linked list of the meta data items.
+ */
+ struct MetaItem *items_head;
+
+ /**
+ * Tail of linked list of the meta data items.
*/
- struct MetaItem *items;
+ struct MetaItem *items_tail;
/**
* Complete serialized and compressed buffer of the items.
struct GNUNET_CONTAINER_MetaData *
GNUNET_CONTAINER_meta_data_create ()
{
- return GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_MetaData));
+ return GNUNET_new (struct GNUNET_CONTAINER_MetaData);
}
/**
* Free meta data item.
*
- * @param item item to free
+ * @param mi item to free
*/
static void
-meta_item_free (struct MetaItem *item)
+meta_item_free (struct MetaItem *mi)
{
- GNUNET_free_non_null (item->plugin_name);
- GNUNET_free_non_null (item->mime_type);
- GNUNET_free_non_null (item->data);
- GNUNET_free (item);
+ GNUNET_free_non_null (mi->plugin_name);
+ GNUNET_free_non_null (mi->mime_type);
+ GNUNET_free_non_null (mi->data);
+ GNUNET_free (mi);
}
static void
invalidate_sbuf (struct GNUNET_CONTAINER_MetaData *md)
{
- if (md->sbuf == NULL)
+ if (NULL == md->sbuf)
return;
GNUNET_free (md->sbuf);
md->sbuf = NULL;
void
GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md)
{
- struct MetaItem *item;
+ struct MetaItem *pos;
- if (md == NULL)
+ if (NULL == md)
return;
- while (NULL != (item = md->items))
+ while (NULL != (pos = md->items_head))
{
- md->items = item->next;
- meta_item_free (item);
+ GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, pos);
+ meta_item_free (pos);
}
GNUNET_free_non_null (md->sbuf);
GNUNET_free (md);
void
GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md)
{
- struct MetaItem *item;
+ struct MetaItem *mi;
- if (md == NULL)
+ if (NULL == md)
return;
- while (NULL != (item = md->items))
+ while (NULL != (mi = md->items_head))
{
- md->items = item->next;
- meta_item_free (item);
+ GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, mi);
+ meta_item_free (mi);
}
GNUNET_free_non_null (md->sbuf);
memset (md, 0, sizeof (struct GNUNET_CONTAINER_MetaData));
}
-
/**
* Test if two MDs are equal. We consider them equal if
* the meta types, formats and content match (we do not
*
* @param md1 first value to check
* @param md2 other value to check
- * @return GNUNET_YES if they are equal
+ * @return #GNUNET_YES if they are equal
*/
int
GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
return GNUNET_YES;
if (md1->item_count != md2->item_count)
return GNUNET_NO;
-
- i = md1->items;
- while (NULL != i)
+ for (i = md1->items_head; NULL != i; i = i->next)
{
found = GNUNET_NO;
- j = md2->items;
- while (NULL != j)
+ for (j = md2->items_head; NULL != j; j = j->next)
{
if ((i->type == j->type) && (i->format == j->format) &&
(i->data_size == j->data_size) &&
found = GNUNET_YES;
break;
}
- j = j->next;
+ if (j->data_size < i->data_size)
+ break; /* elements are sorted by (decreasing) size... */
}
- if (found == GNUNET_NO)
+ if (GNUNET_NO == found)
return GNUNET_NO;
- i = i->next;
}
return GNUNET_YES;
}
* @param data_mime_type mime-type of data (not of the original file);
* can be NULL (if mime-type is not known)
* @param data actual meta-data found
- * @param data_len number of bytes in data
- * @return GNUNET_OK on success, GNUNET_SYSERR if this entry already exists
+ * @param data_size number of bytes in @a data
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if this entry already exists
* data_mime_type and plugin_name are not considered for "exists" checks
*/
int
enum EXTRACTOR_MetaType type,
enum EXTRACTOR_MetaFormat format,
const char *data_mime_type, const char *data,
- size_t data_len)
+ size_t data_size)
{
- struct MetaItem *prev;
struct MetaItem *pos;
- struct MetaItem *i;
+ struct MetaItem *mi;
char *p;
- prev = NULL;
- pos = md->items;
- while (NULL != pos)
+ if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
+ (EXTRACTOR_METAFORMAT_C_STRING == format))
+ GNUNET_break ('\0' == data[data_size - 1]);
+
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
{
- if (pos->data_size < data_len)
- break;
- if ((pos->type == type) && (pos->data_size == data_len) &&
- (0 == memcmp (pos->data, data, data_len)))
+ if (pos->data_size < data_size)
+ break; /* elements are sorted by size in the list */
+ if ((pos->type == type) && (pos->data_size == data_size) &&
+ (0 == memcmp (pos->data, data, data_size)))
{
- if ((pos->mime_type == NULL) && (data_mime_type != NULL))
+ if ((NULL == pos->mime_type) && (NULL != data_mime_type))
{
pos->mime_type = GNUNET_strdup (data_mime_type);
invalidate_sbuf (md);
}
- if ((pos->format == EXTRACTOR_METAFORMAT_C_STRING) &&
- (format == EXTRACTOR_METAFORMAT_UTF8))
+ if ((EXTRACTOR_METAFORMAT_C_STRING == pos->format) &&
+ (EXTRACTOR_METAFORMAT_UTF8 == format))
{
pos->format = EXTRACTOR_METAFORMAT_UTF8;
invalidate_sbuf (md);
}
return GNUNET_SYSERR;
}
- prev = pos;
- pos = pos->next;
}
md->item_count++;
- i = GNUNET_malloc (sizeof (struct MetaItem));
- i->type = type;
- i->format = format;
- i->data_size = data_len;
- i->next = pos;
- if (prev == NULL)
- md->items = i;
+ mi = GNUNET_new (struct MetaItem);
+ mi->type = type;
+ mi->format = format;
+ mi->data_size = data_size;
+ if (NULL == pos)
+ GNUNET_CONTAINER_DLL_insert_tail (md->items_head,
+ md->items_tail,
+ mi);
else
- prev->next = i;
- i->mime_type =
- (data_mime_type == NULL) ? NULL : GNUNET_strdup (data_mime_type);
- i->plugin_name = (plugin_name == NULL) ? NULL : GNUNET_strdup (plugin_name);
- i->data = GNUNET_malloc (data_len);
- memcpy (i->data, data, data_len);
- /* change OS native dir separators to unix '/' and others to '_' */
- if ( (type == EXTRACTOR_METATYPE_FILENAME) ||
- (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME) )
+ GNUNET_CONTAINER_DLL_insert_after (md->items_head,
+ md->items_tail,
+ pos->prev,
+ mi);
+ mi->mime_type =
+ (NULL == data_mime_type) ? NULL : GNUNET_strdup (data_mime_type);
+ mi->plugin_name = (NULL == plugin_name) ? NULL : GNUNET_strdup (plugin_name);
+ mi->data = GNUNET_malloc (data_size);
+ GNUNET_memcpy (mi->data, data, data_size);
+ /* change all dir separators to POSIX style ('/') */
+ if ( (EXTRACTOR_METATYPE_FILENAME == type) ||
+ (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type) )
{
- p = i->data;
- while ((*p != '\0') && (p < i->data + data_len))
+ p = mi->data;
+ while (('\0' != *p) && (p < mi->data + data_size))
{
- if (*p == DIR_SEPARATOR)
+ if ('\\' == *p)
*p = '/';
- else if (*p == '\\')
- *p = '_';
p++;
}
}
/**
* Merge given meta data.
*
- * @param cls the 'struct GNUNET_CONTAINER_MetaData' to merge into
+ * @param cls the `struct GNUNET_CONTAINER_MetaData` to merge into
* @param plugin_name name of the plugin that produced this value;
* special values can be used (i.e. '<zlib>' for zlib being
* used in the main libextractor library and yielding
* @param data_mime_type mime-type of data (not of the original file);
* can be NULL (if mime-type is not known)
* @param data actual meta-data found
- * @param data_len number of bytes in data
+ * @param data_size number of bytes in @a data
* @return 0 (to continue)
*/
static int
merge_helper (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
enum EXTRACTOR_MetaFormat format, const char *data_mime_type,
- const char *data, size_t data_len)
+ const char *data, size_t data_size)
{
struct GNUNET_CONTAINER_MetaData *md = cls;
(void) GNUNET_CONTAINER_meta_data_insert (md, plugin_name, type, format,
- data_mime_type, data, data_len);
+ data_mime_type, data, data_size);
return 0;
}
* @param type type of the item to remove
* @param data specific value to remove, NULL to remove all
* entries of the given type
- * @param data_len number of bytes in data
- * @return GNUNET_OK on success, GNUNET_SYSERR if the item does not exist in md
+ * @param data_size number of bytes in @a data
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the item does not exist in md
*/
int
GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
enum EXTRACTOR_MetaType type,
- const char *data, size_t data_len)
+ const char *data, size_t data_size)
{
struct MetaItem *pos;
- struct MetaItem *prev;
- prev = NULL;
- pos = md->items;
- while (NULL != pos)
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
{
+ if (pos->data_size < data_size)
+ break; /* items are sorted by (decreasing) size */
if ((pos->type == type) &&
- ((data == NULL) ||
- ((pos->data_size == data_len) &&
- (0 == memcmp (pos->data, data, data_len)))))
+ ((NULL == data) ||
+ ((pos->data_size == data_size) &&
+ (0 == memcmp (pos->data, data, data_size)))))
{
- if (prev == NULL)
- md->items = pos->next;
- else
- prev->next = pos->next;
+ GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, pos);
meta_item_free (pos);
md->item_count--;
invalidate_sbuf (md);
return GNUNET_OK;
}
- prev = pos;
- pos = pos->next;
}
return GNUNET_SYSERR;
}
GNUNET_CONTAINER_meta_data_add_publication_date (struct
GNUNET_CONTAINER_MetaData *md)
{
- char *dat;
+ const char *dat;
struct GNUNET_TIME_Absolute t;
t = GNUNET_TIME_absolute_get ();
- GNUNET_CONTAINER_meta_data_delete (md, EXTRACTOR_METATYPE_PUBLICATION_DATE,
+ GNUNET_CONTAINER_meta_data_delete (md,
+ EXTRACTOR_METATYPE_PUBLICATION_DATE,
NULL, 0);
dat = GNUNET_STRINGS_absolute_time_to_string (t);
GNUNET_CONTAINER_meta_data_insert (md, "<gnunet>",
EXTRACTOR_METATYPE_PUBLICATION_DATE,
EXTRACTOR_METAFORMAT_UTF8, "text/plain",
dat, strlen (dat) + 1);
- GNUNET_free (dat);
}
{
struct MetaItem *pos;
- if (md == NULL)
+ if (NULL == md)
return 0;
- if (iter == NULL)
+ if (NULL == iter)
return md->item_count;
- pos = md->items;
- while (NULL != pos)
- {
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
if (0 !=
iter (iter_cls, pos->plugin_name, pos->type, pos->format,
pos->mime_type, pos->data, pos->data_size))
return md->item_count;
- pos = pos->next;
- }
return md->item_count;
}
* @return NULL if no entry was found
*/
char *
-GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData
- *md, enum EXTRACTOR_MetaType type)
+GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData *md,
+ enum EXTRACTOR_MetaType type)
{
struct MetaItem *pos;
- if (md == NULL)
+ if (NULL == md)
return NULL;
- pos = md->items;
- while (NULL != pos)
- {
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
if ((type == pos->type) &&
((pos->format == EXTRACTOR_METAFORMAT_UTF8) ||
(pos->format == EXTRACTOR_METAFORMAT_C_STRING)))
return GNUNET_strdup (pos->data);
- pos = pos->next;
- }
return NULL;
}
{
char *ret;
va_list args;
- enum EXTRACTOR_MetaType type;
+ int type;
- if (md == NULL)
+ if (NULL == md)
return NULL;
ret = NULL;
va_start (args, md);
while (1)
{
- type = va_arg (args, enum EXTRACTOR_MetaType);
-
- if (type == -1)
+ type = va_arg (args, int);
+ if (-1 == type)
break;
- ret = GNUNET_CONTAINER_meta_data_get_by_type (md, type);
- if (ret != NULL)
+ if (NULL != (ret = GNUNET_CONTAINER_meta_data_get_by_type (md, type)))
break;
}
va_end (args);
struct MetaItem *pos;
struct MetaItem *match;
- if (md == NULL)
+ if (NULL == md)
return 0;
match = NULL;
- pos = md->items;
- while (NULL != pos)
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
{
if ((NULL != pos->mime_type) &&
(0 == strncasecmp ("image/", pos->mime_type, strlen ("image/"))) &&
- (pos->format == EXTRACTOR_METAFORMAT_BINARY))
+ (EXTRACTOR_METAFORMAT_BINARY == pos->format))
{
- if (match == NULL)
+ if (NULL == match)
match = pos;
else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
(pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
match = pos;
}
- pos = pos->next;
}
- if ((match == NULL) || (match->data_size == 0))
+ if ((NULL == match) || (0 == match->data_size))
return 0;
*thumb = GNUNET_malloc (match->data_size);
- memcpy (*thumb, match->data, match->data_size);
+ GNUNET_memcpy (*thumb, match->data, match->data_size);
return match->data_size;
}
/**
- * Duplicate struct GNUNET_CONTAINER_MetaData.
+ * Duplicate a `struct GNUNET_CONTAINER_MetaData`.
*
* @param md what to duplicate
* @return duplicate meta-data container
struct GNUNET_CONTAINER_MetaData *ret;
struct MetaItem *pos;
- if (md == NULL)
+ if (NULL == md)
return NULL;
ret = GNUNET_CONTAINER_meta_data_create ();
- pos = md->items;
- while (NULL != pos)
- {
+ for (pos = md->items_tail; NULL != pos; pos = pos->prev)
GNUNET_CONTAINER_meta_data_insert (ret, pos->plugin_name, pos->type,
pos->format, pos->mime_type, pos->data,
pos->data_size);
- pos = pos->next;
- }
return ret;
}
-
-/**
- * Try to compress the given block of data.
- *
- * @param data block to compress; if compression
- * resulted in a smaller block, the first
- * bytes of data are updated to the compressed
- * data
- * @param oldSize number of bytes in data
- * @param result set to the compressed data
- * @param newSize set to size of result
- * @return GNUNET_YES if compression reduce the size,
- * GNUNET_NO if compression did not help
- */
-static int
-try_compression (const char *data, size_t oldSize, char **result,
- size_t * newSize)
-{
- char *tmp;
- uLongf dlen;
-
-#ifdef compressBound
- dlen = compressBound (oldSize);
-#else
- dlen = oldSize + (oldSize / 100) + 20;
- /* documentation says 100.1% oldSize + 12 bytes, but we
- * should be able to overshoot by more to be safe */
-#endif
- tmp = GNUNET_malloc (dlen);
- if (Z_OK ==
- compress2 ((Bytef *) tmp, &dlen, (const Bytef *) data, oldSize, 9))
- {
- if (dlen < oldSize)
- {
- *result = tmp;
- *newSize = dlen;
- return GNUNET_YES;
- }
- }
- GNUNET_free (tmp);
- return GNUNET_NO;
-}
-
-
/**
* Flag in 'version' that indicates compressed meta-data.
*/
* meta-data to match the size constraint,
* possibly discarding some data?
* @return number of bytes written on success,
- * GNUNET_SYSERR on error (typically: not enough
+ * #GNUNET_SYSERR on error (typically: not enough
* space)
*/
ssize_t
if (max < sizeof (struct MetaDataHeader))
return GNUNET_SYSERR; /* far too small */
- if (md == NULL)
+ if (NULL == md)
return 0;
- if (md->sbuf != NULL)
+ if (NULL != md->sbuf)
{
/* try to use serialization cache */
if (md->sbuf_size <= max)
{
if (NULL == *target)
*target = GNUNET_malloc (md->sbuf_size);
- memcpy (*target, md->sbuf, md->sbuf_size);
+ GNUNET_memcpy (*target, md->sbuf, md->sbuf_size);
return md->sbuf_size;
}
if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
}
dst = NULL;
msize = 0;
- pos = md->items;
- while (NULL != pos)
+ for (pos = md->items_tail; NULL != pos; pos = pos->prev)
{
msize += sizeof (struct MetaDataEntry);
msize += pos->data_size;
- if (pos->plugin_name != NULL)
+ if (NULL != pos->plugin_name)
msize += strlen (pos->plugin_name) + 1;
- if (pos->mime_type != NULL)
+ if (NULL != pos->mime_type)
msize += strlen (pos->mime_type) + 1;
- pos = pos->next;
}
size = (size_t) msize;
if (size != msize)
mdata = (char *) &ent[md->item_count];
off = size - (md->item_count * sizeof (struct MetaDataEntry));
i = 0;
- pos = md->items;
- while (NULL != pos)
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
{
ent[i].type = htonl ((uint32_t) pos->type);
ent[i].format = htonl ((uint32_t) pos->format);
ent[i].data_size = htonl ((uint32_t) pos->data_size);
- if (pos->plugin_name == NULL)
+ if (NULL == pos->plugin_name)
plen = 0;
else
plen = strlen (pos->plugin_name) + 1;
ent[i].plugin_name_len = htonl ((uint32_t) plen);
- if (pos->mime_type == NULL)
+ if (NULL == pos->mime_type)
mlen = 0;
else
mlen = strlen (pos->mime_type) + 1;
ent[i].mime_type_len = htonl ((uint32_t) mlen);
off -= pos->data_size;
- memcpy (&mdata[off], pos->data, pos->data_size);
+ if ((EXTRACTOR_METAFORMAT_UTF8 == pos->format) ||
+ (EXTRACTOR_METAFORMAT_C_STRING == pos->format))
+ GNUNET_break ('\0' == pos->data[pos->data_size - 1]);
+ GNUNET_memcpy (&mdata[off], pos->data, pos->data_size);
off -= plen;
- if (pos->plugin_name != NULL)
- memcpy (&mdata[off], pos->plugin_name, plen);
+ if (NULL != pos->plugin_name)
+ GNUNET_memcpy (&mdata[off], pos->plugin_name, plen);
off -= mlen;
- if (pos->mime_type != NULL)
- memcpy (&mdata[off], pos->mime_type, mlen);
+ if (NULL != pos->mime_type)
+ GNUNET_memcpy (&mdata[off], pos->mime_type, mlen);
i++;
- pos = pos->next;
}
- GNUNET_assert (off == 0);
+ GNUNET_assert (0 == off);
clen = 0;
cdata = NULL;
left = size;
i = 0;
- pos = md->items;
- while (pos != NULL)
+ for (pos = md->items_head; NULL != pos; pos = pos->next)
{
comp = GNUNET_NO;
if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS))
- comp = try_compression ((const char *) &ent[i], left, &cdata, &clen);
+ comp = GNUNET_try_compression ((const char *) &ent[i],
+ left,
+ &cdata,
+ &clen);
- if ((md->sbuf == NULL) && (i == 0))
+ if ((NULL == md->sbuf) && (0 == i))
{
/* fill 'sbuf'; this "modifies" md, but since this is only
* an internal cache we will cast away the 'const' instead
{
GNUNET_assert (clen < left);
hdr->version = htonl (2 | HEADER_COMPRESSED);
- memcpy (&hdr[1], cdata, clen);
+ GNUNET_memcpy (&hdr[1], cdata, clen);
vmd->sbuf_size = clen + sizeof (struct MetaDataHeader);
}
else
{
hdr->version = htonl (2);
- memcpy (&hdr[1], &ent[0], left);
+ GNUNET_memcpy (&hdr[1], &ent[0], left);
vmd->sbuf_size = left + sizeof (struct MetaDataHeader);
}
vmd->sbuf = (char *) hdr;
}
if (((left + sizeof (struct MetaDataHeader)) <= max) ||
- ((comp == GNUNET_YES) && (clen <= max)))
+ ((GNUNET_YES == comp) && (clen <= max)))
{
/* success, this now fits! */
if (GNUNET_YES == comp)
{
- if (dst == NULL)
+ if (NULL == dst)
dst = GNUNET_malloc (clen + sizeof (struct MetaDataHeader));
hdr = (struct MetaDataHeader *) dst;
hdr->version = htonl (2 | HEADER_COMPRESSED);
hdr->size = htonl (left);
hdr->entries = htonl (md->item_count - i);
- memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen);
+ GNUNET_memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen);
GNUNET_free (cdata);
+ cdata = NULL;
GNUNET_free (ent);
rlen = clen + sizeof (struct MetaDataHeader);
}
else
{
- if (dst == NULL)
+ if (NULL == dst)
dst = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
hdr = (struct MetaDataHeader *) dst;
hdr->version = htonl (2);
hdr->entries = htonl (md->item_count - i);
hdr->size = htonl (left);
- memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left);
+ GNUNET_memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left);
GNUNET_free (ent);
rlen = left + sizeof (struct MetaDataHeader);
}
if (NULL != *target)
{
- memcpy (*target, dst, clen + sizeof (struct MetaDataHeader));
+ if (GNUNET_YES == comp)
+ GNUNET_memcpy (*target, dst, clen + sizeof (struct MetaDataHeader));
+ else
+ GNUNET_memcpy (*target, dst, left + sizeof (struct MetaDataHeader));
GNUNET_free (dst);
}
else
* end and try again without it */
left -= sizeof (struct MetaDataEntry);
left -= pos->data_size;
- if (pos->plugin_name != NULL)
+ if (NULL != pos->plugin_name)
left -= strlen (pos->plugin_name) + 1;
- if (pos->mime_type != NULL)
+ if (NULL != pos->mime_type)
left -= strlen (pos->mime_type) + 1;
- pos = pos->next;
+
+ GNUNET_free_non_null (cdata);
+ cdata = NULL;
+
i++;
}
GNUNET_free (ent);
ihdr.version = htonl (2);
ihdr.entries = htonl (0);
ihdr.size = htonl (0);
- if (*target == NULL)
- *target = GNUNET_malloc (sizeof (struct MetaDataHeader));
- memcpy (*target, &ihdr, sizeof (struct MetaDataHeader));
+ if (NULL == *target)
+ *target = (char *) GNUNET_new (struct MetaDataHeader);
+ GNUNET_memcpy (*target, &ihdr, sizeof (struct MetaDataHeader));
return sizeof (struct MetaDataHeader);
}
ssize_t ret;
char *ptr;
- if (md->sbuf != NULL)
+ if (NULL != md->sbuf)
return md->sbuf_size;
ptr = NULL;
ret =
GNUNET_CONTAINER_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
- if (ret != -1)
+ if (-1 != ret)
GNUNET_free (ptr);
return ret;
}
-/**
- * Decompress input, return the decompressed data
- * as output, set outputSize to the number of bytes
- * that were found.
- *
- * @param input compressed data
- * @param inputSize number of bytes in input
- * @param outputSize expected size of the output
- * @return NULL on error
- */
-static char *
-decompress (const char *input, size_t inputSize, size_t outputSize)
-{
- char *output;
- uLongf olen;
-
- olen = outputSize;
- output = GNUNET_malloc (olen);
- if (Z_OK ==
- uncompress ((Bytef *) output, &olen, (const Bytef *) input, inputSize))
- {
- return output;
- }
- else
- {
- GNUNET_free (output);
- return NULL;
- }
-}
-
-
/**
* Deserialize meta-data. Initializes md.
*
if (size < sizeof (struct MetaDataHeader))
return NULL;
- memcpy (&hdr, input, sizeof (struct MetaDataHeader));
+ GNUNET_memcpy (&hdr, input, sizeof (struct MetaDataHeader));
version = ntohl (hdr.version) & HEADER_VERSION_MASK;
compressed = (ntohl (hdr.version) & HEADER_COMPRESSED) != 0;
- if (version == 1)
+ if (1 == version)
return NULL; /* null pointer */
- if (version != 2)
+ if (2 != version)
{
GNUNET_break_op (0); /* unsupported version */
return NULL;
ic = ntohl (hdr.entries);
dataSize = ntohl (hdr.size);
- if ((sizeof (struct MetaDataEntry) * ic) > dataSize)
+ if ( ((sizeof (struct MetaDataEntry) * ic) > dataSize) ||
+ ( (0 != ic) &&
+ (dataSize / ic < sizeof (struct MetaDataEntry)) ) )
{
GNUNET_break_op (0);
return NULL;
return NULL;
}
data =
- decompress ((const char *) &input[sizeof (struct MetaDataHeader)],
- size - sizeof (struct MetaDataHeader), dataSize);
- if (data == NULL)
+ GNUNET_decompress ((const char *) &input[sizeof (struct MetaDataHeader)],
+ size - sizeof (struct MetaDataHeader),
+ dataSize);
+ if (NULL == data)
{
GNUNET_break_op (0);
return NULL;
mdata = &cdata[ic * sizeof (struct MetaDataEntry)];
for (i = 0; i < ic; i++)
{
- memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)],
+ GNUNET_memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)],
sizeof (struct MetaDataEntry));
format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format);
- if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
- (format != EXTRACTOR_METAFORMAT_C_STRING) &&
- (format != EXTRACTOR_METAFORMAT_BINARY))
+ if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
+ (EXTRACTOR_METAFORMAT_C_STRING != format) &&
+ (EXTRACTOR_METAFORMAT_BINARY != format))
{
GNUNET_break_op (0);
break;
}
left -= dlen;
meta_data = &mdata[left];
- if ((format == EXTRACTOR_METAFORMAT_UTF8) ||
- (format == EXTRACTOR_METAFORMAT_C_STRING))
+ if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
+ (EXTRACTOR_METAFORMAT_C_STRING == format))
{
- if ((dlen == 0) || (mdata[left + dlen - 1] != '\0'))
+ if (0 == dlen)
+ {
+ GNUNET_break_op (0);
+ break;
+ }
+ if ('\0' != meta_data[dlen - 1])
{
GNUNET_break_op (0);
break;
break;
}
left -= plen;
- if ((plen > 0) && (mdata[left + plen - 1] != '\0'))
+ if ((plen > 0) && ('\0' != mdata[left + plen - 1]))
{
GNUNET_break_op (0);
break;
}
- if (plen == 0)
+ if (0 == plen)
plugin_name = NULL;
else
plugin_name = &mdata[left];
break;
}
left -= mlen;
- if ((mlen > 0) && (mdata[left + mlen - 1] != '\0'))
+ if ((mlen > 0) && ('\0' != mdata[left + mlen - 1]))
{
GNUNET_break_op (0);
break;
}
- if (mlen == 0)
+ if (0 == mlen)
mime_type = NULL;
else
mime_type = &mdata[left];
projects / oweals / gnunet.git / blobdiff