Container library: Metadata

GNU libextractor key-value pairs. More...

Enumerations
enum	GNUNET_CONTAINER_MetaDataSerializationOptions { GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL = 0, GNUNET_CONTAINER_META_DATA_SERIALIZE_PART = 1, GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS = 2 }
	Options for metadata serialization. More...

Functions
struct GNUNET_CONTAINER_MetaData *	GNUNET_CONTAINER_meta_data_create (void)
	Create a fresh meta data container. More...
struct GNUNET_CONTAINER_MetaData *	GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData *md)
	Duplicate a MetaData token. More...
void	GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md)
	Free meta data. More...
int	GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData *md1, const struct GNUNET_CONTAINER_MetaData *md2)
	Test if two MDs are equal. More...
int	GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md, const char *plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char *data_mime_type, const char *data, size_t data_size)
	Extend metadata. More...
void	GNUNET_CONTAINER_meta_data_merge (struct GNUNET_CONTAINER_MetaData *md, const struct GNUNET_CONTAINER_MetaData *in)
	Extend metadata. More...
int	GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md, enum EXTRACTOR_MetaType type, const char *data, size_t data_size)
	Remove an item. More...
void	GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md)
	Remove all items in the container. More...
void	GNUNET_CONTAINER_meta_data_add_publication_date (struct GNUNET_CONTAINER_MetaData *md)
	Add the current time as the publication date to the meta-data. More...
int	GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
	Iterate over MD entries. More...
char *	GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData *md, enum EXTRACTOR_MetaType type)
	Get the first MD entry of the given type. More...
char *	GNUNET_CONTAINER_meta_data_get_first_by_types (const struct GNUNET_CONTAINER_MetaData *md,...)
	Get the first matching MD entry of the given types. More...
size_t	GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData *md, unsigned char **thumb)
	Get a thumbnail from the meta-data (if present). More...
ssize_t	GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData *md, char **target, size_t max, enum GNUNET_CONTAINER_MetaDataSerializationOptions opt)
	Serialize meta-data to target. More...
ssize_t	GNUNET_CONTAINER_meta_data_get_serialized_size (const struct GNUNET_CONTAINER_MetaData *md)
	Get the size of the full meta-data in serialized form. More...
struct GNUNET_CONTAINER_MetaData *	GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size)
	Deserialize meta-data. More...

Detailed Description

GNU libextractor key-value pairs.

Enumeration Type Documentation

GNUNET_CONTAINER_MetaDataSerializationOptions

enum GNUNET_CONTAINER_MetaDataSerializationOptions

Options for metadata serialization.

Enumerator
GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL	Serialize all of the data.
GNUNET_CONTAINER_META_DATA_SERIALIZE_PART	If not enough space is available, it is acceptable to only serialize some of the metadata.
GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS	Speed is of the essence, do not allow compression.

Definition at line 630 of file gnunet_container_lib.h.

                                                   {
  GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL = 0,

  GNUNET_CONTAINER_META_DATA_SERIALIZE_PART = 1,

  GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS = 2
};

Function Documentation

GNUNET_CONTAINER_meta_data_create()

struct GNUNET_CONTAINER_MetaData* GNUNET_CONTAINER_meta_data_create

(

void

)

Create a fresh meta data container.

Returns

empty meta-data container

Create a fresh meta data container.

Returns

empty meta-data container

Definition at line 204 of file container_meta_data.c.

References GNUNET_new.

Referenced by extract_files(), get_file_information(), getopt_set_metadata(), GNUNET_CONTAINER_meta_data_deserialize(), GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_FS_directory_builder_create(), GNUNET_FS_file_information_create_from_reader(), migrate_and_drop_metadata(), process_kblock(), and share_tree_trim().

{
  return GNUNET_new(struct GNUNET_CONTAINER_MetaData);
}

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_duplicate()

struct GNUNET_CONTAINER_MetaData* GNUNET_CONTAINER_meta_data_duplicate

(

const struct GNUNET_CONTAINER_MetaData *

md

)

Duplicate a MetaData token.

Parameters

md	what to duplicate

Returns

duplicate meta-data container

Duplicate a MetaData token.

Parameters

md	what to duplicate

Returns

duplicate meta-data container

Definition at line 667 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, MetaItem::format, GNUNET_CONTAINER_meta_data_create(), GNUNET_CONTAINER_meta_data_insert(), GNUNET_CONTAINER_MetaData::items_tail, MetaItem::mime_type, MetaItem::plugin_name, MetaItem::prev, ret, and MetaItem::type.

Referenced by create_download_context(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_builder_create(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_probe(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), process_ksk_result(), and process_sks_result().

{
  struct GNUNET_CONTAINER_MetaData *ret;
  struct MetaItem *pos;

  if (NULL == md)
    return NULL;
  ret = GNUNET_CONTAINER_meta_data_create();
  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);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_destroy()

void GNUNET_CONTAINER_meta_data_destroy

(

struct GNUNET_CONTAINER_MetaData *

md

)

Free meta data.

Parameters

md	what to free

Definition at line 248 of file container_meta_data.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_free_non_null, GNUNET_CONTAINER_MetaData::items_head, GNUNET_CONTAINER_MetaData::items_tail, meta_item_free(), and GNUNET_CONTAINER_MetaData::sbuf.

Referenced by deserialize_search_result(), do_stop_task(), extract_files(), free_download_context(), free_result(), free_update_information_graph(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_builder_finish(), GNUNET_FS_directory_list_contents(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), GNUNET_FS_file_information_destroy(), GNUNET_FS_probe_stop(), GNUNET_FS_publish_ksk_cancel(), GNUNET_FS_publish_sks_cancel(), GNUNET_FS_share_tree_free(), process_kblock(), process_sblock(), publish_inspector(), read_update_information_graph(), search_result_free(), and search_result_suspend().

{
  struct MetaItem *pos;

  if (NULL == md)
    return;
  while (NULL != (pos = md->items_head))
    {
      GNUNET_CONTAINER_DLL_remove(md->items_head, md->items_tail, pos);
      meta_item_free(pos);
    }
  GNUNET_free_non_null(md->sbuf);
  GNUNET_free(md);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_test_equal()

int GNUNET_CONTAINER_meta_data_test_equal	(	const struct GNUNET_CONTAINER_MetaData *	md1,
		const struct GNUNET_CONTAINER_MetaData *	md2
	)

Test if two MDs are equal.

We consider them equal if the meta types, formats and content match (we do not include the mime types and plugins names in this consideration).

Parameters

md1	first value to check
md2	other value to check

Returns

GNUNET_YES if they are equal

Definition at line 297 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, MetaItem::format, GNUNET_NO, GNUNET_YES, GNUNET_CONTAINER_MetaData::item_count, GNUNET_CONTAINER_MetaData::items_head, MetaItem::next, and MetaItem::type.

{
  struct MetaItem *i;
  struct MetaItem *j;
  int found;

  if (md1 == md2)
    return GNUNET_YES;
  if (md1->item_count != md2->item_count)
    return GNUNET_NO;
  for (i = md1->items_head; NULL != i; i = i->next)
    {
      found = GNUNET_NO;
      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) &&
              (0 == memcmp(i->data, j->data, i->data_size)))
            {
              found = GNUNET_YES;
              break;
            }
          if (j->data_size < i->data_size)
            break; /* elements are sorted by (decreasing) size... */
        }
      if (GNUNET_NO == found)
        return GNUNET_NO;
    }
  return GNUNET_YES;
}

GNUNET_CONTAINER_meta_data_insert()

int GNUNET_CONTAINER_meta_data_insert	(	struct GNUNET_CONTAINER_MetaData *	md,
		const char *	plugin_name,
		enum EXTRACTOR_MetaType	type,
		enum EXTRACTOR_MetaFormat	format,
		const char *	data_mime_type,
		const char *	data,
		size_t	data_size
	)

Extend metadata.

Parameters

md	metadata to extend
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 meta data).
type	libextractor-type describing the meta data
format	basic format information about data
data_mime_type	mime-type of data (not of the original file); can be NULL (if mime-type is not known)
data	actual meta-data found
data_size	number of bytes in data

Returns

GNUNET_OK on success, GNUNET_SYSERR if this entry already exists data_mime_type and plugin_name are not considered for "exists" checks

Note that the list of meta data items is sorted by size (largest first).

Parameters

md	metadata to extend
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 meta data).
type	libextractor-type describing the meta data
format	basic format information about data
data_mime_type	mime-type of data (not of the original file); can be NULL (if mime-type is not known)
data	actual meta-data found
data_size	number of bytes in data

Returns

GNUNET_OK on success, GNUNET_SYSERR if this entry already exists data_mime_type and plugin_name are not considered for "exists" checks

Definition at line 351 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_FILENAME, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, MetaItem::format, GNUNET_break, GNUNET_CONTAINER_DLL_insert_after, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, invalidate_sbuf(), GNUNET_CONTAINER_MetaData::item_count, GNUNET_CONTAINER_MetaData::items_head, GNUNET_CONTAINER_MetaData::items_tail, MetaItem::mime_type, MetaItem::next, p, MetaItem::plugin_name, MetaItem::prev, and MetaItem::type.

Referenced by getopt_set_metadata(), GNUNET_CONTAINER_meta_data_add_publication_date(), GNUNET_CONTAINER_meta_data_deserialize(), GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_FS_directory_builder_add(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_meta_data_make_directory(), merge_helper(), migrate_and_drop_metadata(), process_helper_msgs(), and share_tree_trim().

{
  struct MetaItem *pos;
  struct MetaItem *mi;
  char *p;

  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_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 ((NULL == pos->mime_type) && (NULL != data_mime_type))
            {
              pos->mime_type = GNUNET_strdup(data_mime_type);
              invalidate_sbuf(md);
            }
          if ((EXTRACTOR_METAFORMAT_C_STRING == pos->format) &&
              (EXTRACTOR_METAFORMAT_UTF8 == format))
            {
              pos->format = EXTRACTOR_METAFORMAT_UTF8;
              invalidate_sbuf(md);
            }
          return GNUNET_SYSERR;
        }
    }
  md->item_count++;
  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
    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 = mi->data;
      while (('\0' != *p) && (p < mi->data + data_size))
        {
          if ('\\' == *p)
            *p = '/';
          p++;
        }
    }
  invalidate_sbuf(md);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_merge()

void GNUNET_CONTAINER_meta_data_merge	(	struct GNUNET_CONTAINER_MetaData *	md,
		const struct GNUNET_CONTAINER_MetaData *	in
	)

Extend metadata.

Merges the meta data from the second argument into the first, discarding duplicate key-value pairs.

Parameters

md	metadata to extend
in	metadata to merge

Definition at line 460 of file container_meta_data.c.

References GNUNET_CONTAINER_meta_data_iterate(), and merge_helper().

Referenced by process_ksk_result(), and publish_inspector().

{
  GNUNET_CONTAINER_meta_data_iterate(in, &merge_helper, md);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_delete()

int GNUNET_CONTAINER_meta_data_delete	(	struct GNUNET_CONTAINER_MetaData *	md,
		enum EXTRACTOR_MetaType	type,
		const char *	data,
		size_t	data_size
	)

Remove an item.

Parameters

md	metadata to manipulate
type	type of the item to remove
data	specific value to remove, NULL to remove all entries of the given type
data_size	number of bytes in data

Returns

GNUNET_OK on success, GNUNET_SYSERR if the item does not exist in md

Parameters

md	metadata to manipulate
type	type of the item to remove
data	specific value to remove, NULL to remove all entries of the given type
data_size	number of bytes in data

Returns

GNUNET_OK on success, GNUNET_SYSERR if the item does not exist in md

Definition at line 478 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, GNUNET_CONTAINER_DLL_remove, GNUNET_OK, GNUNET_SYSERR, invalidate_sbuf(), GNUNET_CONTAINER_MetaData::item_count, GNUNET_CONTAINER_MetaData::items_head, GNUNET_CONTAINER_MetaData::items_tail, meta_item_free(), MetaItem::next, and MetaItem::type.

Referenced by get_file_information(), GNUNET_CONTAINER_meta_data_add_publication_date(), and process_helper_msgs().

{
  struct MetaItem *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) &&
          ((NULL == data) ||
           ((pos->data_size == data_size) &&
            (0 == memcmp(pos->data, data, data_size)))))
        {
          GNUNET_CONTAINER_DLL_remove(md->items_head, md->items_tail, pos);
          meta_item_free(pos);
          md->item_count--;
          invalidate_sbuf(md);
          return GNUNET_OK;
        }
    }
  return GNUNET_SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_clear()

void GNUNET_CONTAINER_meta_data_clear

(

struct GNUNET_CONTAINER_MetaData *

md

)

Remove all items in the container.

Parameters

md	metadata to manipulate

Definition at line 270 of file container_meta_data.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free_non_null, GNUNET_CONTAINER_MetaData::items_head, GNUNET_CONTAINER_MetaData::items_tail, meta_item_free(), and GNUNET_CONTAINER_MetaData::sbuf.

{
  struct MetaItem *mi;

  if (NULL == md)
    return;
  while (NULL != (mi = md->items_head))
    {
      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));
}

Here is the call graph for this function:

GNUNET_CONTAINER_meta_data_add_publication_date()

void GNUNET_CONTAINER_meta_data_add_publication_date

(

struct GNUNET_CONTAINER_MetaData *

md

)

Add the current time as the publication date to the meta-data.

Parameters

md	metadata to modify

Definition at line 511 of file container_meta_data.c.

References EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_PUBLICATION_DATE, GNUNET_CONTAINER_meta_data_delete(), GNUNET_CONTAINER_meta_data_insert(), GNUNET_STRINGS_absolute_time_to_string(), and GNUNET_TIME_absolute_get().

Referenced by publish_inspector().

{
  const char *dat;
  struct GNUNET_TIME_Absolute t;

  t = GNUNET_TIME_absolute_get();
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_iterate()

int GNUNET_CONTAINER_meta_data_iterate	(	const struct GNUNET_CONTAINER_MetaData *	md,
		EXTRACTOR_MetaDataProcessor	iter,
		void *	iter_cls
	)

Iterate over MD entries.

Parameters

md	metadata to inspect
iter	function to call on each entry, return 0 to continue to iterate and 1 to abort iteration in this function (GNU libextractor API!)
iter_cls	closure for iter

Returns

number of entries

Parameters

md	metadata to inspect
iter	function to call on each entry
iter_cls	closure for iterator

Returns

number of entries

Definition at line 538 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, MetaItem::format, GNUNET_CONTAINER_MetaData::item_count, GNUNET_CONTAINER_MetaData::items_head, MetaItem::mime_type, MetaItem::next, MetaItem::plugin_name, and MetaItem::type.

Referenced by GNUNET_CONTAINER_meta_data_merge(), GNUNET_FS_directory_list_contents(), GNUNET_FS_download_start_task_(), GNUNET_FS_uri_ksk_create_from_meta_data(), print_entry(), progress_cb(), publish_inspector(), and share_tree_trim().

{
  struct MetaItem *pos;

  if (NULL == md)
    return 0;
  if (NULL == iter)
    return md->item_count;
  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;
  return md->item_count;
}

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_get_by_type()

char* GNUNET_CONTAINER_meta_data_get_by_type	(	const struct GNUNET_CONTAINER_MetaData *	md,
		enum EXTRACTOR_MetaType	type
	)

Get the first MD entry of the given type.

Caller is responsible for freeing the return value. Also, only meta data items that are strings (0-terminated) are returned by this function.

Parameters

md	metadata to inspect
type	type to look for

Returns

NULL if no entry was found

Definition at line 568 of file container_meta_data.c.

References MetaItem::data, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, MetaItem::format, GNUNET_strdup, GNUNET_CONTAINER_MetaData::items_head, MetaItem::next, and MetaItem::type.

Referenced by GNUNET_CONTAINER_meta_data_get_first_by_types(), GNUNET_FS_directory_list_contents(), GNUNET_FS_meta_data_make_directory(), GNUNET_FS_meta_data_suggest_filename(), GNUNET_FS_meta_data_test_for_directory(), GNUNET_FS_publish_main_(), print_entry(), progress_cb(), and publish_inspector().

{
  struct MetaItem *pos;

  if (NULL == md)
    return NULL;
  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);
  return NULL;
}

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_get_first_by_types()

char* GNUNET_CONTAINER_meta_data_get_first_by_types	(	const struct GNUNET_CONTAINER_MetaData *	md,
			...
	)

Get the first matching MD entry of the given types.

Caller is responsible for freeing the return value. Also, only meta data items that are strings (0-terminated) are returned by this function.

Parameters

md	metadata to inspect
...	-1-terminated list of types

Returns

NULL if we do not have any such entry, otherwise client is responsible for freeing the value!

Definition at line 596 of file container_meta_data.c.

References gnunet-chk::args, GNUNET_CONTAINER_meta_data_get_by_type(), ret, and MetaItem::type.

Referenced by GNUNET_FS_meta_data_suggest_filename(), and GNUNET_FS_uri_ksk_create_from_meta_data().

{
  char *ret;
  va_list args;
  int type;

  if (NULL == md)
    return NULL;
  ret = NULL;
  va_start(args, md);
  while (1)
    {
      type = va_arg(args, int);
      if (-1 == type)
        break;
      if (NULL != (ret = GNUNET_CONTAINER_meta_data_get_by_type(md, type)))
        break;
    }
  va_end(args);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_get_thumbnail()

size_t GNUNET_CONTAINER_meta_data_get_thumbnail	(	const struct GNUNET_CONTAINER_MetaData *	md,
		unsigned char **	thumb
	)

Get a thumbnail from the meta-data (if present).

Only matches meta data with mime type "image" and binary format.

Parameters

md	metadata to inspect
thumb	will be set to the thumbnail data. Must be freed by the caller!

Returns

number of bytes in thumbnail, 0 if not available

Parameters

md	metadata to get the thumbnail from
thumb	will be set to the thumbnail data. Must be freed by the caller!

Returns

number of bytes in thumbnail, 0 if not available

Definition at line 630 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, EXTRACTOR_METAFORMAT_BINARY, EXTRACTOR_METATYPE_THUMBNAIL, MetaItem::format, GNUNET_malloc, GNUNET_memcpy, GNUNET_CONTAINER_MetaData::items_head, MetaItem::mime_type, MetaItem::next, and MetaItem::type.

{
  struct MetaItem *pos;
  struct MetaItem *match;

  if (NULL == md)
    return 0;
  match = NULL;
  for (pos = md->items_head; NULL != pos; pos = pos->next)
    {
      if ((NULL != pos->mime_type) &&
          (0 == strncasecmp("image/", pos->mime_type, strlen("image/"))) &&
          (EXTRACTOR_METAFORMAT_BINARY == pos->format))
        {
          if (NULL == match)
            match = pos;
          else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
                   (pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
            match = pos;
        }
    }
  if ((NULL == match) || (0 == match->data_size))
    return 0;
  *thumb = GNUNET_malloc(match->data_size);
  GNUNET_memcpy(*thumb, match->data, match->data_size);
  return match->data_size;
}

GNUNET_CONTAINER_meta_data_serialize()

ssize_t GNUNET_CONTAINER_meta_data_serialize	(	const struct GNUNET_CONTAINER_MetaData *	md,
		char **	target,
		size_t	max,
		enum GNUNET_CONTAINER_MetaDataSerializationOptions	opt
	)

Serialize meta-data to target.

Parameters

md	metadata to serialize
target	where to write the serialized metadata; *target can be NULL, in which case memory is allocated
max	maximum number of bytes available
opt	is it ok to just write SOME of the meta-data to match the size constraint, possibly discarding some data?

Returns

number of bytes written on success, -1 on error (typically: not enough space)

Parameters

md	metadata to serialize
target	where to write the serialized metadata; *target can be NULL, in which case memory is allocated
max	maximum number of bytes available in target
opt	is it ok to just write SOME of the meta-data to match the size constraint, possibly discarding some data?

Returns

number of bytes written on success, GNUNET_SYSERR on error (typically: not enough space)

Definition at line 775 of file container_meta_data.c.

References MetaItem::data, MetaItem::data_size, MetaDataEntry::data_size, MetaDataHeader::entries, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, MetaItem::format, MetaDataEntry::format, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS, GNUNET_CONTAINER_META_DATA_SERIALIZE_PART, GNUNET_free, GNUNET_free_non_null, GNUNET_malloc, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_SYSERR, GNUNET_try_compression(), GNUNET_YES, HEADER_COMPRESSED, GNUNET_CONTAINER_MetaData::item_count, GNUNET_CONTAINER_MetaData::items_head, GNUNET_CONTAINER_MetaData::items_tail, MetaItem::mime_type, MetaDataEntry::mime_type_len, MetaItem::next, MetaItem::plugin_name, MetaDataEntry::plugin_name_len, MetaItem::prev, GNUNET_CONTAINER_MetaData::sbuf, GNUNET_CONTAINER_MetaData::sbuf_size, size, MetaDataHeader::size, MetaItem::type, MetaDataEntry::type, and MetaDataHeader::version.

Referenced by extract_files(), GNUNET_BIO_write_meta_data(), GNUNET_CONTAINER_meta_data_get_serialized_size(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_builder_finish(), and GNUNET_FS_publish_ublock_().

{
  struct GNUNET_CONTAINER_MetaData *vmd;
  struct MetaItem *pos;
  struct MetaDataHeader ihdr;
  struct MetaDataHeader *hdr;
  struct MetaDataEntry *ent;
  char *dst;
  unsigned int i;
  uint64_t msize;
  size_t off;
  char *mdata;
  char *cdata;
  size_t mlen;
  size_t plen;
  size_t size;
  size_t left;
  size_t clen;
  size_t rlen;
  int comp;

  if (max < sizeof(struct MetaDataHeader))
    return GNUNET_SYSERR;       /* far too small */
  if (NULL == md)
    return 0;

  if (NULL != md->sbuf)
    {
      /* try to use serialization cache */
      if (md->sbuf_size <= max)
        {
          if (NULL == *target)
            *target = GNUNET_malloc(md->sbuf_size);
          GNUNET_memcpy(*target, md->sbuf, md->sbuf_size);
          return md->sbuf_size;
        }
      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
        return GNUNET_SYSERR;   /* can say that this will fail */
      /* need to compute a partial serialization, sbuf useless ... */
    }
  dst = NULL;
  msize = 0;
  for (pos = md->items_tail; NULL != pos; pos = pos->prev)
    {
      msize += sizeof(struct MetaDataEntry);
      msize += pos->data_size;
      if (NULL != pos->plugin_name)
        msize += strlen(pos->plugin_name) + 1;
      if (NULL != pos->mime_type)
        msize += strlen(pos->mime_type) + 1;
    }
  size = (size_t)msize;
  if (size != msize)
    {
      GNUNET_break(0);          /* integer overflow */
      return GNUNET_SYSERR;
    }
  if (size >= GNUNET_MAX_MALLOC_CHECKED)
    {
      /* too large to be processed */
      return GNUNET_SYSERR;
    }
  ent = GNUNET_malloc(size);
  mdata = (char *)&ent[md->item_count];
  off = size - (md->item_count * sizeof(struct MetaDataEntry));
  i = 0;
  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 (NULL == pos->plugin_name)
        plen = 0;
      else
        plen = strlen(pos->plugin_name) + 1;
      ent[i].plugin_name_len = htonl((uint32_t)plen);
      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;
      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 (NULL != pos->plugin_name)
        GNUNET_memcpy(&mdata[off], pos->plugin_name, plen);
      off -= mlen;
      if (NULL != pos->mime_type)
        GNUNET_memcpy(&mdata[off], pos->mime_type, mlen);
      i++;
    }
  GNUNET_assert(0 == off);

  clen = 0;
  cdata = NULL;
  left = size;
  i = 0;
  for (pos = md->items_head; NULL != pos; pos = pos->next)
    {
      comp = GNUNET_NO;
      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS))
        comp = GNUNET_try_compression((const char *)&ent[i],
                                      left,
                                      &cdata,
                                      &clen);

      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
           * of making the API look strange. */
          vmd = (struct GNUNET_CONTAINER_MetaData *)md;
          hdr = GNUNET_malloc(left + sizeof(struct MetaDataHeader));
          hdr->size = htonl(left);
          hdr->entries = htonl(md->item_count);
          if (GNUNET_YES == comp)
            {
              GNUNET_assert(clen < left);
              hdr->version = htonl(2 | HEADER_COMPRESSED);
              GNUNET_memcpy(&hdr[1], cdata, clen);
              vmd->sbuf_size = clen + sizeof(struct MetaDataHeader);
            }
          else
            {
              hdr->version = htonl(2);
              GNUNET_memcpy(&hdr[1], &ent[0], left);
              vmd->sbuf_size = left + sizeof(struct MetaDataHeader);
            }
          vmd->sbuf = (char *)hdr;
        }

      if (((left + sizeof(struct MetaDataHeader)) <= max) ||
          ((GNUNET_YES == comp) && (clen <= max)))
        {
          /* success, this now fits! */
          if (GNUNET_YES == comp)
            {
              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);
              GNUNET_memcpy(&dst[sizeof(struct MetaDataHeader)], cdata, clen);
              GNUNET_free(cdata);
              cdata = NULL;
              GNUNET_free(ent);
              rlen = clen + sizeof(struct MetaDataHeader);
            }
          else
            {
              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);
              GNUNET_memcpy(&dst[sizeof(struct MetaDataHeader)], &ent[i], left);
              GNUNET_free(ent);
              rlen = left + sizeof(struct MetaDataHeader);
            }
          if (NULL != *target)
            {
              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
            {
              *target = dst;
            }
          return rlen;
        }

      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
        {
          /* does not fit! */
          GNUNET_free(ent);
          return GNUNET_SYSERR;
        }

      /* next iteration: ignore the corresponding meta data at the
       * end and try again without it */
      left -= sizeof(struct MetaDataEntry);
      left -= pos->data_size;
      if (NULL != pos->plugin_name)
        left -= strlen(pos->plugin_name) + 1;
      if (NULL != pos->mime_type)
        left -= strlen(pos->mime_type) + 1;

      GNUNET_free_non_null(cdata);
      cdata = NULL;

      i++;
    }
  GNUNET_free(ent);

  /* nothing fit, only write header! */
  ihdr.version = htonl(2);
  ihdr.entries = htonl(0);
  ihdr.size = htonl(0);
  if (NULL == *target)
    *target = (char *)GNUNET_new(struct MetaDataHeader);
  GNUNET_memcpy(*target, &ihdr, sizeof(struct MetaDataHeader));
  return sizeof(struct MetaDataHeader);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_get_serialized_size()

ssize_t GNUNET_CONTAINER_meta_data_get_serialized_size

(

const struct GNUNET_CONTAINER_MetaData *

md

)

Get the size of the full meta-data in serialized form.

Parameters

md	metadata to inspect

Returns

number of bytes needed for serialization, -1 on error

Definition at line 999 of file container_meta_data.c.

References GNUNET_CONTAINER_meta_data_serialize(), GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL, GNUNET_free, GNUNET_MAX_MALLOC_CHECKED, ret, GNUNET_CONTAINER_MetaData::sbuf, and GNUNET_CONTAINER_MetaData::sbuf_size.

Referenced by extract_files(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_builder_finish(), GNUNET_FS_download_start_task_(), GNUNET_FS_publish_ublock_(), and trigger_recursive_download().

{
  ssize_t ret;
  char *ptr;

  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 (-1 != ret)
    GNUNET_free(ptr);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CONTAINER_meta_data_deserialize()

struct GNUNET_CONTAINER_MetaData* GNUNET_CONTAINER_meta_data_deserialize	(	const char *	input,
		size_t	size
	)

Deserialize meta-data.

Initializes md.

Parameters

input	serialized meta-data.
size	number of bytes available

Returns

MD on success, NULL on error (i.e. bad format)

Initializes md.

Parameters

input	buffer with the serialized metadata
size	number of bytes available in input

Returns

MD on success, NULL on error (i.e. bad format)

Definition at line 1026 of file container_meta_data.c.

References MetaItem::data, MetaDataEntry::data_size, MetaDataHeader::entries, EXTRACTOR_METAFORMAT_BINARY, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, MetaItem::format, MetaDataEntry::format, GNUNET_break_op, GNUNET_CONTAINER_meta_data_create(), GNUNET_CONTAINER_meta_data_insert(), GNUNET_decompress(), GNUNET_free_non_null, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, HEADER_COMPRESSED, HEADER_VERSION_MASK, MetaItem::mime_type, MetaDataEntry::mime_type_len, MetaItem::plugin_name, MetaDataEntry::plugin_name_len, MetaDataHeader::size, MetaDataEntry::type, and MetaDataHeader::version.

Referenced by GNUNET_BIO_read_meta_data(), GNUNET_FS_directory_list_contents(), process_helper_msgs(), process_kblock(), and process_sblock().

{
  struct GNUNET_CONTAINER_MetaData *md;
  struct MetaDataHeader hdr;
  struct MetaDataEntry ent;
  uint32_t ic;
  uint32_t i;
  char *data;
  const char *cdata;
  uint32_t version;
  uint32_t dataSize;
  int compressed;
  size_t left;
  uint32_t mlen;
  uint32_t plen;
  uint32_t dlen;
  const char *mdata;
  const char *meta_data;
  const char *plugin_name;
  const char *mime_type;
  enum EXTRACTOR_MetaFormat format;

  if (size < sizeof(struct MetaDataHeader))
    return NULL;
  GNUNET_memcpy(&hdr, input, sizeof(struct MetaDataHeader));
  version = ntohl(hdr.version) & HEADER_VERSION_MASK;
  compressed = (ntohl(hdr.version) & HEADER_COMPRESSED) != 0;

  if (1 == version)
    return NULL;                /* null pointer */
  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) ||
      ((0 != ic) &&
       (dataSize / ic < sizeof(struct MetaDataEntry))))
    {
      GNUNET_break_op(0);
      return NULL;
    }

  if (compressed)
    {
      if (dataSize >= GNUNET_MAX_MALLOC_CHECKED)
        {
          /* make sure we don't blow our memory limit because of a mal-formed
           * message... */
          GNUNET_break_op(0);
          return NULL;
        }
      data =
        GNUNET_decompress((const char *)&input[sizeof(struct MetaDataHeader)],
                          size - sizeof(struct MetaDataHeader),
                          dataSize);
      if (NULL == data)
        {
          GNUNET_break_op(0);
          return NULL;
        }
      cdata = data;
    }
  else
    {
      data = NULL;
      cdata = (const char *)&input[sizeof(struct MetaDataHeader)];
      if (dataSize != size - sizeof(struct MetaDataHeader))
        {
          GNUNET_break_op(0);
          return NULL;
        }
    }

  md = GNUNET_CONTAINER_meta_data_create();
  left = dataSize - ic * sizeof(struct MetaDataEntry);
  mdata = &cdata[ic * sizeof(struct MetaDataEntry)];
  for (i = 0; i < ic; i++)
    {
      GNUNET_memcpy(&ent, &cdata[i * sizeof(struct MetaDataEntry)],
                    sizeof(struct MetaDataEntry));
      format = (enum EXTRACTOR_MetaFormat)ntohl(ent.format);
      if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
          (EXTRACTOR_METAFORMAT_C_STRING != format) &&
          (EXTRACTOR_METAFORMAT_BINARY != format))
        {
          GNUNET_break_op(0);
          break;
        }
      dlen = ntohl(ent.data_size);
      plen = ntohl(ent.plugin_name_len);
      mlen = ntohl(ent.mime_type_len);
      if (dlen > left)
        {
          GNUNET_break_op(0);
          break;
        }
      left -= dlen;
      meta_data = &mdata[left];
      if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
          (EXTRACTOR_METAFORMAT_C_STRING == format))
        {
          if (0 == dlen)
            {
              GNUNET_break_op(0);
              break;
            }
          if ('\0' != meta_data[dlen - 1])
            {
              GNUNET_break_op(0);
              break;
            }
        }
      if (plen > left)
        {
          GNUNET_break_op(0);
          break;
        }
      left -= plen;
      if ((plen > 0) && ('\0' != mdata[left + plen - 1]))
        {
          GNUNET_break_op(0);
          break;
        }
      if (0 == plen)
        plugin_name = NULL;
      else
        plugin_name = &mdata[left];

      if (mlen > left)
        {
          GNUNET_break_op(0);
          break;
        }
      left -= mlen;
      if ((mlen > 0) && ('\0' != mdata[left + mlen - 1]))
        {
          GNUNET_break_op(0);
          break;
        }
      if (0 == mlen)
        mime_type = NULL;
      else
        mime_type = &mdata[left];
      GNUNET_CONTAINER_meta_data_insert(md, plugin_name,
                                        (enum EXTRACTOR_MetaType)
                                        ntohl(ent.type), format, mime_type,
                                        meta_data, dlen);
    }
  GNUNET_free_non_null(data);
  return md;
}

Here is the call graph for this function:

Here is the caller graph for this function: