Metadata

Meta data processingGNU libextractor key-value pairs. More...

Collaboration diagram for Metadata:

Enumerations
enum	GNUNET_FS_MetaDataSerializationOptions { GNUNET_FS_META_DATA_SERIALIZE_FULL = 0 , GNUNET_FS_META_DATA_SERIALIZE_PART = 1 , GNUNET_FS_META_DATA_SERIALIZE_NO_COMPRESS = 2 }
	Options for metadata serialization. More...

Functions
struct GNUNET_FS_MetaData *	GNUNET_FS_meta_data_create (void)
	Create a fresh meta data container. More...
struct GNUNET_FS_MetaData *	GNUNET_FS_meta_data_duplicate (const struct GNUNET_FS_MetaData *md)
	Duplicate a MetaData token. More...
void	GNUNET_FS_meta_data_destroy (struct GNUNET_FS_MetaData *md)
	Free meta data. More...
int	GNUNET_FS_meta_data_test_equal (const struct GNUNET_FS_MetaData *md1, const struct GNUNET_FS_MetaData *md2)
	Test if two MDs are equal. More...
int	GNUNET_FS_meta_data_insert (struct GNUNET_FS_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_FS_meta_data_merge (struct GNUNET_FS_MetaData *md, const struct GNUNET_FS_MetaData *in)
	Extend metadata. More...
int	GNUNET_FS_meta_data_delete (struct GNUNET_FS_MetaData *md, enum EXTRACTOR_MetaType type, const char *data, size_t data_size)
	Remove an item. More...
void	GNUNET_FS_meta_data_clear (struct GNUNET_FS_MetaData *md)
	Remove all items in the container. More...
void	GNUNET_FS_meta_data_add_publication_date (struct GNUNET_FS_MetaData *md)
	Add the current time as the publication date to the meta-data. More...
int	GNUNET_FS_meta_data_iterate (const struct GNUNET_FS_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
	Iterate over MD entries. More...
char *	GNUNET_FS_meta_data_get_by_type (const struct GNUNET_FS_MetaData *md, enum EXTRACTOR_MetaType type)
	Get the first MD entry of the given type. More...
char *	GNUNET_FS_meta_data_get_first_by_types (const struct GNUNET_FS_MetaData *md,...)
	Get the first matching MD entry of the given types. More...
size_t	GNUNET_FS_meta_data_get_thumbnail (const struct GNUNET_FS_MetaData *md, unsigned char **thumb)
	Get a thumbnail from the meta-data (if present). More...
ssize_t	GNUNET_FS_meta_data_serialize (const struct GNUNET_FS_MetaData *md, char **target, size_t max, enum GNUNET_FS_MetaDataSerializationOptions opt)
	Serialize meta-data to target. More...
ssize_t	GNUNET_FS_meta_data_get_serialized_size (const struct GNUNET_FS_MetaData *md)
	Get the size of the full meta-data in serialized form. More...
struct GNUNET_FS_MetaData *	GNUNET_FS_meta_data_deserialize (const char *input, size_t size)
	Deserialize meta-data. More...

Detailed Description

Meta data processing

GNU libextractor key-value pairs.

Enumeration Type Documentation

GNUNET_FS_MetaDataSerializationOptions

enum GNUNET_FS_MetaDataSerializationOptions

Options for metadata serialization.

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

Definition at line 3113 of file gnunet_fs_service.h.

{
  GNUNET_FS_META_DATA_SERIALIZE_FULL = 0,
 
  GNUNET_FS_META_DATA_SERIALIZE_PART = 1,
 
  GNUNET_FS_META_DATA_SERIALIZE_NO_COMPRESS = 2
};

Function Documentation

GNUNET_FS_meta_data_create()

struct GNUNET_FS_MetaData * GNUNET_FS_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 127 of file meta_data.c.

{
  return GNUNET_new (struct GNUNET_FS_MetaData);
}

References GNUNET_new.

Referenced by extract_files(), get_file_information(), getopt_set_metadata(), GNUNET_FS_directory_builder_create(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_meta_data_deserialize(), GNUNET_FS_meta_data_duplicate(), migrate_and_drop_metadata(), process_kblock(), and share_tree_trim().

Here is the caller graph for this function:

GNUNET_FS_meta_data_duplicate()

struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_duplicate

(

const struct GNUNET_FS_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 527 of file meta_data.c.

{
  struct GNUNET_FS_MetaData *ret;
  struct MetaItem *pos;
 
  if (NULL == md)
    return NULL;
  ret = GNUNET_FS_meta_data_create ();
  for (pos = md->items_tail; NULL != pos; pos = pos->prev)
    GNUNET_FS_meta_data_insert (ret, pos->plugin_name, pos->type,
                                pos->format, pos->mime_type, pos->data,
                                pos->data_size);
  return ret;
}

References MetaItem::data, MetaItem::data_size, MetaItem::format, GNUNET_FS_meta_data_create(), GNUNET_FS_meta_data_insert(), GNUNET_FS_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().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_destroy()

void GNUNET_FS_meta_data_destroy

(

struct GNUNET_FS_MetaData *

md

)

Free meta data.

Parameters

md	what to free

Definition at line 166 of file meta_data.c.

{
  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 (md->sbuf);
  GNUNET_free (md);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_FS_MetaData::items_head, GNUNET_FS_MetaData::items_tail, meta_item_free(), and GNUNET_FS_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().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_test_equal()

int GNUNET_FS_meta_data_test_equal	(	const struct GNUNET_FS_MetaData *	md1,
		const struct GNUNET_FS_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 200 of file meta_data.c.

{
  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;
}

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

GNUNET_FS_meta_data_insert()

int GNUNET_FS_meta_data_insert	(	struct GNUNET_FS_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 (e.g. '<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 (e.g. '<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 254 of file meta_data.c.

{
  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;
}

References data, MetaItem::data, data_size, 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_FS_MetaData::item_count, GNUNET_FS_MetaData::items_head, GNUNET_FS_MetaData::items_tail, MetaItem::mime_type, MetaItem::next, p, plugin_name, MetaItem::plugin_name, MetaItem::prev, type, and MetaItem::type.

Referenced by getopt_set_metadata(), GNUNET_FS_directory_builder_add(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_meta_data_add_publication_date(), GNUNET_FS_meta_data_deserialize(), GNUNET_FS_meta_data_duplicate(), GNUNET_FS_meta_data_make_directory(), merge_helper(), migrate_and_drop_metadata(), process_helper_msgs(), and share_tree_trim().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_merge()

void GNUNET_FS_meta_data_merge	(	struct GNUNET_FS_MetaData *	md,
		const struct GNUNET_FS_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 356 of file meta_data.c.

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

References GNUNET_FS_meta_data_iterate(), and merge_helper().

Referenced by process_ksk_result(), and publish_inspector().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_delete()

int GNUNET_FS_meta_data_delete	(	struct GNUNET_FS_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

Definition at line 364 of file meta_data.c.

{
  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;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_clear()

void GNUNET_FS_meta_data_clear

(

struct GNUNET_FS_MetaData *

md

)

Remove all items in the container.

Parameters

md	metadata to manipulate

Definition at line 183 of file meta_data.c.

{
  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 (md->sbuf);
  memset (md, 0, sizeof(struct GNUNET_FS_MetaData));
}

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

Here is the call graph for this function:

GNUNET_FS_meta_data_add_publication_date()

void GNUNET_FS_meta_data_add_publication_date

(

struct GNUNET_FS_MetaData *

md

)

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

Parameters

md	metadata to modify

Definition at line 391 of file meta_data.c.

{
  const char *dat;
  struct GNUNET_TIME_Absolute t;
 
  t = GNUNET_TIME_absolute_get ();
  GNUNET_FS_meta_data_delete (md,
                              EXTRACTOR_METATYPE_PUBLICATION_DATE,
                              NULL, 0);
  dat = GNUNET_STRINGS_absolute_time_to_string (t);
  GNUNET_FS_meta_data_insert (md, "<gnunet>",
                              EXTRACTOR_METATYPE_PUBLICATION_DATE,
                              EXTRACTOR_METAFORMAT_UTF8, "text/plain",
                              dat, strlen (dat) + 1);
}

References EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_PUBLICATION_DATE, GNUNET_FS_meta_data_delete(), GNUNET_FS_meta_data_insert(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), and t.

Referenced by publish_inspector().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_iterate()

int GNUNET_FS_meta_data_iterate	(	const struct GNUNET_FS_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 418 of file meta_data.c.

{
  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;
}

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

Referenced by GNUNET_FS_directory_list_contents(), GNUNET_FS_download_start_task_(), GNUNET_FS_meta_data_merge(), GNUNET_FS_uri_ksk_create_from_meta_data(), print_entry(), print_search_result(), publish_inspector(), and share_tree_trim().

Here is the caller graph for this function:

GNUNET_FS_meta_data_get_by_type()

char * GNUNET_FS_meta_data_get_by_type	(	const struct GNUNET_FS_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 438 of file meta_data.c.

{
  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;
}

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

Referenced by GNUNET_FS_directory_list_contents(), GNUNET_FS_meta_data_get_first_by_types(), 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(), print_search_result(), progress_cb(), and publish_inspector().

Here is the caller graph for this function:

GNUNET_FS_meta_data_get_first_by_types()

char * GNUNET_FS_meta_data_get_first_by_types	(	const struct GNUNET_FS_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 456 of file meta_data.c.

{
  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_FS_meta_data_get_by_type (md, type)))
      break;
  }
  va_end (args);
  return ret;
}

References warningfilter::args, GNUNET_FS_meta_data_get_by_type(), ret, and type.

Referenced by GNUNET_FS_meta_data_suggest_filename(), and GNUNET_FS_uri_ksk_create_from_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_get_thumbnail()

size_t GNUNET_FS_meta_data_get_thumbnail	(	const struct GNUNET_FS_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 490 of file meta_data.c.

{
  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;
}

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

GNUNET_FS_meta_data_serialize()

ssize_t GNUNET_FS_meta_data_serialize	(	const struct GNUNET_FS_MetaData *	md,
		char **	target,
		size_t	max,
		enum GNUNET_FS_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 637 of file meta_data.c.

{
  struct GNUNET_FS_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_FS_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_FS_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_FS_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_FS_META_DATA_SERIALIZE_PART))
    {
      /* does not fit! */
      GNUNET_free (ent);
      if (NULL != cdata)
        GNUNET_free (cdata);
      cdata = NULL;
      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;
 
    if (NULL != cdata)
      GNUNET_free (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);
}

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_free, GNUNET_FS_META_DATA_SERIALIZE_NO_COMPRESS, GNUNET_FS_META_DATA_SERIALIZE_PART, GNUNET_malloc, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_SYSERR, GNUNET_try_compression(), GNUNET_YES, HEADER_COMPRESSED, GNUNET_FS_MetaData::item_count, GNUNET_FS_MetaData::items_head, GNUNET_FS_MetaData::items_tail, max, MetaItem::mime_type, MetaDataEntry::mime_type_len, MetaItem::next, MetaItem::plugin_name, MetaDataEntry::plugin_name_len, MetaItem::prev, GNUNET_FS_MetaData::sbuf, GNUNET_FS_MetaData::sbuf_size, size, MetaDataHeader::size, MetaItem::type, MetaDataEntry::type, and MetaDataHeader::version.

Referenced by extract_files(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_builder_finish(), GNUNET_FS_meta_data_get_serialized_size(), GNUNET_FS_publish_ublock_(), and GNUNET_FS_write_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_get_serialized_size()

ssize_t GNUNET_FS_meta_data_get_serialized_size

(

const struct GNUNET_FS_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 858 of file meta_data.c.

{
  ssize_t ret;
  char *ptr;
 
  if (NULL != md->sbuf)
    return md->sbuf_size;
  ptr = NULL;
  ret =
    GNUNET_FS_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
                                   GNUNET_FS_META_DATA_SERIALIZE_FULL);
  if (-1 != ret)
    GNUNET_free (ptr);
  return ret;
}

References GNUNET_free, GNUNET_FS_meta_data_serialize(), GNUNET_FS_META_DATA_SERIALIZE_FULL, GNUNET_MAX_MALLOC_CHECKED, ret, GNUNET_FS_MetaData::sbuf, and GNUNET_FS_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().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_deserialize()

struct GNUNET_FS_MetaData * GNUNET_FS_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 (e.g. 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 885 of file meta_data.c.

{
  struct GNUNET_FS_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_FS_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 = 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_FS_meta_data_insert (md, plugin_name,
                                ntohl (ent.type), format,
                                mime_type,
                                meta_data, dlen);
  }
  GNUNET_free (data);
  return md;
}

References data, MetaDataEntry::data_size, MetaDataHeader::entries, EXTRACTOR_METAFORMAT_BINARY, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, MetaDataEntry::format, GNUNET_break_op, GNUNET_decompress(), GNUNET_free, GNUNET_FS_meta_data_create(), GNUNET_FS_meta_data_insert(), GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, HEADER_COMPRESSED, HEADER_VERSION_MASK, MetaDataEntry::mime_type_len, plugin_name, MetaDataEntry::plugin_name_len, size, MetaDataHeader::size, MetaDataEntry::type, and MetaDataHeader::version.

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

Here is the call graph for this function:

Here is the caller graph for this function: