/* gbookmarkfile.c: parsing and building desktop bookmarks

*

* Copyright (C) 2005-2006 Emmanuele Bassi

*

* SPDX-License-Identifier: LGPL-2.1-or-later

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this library; if not, see <http://www.gnu.org/licenses/>.

*/

#include "config.h"

#include "gbookmarkfile.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <fcntl.h>

#include <locale.h>

#include <time.h>

#include <stdarg.h>

#include "gconvert.h"

#include "gdataset.h"

#include "gdatetime.h"

#include "gerror.h"

#include "gfileutils.h"

#include "ghash.h"

#include "glibintl.h"

#include "glist.h"

#include "gmain.h"

#include "gmarkup.h"

#include "gmem.h"

#include "gmessages.h"

#include "gshell.h"

#include "gslice.h"

#include "gstdio.h"

#include "gstring.h"

#include "gstrfuncs.h"

#include "gtimer.h"

#include "gutils.h"

/* XBEL 1.0 standard entities */

#define XBEL_VERSION "1.0"

#define XBEL_DTD_NICK "xbel"

#define XBEL_DTD_SYSTEM "+//IDN python.org//DTD XML Bookmark " \

"Exchange Language 1.0//EN//XML"

#define XBEL_DTD_URI "http://www.python.org/topics/xml/dtds/xbel-1.0.dtd"

#define XBEL_ROOT_ELEMENT "xbel"

#define XBEL_FOLDER_ELEMENT "folder" /* unused */

#define XBEL_BOOKMARK_ELEMENT "bookmark"

#define XBEL_ALIAS_ELEMENT "alias" /* unused */

#define XBEL_SEPARATOR_ELEMENT "separator" /* unused */

#define XBEL_TITLE_ELEMENT "title"

#define XBEL_DESC_ELEMENT "desc"

#define XBEL_INFO_ELEMENT "info"

#define XBEL_METADATA_ELEMENT "metadata"

#define XBEL_VERSION_ATTRIBUTE "version"

#define XBEL_FOLDED_ATTRIBUTE "folded" /* unused */

#define XBEL_OWNER_ATTRIBUTE "owner"

#define XBEL_ADDED_ATTRIBUTE "added"

#define XBEL_VISITED_ATTRIBUTE "visited"

#define XBEL_MODIFIED_ATTRIBUTE "modified"

#define XBEL_ID_ATTRIBUTE "id"

#define XBEL_HREF_ATTRIBUTE "href"

#define XBEL_REF_ATTRIBUTE "ref" /* unused */

#define XBEL_YES_VALUE "yes"

#define XBEL_NO_VALUE "no"

/* Desktop bookmark spec entities */

#define BOOKMARK_METADATA_OWNER "http://freedesktop.org"

#define BOOKMARK_NAMESPACE_NAME "bookmark"

#define BOOKMARK_NAMESPACE_URI "http://www.freedesktop.org/standards/desktop-bookmarks"

#define BOOKMARK_GROUPS_ELEMENT "groups"

#define BOOKMARK_GROUP_ELEMENT "group"

#define BOOKMARK_APPLICATIONS_ELEMENT "applications"

#define BOOKMARK_APPLICATION_ELEMENT "application"

#define BOOKMARK_ICON_ELEMENT "icon"

#define BOOKMARK_PRIVATE_ELEMENT "private"

#define BOOKMARK_NAME_ATTRIBUTE "name"

#define BOOKMARK_EXEC_ATTRIBUTE "exec"

#define BOOKMARK_COUNT_ATTRIBUTE "count"

#define BOOKMARK_TIMESTAMP_ATTRIBUTE "timestamp" /* deprecated by "modified" */

#define BOOKMARK_MODIFIED_ATTRIBUTE "modified"

#define BOOKMARK_HREF_ATTRIBUTE "href"

#define BOOKMARK_TYPE_ATTRIBUTE "type"

/* Shared MIME Info entities */

#define MIME_NAMESPACE_NAME "mime"

#define MIME_NAMESPACE_URI "http://www.freedesktop.org/standards/shared-mime-info"

#define MIME_TYPE_ELEMENT "mime-type"

#define MIME_TYPE_ATTRIBUTE "type"

typedef struct _BookmarkAppInfo BookmarkAppInfo;

typedef struct _BookmarkMetadata BookmarkMetadata;

typedef struct _BookmarkItem BookmarkItem;

typedef struct _ParseData ParseData;

struct _BookmarkAppInfo

{

gchar *name;

gchar *exec;

guint count;

GDateTime *stamp; /* (owned) */

};

struct _BookmarkMetadata

{

gchar *mime_type;

GList *groups;

GList *applications;

GHashTable *apps_by_name;

gchar *icon_href;

gchar *icon_mime;

guint is_private : 1;

};

struct _BookmarkItem

{

gchar *uri;

gchar *title;

gchar *description;

GDateTime *added; /* (owned) */

GDateTime *modified; /* (owned) */

GDateTime *visited; /* (owned) */

BookmarkMetadata *metadata;

};

struct _GBookmarkFile

{

gchar *title;

gchar *description;

/* we store our items in a list and keep a copy inside

* a hash table for faster lookup performances

*/

GList *items;

GHashTable *items_by_uri;

};

/* parser state machine */

typedef enum

{

STATE_STARTED = 0,

STATE_ROOT,

STATE_BOOKMARK,

STATE_TITLE,

STATE_DESC,

STATE_INFO,

STATE_METADATA,

STATE_APPLICATIONS,

STATE_APPLICATION,

STATE_GROUPS,

STATE_GROUP,

STATE_MIME,

STATE_ICON,

STATE_FINISHED

} ParserState;

static void g_bookmark_file_init (GBookmarkFile *bookmark);

static void g_bookmark_file_clear (GBookmarkFile *bookmark);

static gboolean g_bookmark_file_parse (GBookmarkFile *bookmark,

const gchar *buffer,

gsize length,

GError **error);

static gchar * g_bookmark_file_dump (GBookmarkFile *bookmark,

gsize *length,

GError **error);

static BookmarkItem *g_bookmark_file_lookup_item (GBookmarkFile *bookmark,

const gchar *uri);

static void g_bookmark_file_add_item (GBookmarkFile *bookmark,

BookmarkItem *item,

GError **error);

static gboolean timestamp_from_iso8601 (const gchar *iso_date,

GDateTime **out_date_time,

GError **error);

/********************************

* BookmarkAppInfo *

* *

* Application metadata storage *

********************************/

static BookmarkAppInfo *

bookmark_app_info_new (const gchar *name)

{

BookmarkAppInfo *retval;

g_warn_if_fail (name != NULL);

retval = g_slice_new (BookmarkAppInfo);

retval->name = g_strdup (name);

retval->exec = NULL;

retval->count = 0;

retval->stamp = NULL;

return retval;

}

static void

bookmark_app_info_free (BookmarkAppInfo *app_info)

{

if (!app_info)

return;

g_free (app_info->name);

g_free (app_info->exec);

g_clear_pointer (&app_info->stamp, g_date_time_unref);

g_slice_free (BookmarkAppInfo, app_info);

}

static BookmarkAppInfo *

bookmark_app_info_copy (BookmarkAppInfo *app_info)

{

BookmarkAppInfo *copy;

if (!app_info)

return NULL;

copy = bookmark_app_info_new (app_info->name);

copy->count = app_info->count;

copy->exec = g_strdup (app_info->exec);

if (app_info->stamp)

copy->stamp = g_date_time_ref (app_info->stamp);

return copy;

}

static gchar *

bookmark_app_info_dump (BookmarkAppInfo *app_info)

{

gchar *retval;

gchar *name, *exec, *modified, *count;

g_warn_if_fail (app_info != NULL);

if (app_info->count == 0)

return NULL;

name = g_markup_escape_text (app_info->name, -1);

exec = g_markup_escape_text (app_info->exec, -1);

count = g_strdup_printf ("%u", app_info->count);

if (app_info->stamp)

{

char *tmp;

tmp = g_date_time_format_iso8601 (app_info->stamp);

modified = g_strconcat (" " BOOKMARK_MODIFIED_ATTRIBUTE "=\"", tmp, "\"",

NULL);

g_free (tmp);

}

else

{

modified = g_strdup ("");

}

retval = g_strconcat (" "

"<" BOOKMARK_NAMESPACE_NAME ":" BOOKMARK_APPLICATION_ELEMENT

" " BOOKMARK_NAME_ATTRIBUTE "=\"", name, "\""

" " BOOKMARK_EXEC_ATTRIBUTE "=\"", exec, "\"",

modified,

" " BOOKMARK_COUNT_ATTRIBUTE "=\"", count, "\"/>\n",

NULL);

g_free (name);

g_free (exec);

g_free (modified);

g_free (count);

return retval;

}

/***********************

* BookmarkMetadata *

* *

* Metadata storage *

***********************/

static BookmarkMetadata *

bookmark_metadata_new (void)

{

BookmarkMetadata *retval;

retval = g_slice_new (BookmarkMetadata);

retval->mime_type = NULL;

retval->groups = NULL;

retval->applications = NULL;

retval->apps_by_name = g_hash_table_new_full (g_str_hash,

g_str_equal,

NULL,

NULL);

retval->is_private = FALSE;

retval->icon_href = NULL;

retval->icon_mime = NULL;

return retval;

}

static void

bookmark_metadata_free (BookmarkMetadata *metadata)

{

if (!metadata)

return;

g_free (metadata->mime_type);

g_list_free_full (metadata->groups, g_free);

g_list_free_full (metadata->applications, (GDestroyNotify) bookmark_app_info_free);

g_hash_table_destroy (metadata->apps_by_name);

g_free (metadata->icon_href);

g_free (metadata->icon_mime);

g_slice_free (BookmarkMetadata, metadata);

}

static BookmarkMetadata *

bookmark_metadata_copy (BookmarkMetadata *metadata)

{

BookmarkMetadata *copy;

GList *l;

if (!metadata)

return NULL;

copy = bookmark_metadata_new ();

copy->is_private = metadata->is_private;

copy->mime_type = g_strdup (metadata->mime_type);

copy->icon_href = g_strdup (metadata->icon_href);

copy->icon_mime = g_strdup (metadata->icon_mime);

copy->groups = g_list_copy_deep (metadata->groups, (GCopyFunc) g_strdup, NULL);

copy->applications =

g_list_copy_deep (metadata->applications, (GCopyFunc) bookmark_app_info_copy, NULL);

for (l = copy->applications; l; l = l->next)

{

BookmarkAppInfo *app_info = l->data;

g_hash_table_insert (copy->apps_by_name, app_info->name, app_info);

}

g_assert (g_hash_table_size (copy->apps_by_name) ==

g_hash_table_size (metadata->apps_by_name));

return copy;

}

static gchar *

bookmark_metadata_dump (BookmarkMetadata *metadata)

{

GString *retval;

gchar *buffer;

if (!metadata->applications)

return NULL;

retval = g_string_sized_new (1024);

/* metadata container */

g_string_append (retval,

" "

"<" XBEL_METADATA_ELEMENT

" " XBEL_OWNER_ATTRIBUTE "=\"" BOOKMARK_METADATA_OWNER

"\">\n");

/* mime type */

if (metadata->mime_type) {

buffer = g_strconcat (" "

"<" MIME_NAMESPACE_NAME ":" MIME_TYPE_ELEMENT " "

MIME_TYPE_ATTRIBUTE "=\"", metadata->mime_type, "\"/>\n",

NULL);

g_string_append (retval, buffer);

g_free (buffer);

}

if (metadata->groups)

{

GList *l;

/* open groups container */

g_string_append (retval,

" "

"<" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_GROUPS_ELEMENT ">\n");

for (l = g_list_last (metadata->groups); l != NULL; l = l->prev)

{

gchar *group_name;

group_name = g_markup_escape_text ((gchar *) l->data, -1);

buffer = g_strconcat (" "

"<" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_GROUP_ELEMENT ">",

group_name,

"</" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_GROUP_ELEMENT ">\n", NULL);

g_string_append (retval, buffer);

g_free (buffer);

g_free (group_name);

}

/* close groups container */

g_string_append (retval,

" "

"</" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_GROUPS_ELEMENT ">\n");

}

if (metadata->applications)

{

GList *l;

/* open applications container */

g_string_append (retval,

" "

"<" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_APPLICATIONS_ELEMENT ">\n");

for (l = g_list_last (metadata->applications); l != NULL; l = l->prev)

{

BookmarkAppInfo *app_info = (BookmarkAppInfo *) l->data;

gchar *app_data;

g_warn_if_fail (app_info != NULL);

app_data = bookmark_app_info_dump (app_info);

if (app_data)

{

retval = g_string_append (retval, app_data);

g_free (app_data);

}

}

/* close applications container */

g_string_append (retval,

" "

"</" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_APPLICATIONS_ELEMENT ">\n");

}

/* icon */

if (metadata->icon_href)

{

gchar *href, *mime;

if (!metadata->icon_mime)

metadata->icon_mime = g_strdup ("application/octet-stream");

href = g_markup_escape_text (metadata->icon_href, -1);

mime = g_markup_escape_text (metadata->icon_mime, -1);

buffer = g_strconcat (" "

"<" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_ICON_ELEMENT

" " BOOKMARK_HREF_ATTRIBUTE "=\"",

href,

"\" " BOOKMARK_TYPE_ATTRIBUTE "=\"", mime, "\"/>\n", NULL);

g_string_append (retval, buffer);

g_free (buffer);

g_free (mime);

g_free (href);

}

/* private hint */

if (metadata->is_private)

g_string_append (retval,

" "

"<" BOOKMARK_NAMESPACE_NAME

":" BOOKMARK_PRIVATE_ELEMENT "/>\n");

/* close metadata container */

g_string_append (retval,

" "

"</" XBEL_METADATA_ELEMENT ">\n");

return g_string_free (retval, FALSE);

}

/******************************************************

* BookmarkItem *

* *

* Storage for a single bookmark item inside the list *

******************************************************/

static BookmarkItem *

bookmark_item_new (const gchar *uri)

{

BookmarkItem *item;

g_warn_if_fail (uri != NULL);

item = g_slice_new (BookmarkItem);

item->uri = g_strdup (uri);

item->title = NULL;

item->description = NULL;

item->added = NULL;

item->modified = NULL;

item->visited = NULL;

item->metadata = NULL;

return item;

}

static void

bookmark_item_free (BookmarkItem *item)

{

if (!item)

return;

g_free (item->uri);

g_free (item->title);

g_free (item->description);

if (item->metadata)

bookmark_metadata_free (item->metadata);

g_clear_pointer (&item->added, g_date_time_unref);

g_clear_pointer (&item->modified, g_date_time_unref);

g_clear_pointer (&item->visited, g_date_time_unref);

g_slice_free (BookmarkItem, item);

}

static BookmarkItem *

bookmark_item_copy (BookmarkItem *item)

{

BookmarkItem* copy;

if (!item)

return NULL;

copy = bookmark_item_new (item->uri);

copy->title = g_strdup (item->title);

copy->description = g_strdup (item->description);

copy->metadata = bookmark_metadata_copy (item->metadata);

if (item->added)

copy->added = g_date_time_ref (item->added);

if (item->modified)

copy->modified = g_date_time_ref (item->modified);

if (item->visited)

copy->visited = g_date_time_ref (item->visited);

return copy;

}

static void

bookmark_item_touch_modified (BookmarkItem *item)

{

g_clear_pointer (&item->modified, g_date_time_unref);

item->modified = g_date_time_new_now_utc ();

}

static gchar *

bookmark_item_dump (BookmarkItem *item)

{

GString *retval;

gchar *escaped_uri;

/* at this point, we must have at least a registered application; if we don't

* we don't screw up the bookmark file, and just skip this item

*/

if (!item->metadata || !item->metadata->applications)

{

g_warning ("Item for URI '%s' has no registered applications: skipping.", item->uri);

return NULL;

}

retval = g_string_sized_new (4096);

g_string_append (retval, " <" XBEL_BOOKMARK_ELEMENT " ");

escaped_uri = g_markup_escape_text (item->uri, -1);

g_string_append (retval, XBEL_HREF_ATTRIBUTE "=\"");

g_string_append (retval, escaped_uri);

g_string_append (retval , "\" ");

g_free (escaped_uri);

if (item->added)

{

char *added;

added = g_date_time_format_iso8601 (item->added);

g_string_append (retval, XBEL_ADDED_ATTRIBUTE "=\"");

g_string_append (retval, added);

g_string_append (retval, "\" ");

g_free (added);

}

if (item->modified)

{

char *modified;

modified = g_date_time_format_iso8601 (item->modified);

g_string_append (retval, XBEL_MODIFIED_ATTRIBUTE "=\"");

g_string_append (retval, modified);

g_string_append (retval, "\" ");

g_free (modified);

}

if (item->visited)

{

char *visited;

visited = g_date_time_format_iso8601 (item->visited);

g_string_append (retval, XBEL_VISITED_ATTRIBUTE "=\"");

g_string_append (retval, visited);

g_string_append (retval, "\" ");

g_free (visited);

}

if (retval->str[retval->len - 1] == ' ')

g_string_truncate (retval, retval->len - 1);

g_string_append (retval, ">\n");

if (item->title)

{

gchar *escaped_title;

escaped_title = g_markup_escape_text (item->title, -1);

g_string_append (retval, " " "<" XBEL_TITLE_ELEMENT ">");

g_string_append (retval, escaped_title);

g_string_append (retval, "</" XBEL_TITLE_ELEMENT ">\n");

g_free (escaped_title);

}

if (item->description)

{

gchar *escaped_desc;

escaped_desc = g_markup_escape_text (item->description, -1);

g_string_append (retval, " " "<" XBEL_DESC_ELEMENT ">");

g_string_append (retval, escaped_desc);

g_string_append (retval, "</" XBEL_DESC_ELEMENT ">\n");

g_free (escaped_desc);

}

if (item->metadata)

{

gchar *metadata;

metadata = bookmark_metadata_dump (item->metadata);

if (metadata)

{

g_string_append (retval, " " "<" XBEL_INFO_ELEMENT ">\n");

g_string_append (retval, metadata);

g_string_append (retval, " " "</" XBEL_INFO_ELEMENT ">\n");

g_free (metadata);

}

}

g_string_append (retval, " </" XBEL_BOOKMARK_ELEMENT ">\n");

return g_string_free (retval, FALSE);

}

static BookmarkAppInfo *

bookmark_item_lookup_app_info (BookmarkItem *item,

const gchar *app_name)

{

g_warn_if_fail (item != NULL && app_name != NULL);

if (!item->metadata)

return NULL;

return g_hash_table_lookup (item->metadata->apps_by_name, app_name);

}

/*************************

* GBookmarkFile *

*************************/

static void

g_bookmark_file_init (GBookmarkFile *bookmark)

{

bookmark->title = NULL;

bookmark->description = NULL;

bookmark->items = NULL;

bookmark->items_by_uri = g_hash_table_new_full (g_str_hash,

g_str_equal,

NULL,

NULL);

}

static void

g_bookmark_file_clear (GBookmarkFile *bookmark)

{

g_free (bookmark->title);

g_free (bookmark->description);

g_list_free_full (bookmark->items, (GDestroyNotify) bookmark_item_free);

bookmark->items = NULL;

g_clear_pointer (&bookmark->items_by_uri, g_hash_table_unref);

}

struct _ParseData

{

ParserState state;

GHashTable *namespaces;

GBookmarkFile *bookmark_file;

BookmarkItem *current_item;

};

static ParseData *

parse_data_new (void)

{

ParseData *retval;

retval = g_new (ParseData, 1);

retval->state = STATE_STARTED;

retval->namespaces = g_hash_table_new_full (g_str_hash, g_str_equal,

(GDestroyNotify) g_free,

(GDestroyNotify) g_free);

retval->bookmark_file = NULL;

retval->current_item = NULL;

return retval;

}

static void

parse_data_free (ParseData *parse_data)

{

g_hash_table_destroy (parse_data->namespaces);

g_free (parse_data);

}

#define IS_ATTRIBUTE(s,a) ((0 == strcmp ((s), (a))))

static void

parse_bookmark_element (GMarkupParseContext *context,

ParseData *parse_data,

const gchar **attribute_names,

const gchar **attribute_values,

GError **error)

{

const gchar *uri, *added, *modified, *visited;

const gchar *attr;

gint i;

BookmarkItem *item;

GError *add_error;

g_warn_if_fail ((parse_data != NULL) && (parse_data->state == STATE_BOOKMARK));

i = 0;

uri = added = modified = visited = NULL;

for (attr = attribute_names[i]; attr != NULL; attr = attribute_names[++i])

{

if (IS_ATTRIBUTE (attr, XBEL_HREF_ATTRIBUTE))

uri = attribute_values[i];

else if (IS_ATTRIBUTE (attr, XBEL_ADDED_ATTRIBUTE))

added = attribute_values[i];

else if (IS_ATTRIBUTE (attr, XBEL_MODIFIED_ATTRIBUTE))

modified = attribute_values[i];

else if (IS_ATTRIBUTE (attr, XBEL_VISITED_ATTRIBUTE))

visited = attribute_values[i];

else

{

/* bookmark is defined by the XBEL spec, so we need

* to error out if the element has different or

* missing attributes

*/

g_set_error (error, G_MARKUP_ERROR,

G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,

_("Unexpected attribute “%s” for element “%s”"),

attr,

XBEL_BOOKMARK_ELEMENT);

return;

}

}

if (!uri)

{

g_set_error (error, G_MARKUP_ERROR,

G_MARKUP_ERROR_INVALID_CONTENT,

_("Attribute “%s” of element “%s” not found"),

XBEL_HREF_ATTRIBUTE,

XBEL_BOOKMARK_ELEMENT);

return;

}

g_warn_if_fail (parse_data->current_item == NULL);

item = bookmark_item_new (uri);

if (added != NULL && !timestamp_from_iso8601 (added, &item->added, error))

{

bookmark_item_free (item);

return;

}

if (modified != NULL && !timestamp_from_iso8601 (modified, &item->modified, error))

{

bookmark_item_free (item);

return;

}

if (visited != NULL && !timestamp_from_iso8601 (visited, &item->visited, error))

{

bookmark_item_free (item);

return;

}

add_error = NULL;

g_bookmark_file_add_item (parse_data->bookmark_file,

item,

&add_error);

if (add_error)

{

bookmark_item_free (item);

g_propagate_error (error, add_error);

return;

}

parse_data->current_item = item;

}

static void

parse_application_element (GMarkupParseContext *context,

ParseData *parse_data,

const gchar **attribute_names,

const gchar **attribute_values,

GError **error)

{

const gchar *name, *exec, *count, *stamp, *modified;

const gchar *attr;

gint i;

BookmarkItem *item;

BookmarkAppInfo *ai;

g_warn_if_fail ((parse_data != NULL) && (parse_data->state == STATE_APPLICATION));

i = 0;

name = exec = count = stamp = modified = NULL;

for (attr = attribute_names[i]; attr != NULL; attr = attribute_names[++i])

{

if (IS_ATTRIBUTE (attr, BOOKMARK_NAME_ATTRIBUTE))

name = attribute_values[i];

else if (IS_ATTRIBUTE (attr, BOOKMARK_EXEC_ATTRIBUTE))

exec = attribute_values[i];

else if (IS_ATTRIBUTE (attr, BOOKMARK_COUNT_ATTRIBUTE))

count = attribute_values[i];

else if (IS_ATTRIBUTE (attr, BOOKMARK_TIMESTAMP_ATTRIBUTE))

stamp = attribute_values[i];

else if (IS_ATTRIBUTE (attr, BOOKMARK_MODIFIED_ATTRIBUTE))

modified = attribute_values[i];

}

/* the "name" and "exec" attributes are mandatory */

if (!name)

{

g_set_error (error, G_MARKUP_ERROR,

G_MARKUP_ERROR_INVALID_CONTENT,

_("Attribute “%s” of element “%s” not found"),

BOOKMARK_NAME_ATTRIBUTE,

BOOKMARK_APPLICATION_ELEMENT);

return;

}

if (!exec)

{

g_set_error (error, G_MARKUP_ERROR,

G_MARKUP_ERROR_INVALID_CONTENT,

_("Attribute “%s” of element “%s” not found"),

BOOKMARK_EXEC_ATTRIBUTE,

BOOKMARK_APPLICATION_ELEMENT);

return;

}

g_warn_if_fail (parse_data->current_item != NULL);

item = parse_data->current_item;

ai = bookmark_item_lookup_app_info (item, name);

if (!ai)

{

ai = bookmark_app_info_new (name);

if (!item->metadata)

item->metadata = bookmark_metadata_new ();

item->metadata->applications = g_list_prepend (item->metadata->applications, ai);

g_hash_table_replace (item->metadata->apps_by_name, ai->name, ai);

}

g_free (ai->exec);

ai->exec = g_strdup (exec);

if (count)

ai->count = atoi (count);

else

ai->count = 1;

g_clear_pointer (&ai->stamp, g_date_time_unref);

if (modified != NULL)

{

if (!timestamp_from_iso8601 (modified, &ai->stamp, error))

return;

}

else

{

/* the timestamp attribute has been deprecated but we still parse

* it for backward compatibility

*/

if (stamp)

ai->stamp = g_date_time_new_from_unix_utc (atol (stamp));

else

ai->stamp = g_date_time_new_now_utc ();

}

}

static void

parse_mime_type_element (GMarkupParseContext *context,

ParseData *parse_data,

const gchar **attribute_names,

const gchar **attribute_values,

GError **error)

{

const gchar *type;

const gchar *attr;

gint i;

BookmarkItem *item;

g_warn_if_fail ((parse_data != NULL) && (parse_data->state == STATE_MIME));

i = 0;

type = NULL;

for (attr = attribute_names[i]; attr != NULL; attr = attribute_names[++i])

{

if (IS_ATTRIBUTE (attr, MIME_TYPE_ATTRIBUTE))

type = attribute_values[i];

}

if (!type)

type = "application/octet-stream";

g_warn_if_fail (parse_data->current_item != NULL);

item = parse_data->current_item;

if (!item->metadata)