cafe-desktop-item.c

Bug Summary

File:	libcafe-desktop/cafe-desktop-item.c
Warning:	line 3122, column 4 Access of the heap area at index 3, while it holds only 3 'char' elements
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cafe-desktop-item.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/libcafe-desktop -fcoverage-compilation-dir=/rootdir/libcafe-desktop -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libpng16 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/startup-notification-1.0 -I /usr/include/dconf -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libmount -I /usr/include/blkid -D G_LOG_DOMAIN="CafeDesktop" -D CAFELOCALEDIR="/usr/share/locale" -D PNP_IDS="/usr/share/libcafe-desktop/pnp.ids" -D ISO_CODES_PREFIX="/usr" -D PIC -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-12-27-181026-15074-1 -x c cafe-desktop-item.c
1/* -*- Mode: C; c-set-style: linux indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2/* cafe-desktop-item.c - CAFE Desktop File Representation

 Copyright (C) 1999, 2000 Red Hat Inc.
 Copyright (C) 2001 Sid Vicious
 All rights reserved.

 This file is part of the Cafe Library.

 Developed by Elliot Lee <sopwith@redhat.com> and Sid Vicious

 The Cafe Library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public License as
 published by the Free Software Foundation; either version 2 of the
 License, or (at your option) any later version.

 The Cafe 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
 Library General Public License for more details.

 You should have received a copy of the GNU Library General Public
 License along with the Cafe Library; see the file COPYING.LIB.  If not,
 write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 Boston, MA 02110-1301, USA.  */
26/*
@NOTATION@
*/

30#include "config.h"

32#include <limits.h>
33#include <ctype.h>
34#include <stdio.h>
35#include <glib.h>
36#include <sys/types.h>
37#include <dirent.h>
38#include <unistd.h>
39#include <time.h>
40#include <string.h>
41#include <glib/gi18n-lib.h>
42#include <locale.h>
43#include <stdlib.h>

45#include <gio/gio.h>

47#ifdef HAVE_STARTUP_NOTIFICATION
48#define SN_API_NOT_YET_FROZEN
49#include <libsn/sn.h>
50#include <cdk/cdk.h>
51#include <cdk/cdkx.h>
52#include <ctk/ctk.h>
53#endif

55#define sure_string(s)((s)!=((void*)0)?(s):"") ((s)!=NULL((void*)0)?(s):"")

57#define CAFE_DESKTOP_USE_UNSTABLE_API
58#undef CAFE_DISABLE_DEPRECATED
59#include <cafe-desktop-item.h>
60#include <cafe-desktop-utils.h>

62#include "private.h"

64struct _CafeDesktopItem {
int refcount;

/* all languages used */
GList *languages;

CafeDesktopItemType type;

/* `modified' means that the ditem has been
* modified since the last save. */
gboolean modified;

/* Keys of the main section only */
GList *keys;

GList *sections;

/* This includes ALL keys, including
* other sections, separated by '/' */
GHashTable *main_hash;

char *location;

time_t mtime;

guint32 launch_time;
90};

92/* If mtime is set to this, set_location won't update mtime,
* this is to be used internally only. */
94#define DONT_UPDATE_MTIME((time_t)-2) ((time_t)-2)

96typedef struct {
char *name;
GList *keys;
99} Section;

101typedef enum {
ENCODING_UNKNOWN,
ENCODING_UTF8,
ENCODING_LEGACY_MIXED
105} Encoding;

107/*
* IO reading utils, that look like the libc buffered io stuff
*/

111#define READ_BUF_SIZE(32 * 1024) (32 * 1024)

113typedef struct {
GFile *file;
GFileInputStream *stream;
char *uri;
char *buf;
gboolean buf_needs_free;
gboolean past_first_read;
gboolean eof;
guint64 size;
gsize pos;
123} ReadBuf;

125static CafeDesktopItem *ditem_load (ReadBuf           *rb,
		     gboolean           no_translations,
		     GError           **error);
128static gboolean          ditem_save (CafeDesktopItem  *item,
		     const char        *uri,
		     GError           **error);

132static void cafe_desktop_item_set_location_gfile (CafeDesktopItem *item,
				   GFile            *file);

135static CafeDesktopItem *cafe_desktop_item_new_from_gfile (GFile *file,
					    CafeDesktopItemLoadFlags flags,
					    GError **error);

139static int
140readbuf_getc (ReadBuf *rb)
141{
if (rb->eof)
return EOF(-1);

if (rb->size == 0 ||
   rb->pos == rb->size) {
gssize bytes_read;

if (rb->stream == NULL((void*)0))
	bytes_read = 0;
else
	bytes_read = g_input_stream_read (G_INPUT_STREAM (rb->stream)((((GInputStream*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((rb->stream)), ((g_input_stream_get_type ())))))),
					  rb->buf,
					  READ_BUF_SIZE(32 * 1024),
					  NULL((void*)0), NULL((void*)0));

/* FIXME: handle errors other than EOF */
if (bytes_read <= 0) {
	rb->eof = TRUE(!(0));
	return EOF(-1);
}

if (rb->size != 0)
	rb->past_first_read = TRUE(!(0));
rb->size = bytes_read;
rb->pos = 0;

}

return (guchar) rb->buf[rb->pos++];
171}

173/* Note, does not include the trailing \n */
174static char *
175readbuf_gets (char *buf, gsize bufsize, ReadBuf *rb)
176{
int c;
gsize pos;

g_return_val_if_fail (buf != NULL, NULL)do { if ((buf != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "buf != NULL"); return
 (((void*)0)); } } while (0);
g_return_val_if_fail (rb != NULL, NULL)do { if ((rb != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "rb != NULL"); return
 (((void*)0)); } } while (0);

pos = 0;
buf[0] = '\0';

do {
c = readbuf_getc (rb);
if (c == EOF(-1) || c == '\n')
	break;
buf[pos++] = c;
} while (pos < bufsize-1);

if (c == EOF(-1) && pos == 0)
return NULL((void*)0);

buf[pos++] = '\0';

return buf;
199}

201static ReadBuf *
202readbuf_open (GFile *file, GError **error)
203{
GError *local_error;
GFileInputStream *stream;
char *uri;
ReadBuf *rb;

g_return_val_if_fail (file != NULL, NULL)do { if ((file != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "file != NULL");
 return (((void*)0)); } } while (0);

uri = g_file_get_uri (file);
local_error = NULL((void*)0);
stream = g_file_read (file, NULL((void*)0), &local_error);

if (stream == NULL((void*)0)) {
g_set_error (error,
	     /* FIXME: better errors */
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,
	     _("Error reading file '%s': %s")((char *) g_dgettext ("cafe-desktop", "Error reading file '%s': %s"
)),
	     uri, local_error->message);
g_error_free (local_error);
g_free (uri);
return NULL((void*)0);
}

rb = g_new0 (ReadBuf, 1)((ReadBuf *) g_malloc0_n ((1), sizeof (ReadBuf)));
rb->stream = stream;
rb->file = g_file_dup (file);
rb->uri = uri;
rb->buf = g_malloc (READ_BUF_SIZE(32 * 1024));
rb->buf_needs_free = TRUE(!(0));
/* rb->past_first_read = FALSE; */
/* rb->eof = FALSE; */
/* rb->size = 0; */
/* rb->pos = 0; */

return rb;
239}

241static ReadBuf *
242readbuf_new_from_string (const char *uri, const char *string, gssize length)
243{
ReadBuf *rb;

g_return_val_if_fail (string != NULL, NULL)do { if ((string != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "string != NULL"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (length >= 0, NULL)do { if ((length >= 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "length >= 0"
); return (((void*)0)); } } while (0);

rb = g_new0 (ReadBuf, 1)((ReadBuf *) g_malloc0_n ((1), sizeof (ReadBuf)));
/* rb->file = NULL; */
/* rb->stream = NULL; */
rb->uri = g_strdup (uri)g_strdup_inline (uri);
rb->buf = (char *) string;
/* rb->buf_needs_free = FALSE; */
/* rb->past_first_read = FALSE; */
/* rb->eof = FALSE; */
rb->size = length;
/* rb->pos = 0; */

return rb;
261}

263static gboolean
264readbuf_rewind (ReadBuf *rb, GError **error)
265{
GError *local_error;

rb->eof = FALSE(0);
rb->pos = 0;

if (!rb->past_first_read)
return TRUE(!(0));

rb->size = 0;

if (g_seekable_seek (G_SEEKABLE (rb->stream)((((GSeekable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((rb->stream)), ((g_seekable_get_type ())))))),
	     0, G_SEEK_SET, NULL((void*)0), NULL((void*)0)))
return TRUE(!(0));

g_object_unref (rb->stream);
local_error = NULL((void*)0);
rb->stream = g_file_read (rb->file, NULL((void*)0), &local_error);

if (rb->stream == NULL((void*)0)) {
g_set_error (
	error, CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	CAFE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,
	_("Error rewinding file '%s': %s")((char *) g_dgettext ("cafe-desktop", "Error rewinding file '%s': %s"
)),
	rb->uri, local_error->message);
g_error_free (local_error);

return FALSE(0);
}

return TRUE(!(0));
296}

298static void
299readbuf_close (ReadBuf *rb)
300{
if (rb->stream != NULL((void*)0))
g_object_unref (rb->stream);
if (rb->file != NULL((void*)0))
g_object_unref (rb->file);
g_free (rb->uri);
if (rb->buf_needs_free)
g_free (rb->buf);
g_free (rb);
309}

311static CafeDesktopItemType
312type_from_string (const char *type)
313{
if (!type)
return CAFE_DESKTOP_ITEM_TYPE_NULL;

switch (type [0]) {
case 'A':
if (!strcmp (type, "Application"))
	return CAFE_DESKTOP_ITEM_TYPE_APPLICATION;
break;
case 'L':
if (!strcmp (type, "Link"))
	return CAFE_DESKTOP_ITEM_TYPE_LINK;
break;
case 'F':
if (!strcmp (type, "FSDevice"))
	return CAFE_DESKTOP_ITEM_TYPE_FSDEVICE;
break;
case 'M':
if (!strcmp (type, "MimeType"))
	return CAFE_DESKTOP_ITEM_TYPE_MIME_TYPE;
break;
case 'D':
if (!strcmp (type, "Directory"))
	return CAFE_DESKTOP_ITEM_TYPE_DIRECTORY;
break;
case 'S':
if (!strcmp (type, "Service"))
	return CAFE_DESKTOP_ITEM_TYPE_SERVICE;

else if (!strcmp (type, "ServiceType"))
	return CAFE_DESKTOP_ITEM_TYPE_SERVICE_TYPE;
break;
default:
break;
}

return CAFE_DESKTOP_ITEM_TYPE_OTHER;
350}

352/**
* cafe_desktop_item_new:
*
* Creates a CafeDesktopItem object. The reference count on the returned value is set to '1'.
*
* Returns: The new CafeDesktopItem
*/
359CafeDesktopItem *
360cafe_desktop_item_new (void)
361{
CafeDesktopItem *retval;

_cafe_desktop_init_i18n ();

retval = g_new0 (CafeDesktopItem, 1)((CafeDesktopItem *) g_malloc0_n ((1), sizeof (CafeDesktopItem
)));

retval->refcount++;

retval->main_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
				   (GDestroyNotify) g_free,
				   (GDestroyNotify) g_free);

/* These are guaranteed to be set */
cafe_desktop_item_set_string (retval,
		       CAFE_DESKTOP_ITEM_NAME"Name",
		       /* Translators: the "name" mentioned
			* here is the name of an application or
			* a document */
		       _("No name")((char *) g_dgettext ("cafe-desktop", "No name")));
cafe_desktop_item_set_string (retval,
		       CAFE_DESKTOP_ITEM_ENCODING"Encoding",
		       "UTF-8");
cafe_desktop_item_set_string (retval,
		       CAFE_DESKTOP_ITEM_VERSION"Version",
		       "1.0");

retval->launch_time = 0;

return retval;
391}

393static Section *
394dup_section (Section *sec)
395{
GList *li;
Section *retval = g_new0 (Section, 1)((Section *) g_malloc0_n ((1), sizeof (Section)));

retval->name = g_strdup (sec->name)g_strdup_inline (sec->name);

retval->keys = g_list_copy (sec->keys);
for (li = retval->keys; li != NULL((void*)0); li = li->next)
li->data = g_strdup (li->data)g_strdup_inline (li->data);

return retval;
406}

408static void
409copy_string_hash (gpointer key, gpointer value, gpointer user_data)
410{
GHashTable *copy = user_data;
g_hash_table_replace (copy,
	      g_strdup (key)g_strdup_inline (key),
	      g_strdup (value)g_strdup_inline (value));
415}


418/**
* cafe_desktop_item_copy:
* @item: The item to be copied
*
* Creates a copy of a CafeDesktopItem.  The new copy has a refcount of 1.
* Note: Section stack is NOT copied.
*
* Returns: The new copy
*/
427CafeDesktopItem *
428cafe_desktop_item_copy (const CafeDesktopItem *item)
429{
GList *li;
CafeDesktopItem *retval;

g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);

retval = cafe_desktop_item_new ();

retval->type = item->type;
retval->modified = item->modified;
retval->location = g_strdup (item->location)g_strdup_inline (item->location);
retval->mtime = item->mtime;
retval->launch_time = item->launch_time;

/* Languages */
retval->languages = g_list_copy (item->languages);
for (li = retval->languages; li != NULL((void*)0); li = li->next)
li->data = g_strdup (li->data)g_strdup_inline (li->data);

/* Keys */
retval->keys = g_list_copy (item->keys);
for (li = retval->keys; li != NULL((void*)0); li = li->next)
li->data = g_strdup (li->data)g_strdup_inline (li->data);

/* Sections */
retval->sections = g_list_copy (item->sections);
for (li = retval->sections; li != NULL((void*)0); li = li->next)
li->data = dup_section (li->data);

retval->main_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
				   (GDestroyNotify) g_free,
				   (GDestroyNotify) g_free);

g_hash_table_foreach (item->main_hash,
	      copy_string_hash,
	      retval->main_hash);

return retval;
468}

470static void
471read_sort_order (CafeDesktopItem *item, GFile *dir)
472{
GFile *child;
char buf[BUFSIZ8192];
GString *str;
ReadBuf *rb;

child = g_file_get_child (dir, ".order");

rb = readbuf_open (child, NULL((void*)0));
g_object_unref (child);

if (rb == NULL((void*)0))
return;

str = NULL((void*)0);
while (readbuf_gets (buf, sizeof (buf), rb) != NULL((void*)0)) {
if (str == NULL((void*)0))
	str = g_string_new (buf);
else
	g_string_append (str, buf)(__builtin_constant_p (buf) ? __extension__ ({ const char * const
 __val = (buf); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, buf, (gssize) -1
));
g_string_append_c (str, ';')g_string_append_c_inline (str, ';');
}
readbuf_close (rb);
if (str != NULL((void*)0)) {
cafe_desktop_item_set_string (item, CAFE_DESKTOP_ITEM_SORT_ORDER"SortOrder",
			       str->str);
g_string_free (str, TRUE)(__builtin_constant_p ((!(0))) ? (((!(0))) ? (g_string_free) (
(str), ((!(0)))) : g_string_free_and_steal (str)) : (g_string_free
) ((str), ((!(0)))));
}
500}

502static CafeDesktopItem *
503make_fake_directory (GFile *dir)
504{
CafeDesktopItem *item;
GFile *child;

item = cafe_desktop_item_new ();
cafe_desktop_item_set_entry_type (item,
			   CAFE_DESKTOP_ITEM_TYPE_DIRECTORY);


item->mtime = DONT_UPDATE_MTIME((time_t)-2); /* it doesn't exist, we know that */
child = g_file_get_child (dir, ".directory");
cafe_desktop_item_set_location_gfile (item, child);
item->mtime = 0;
g_object_unref (child);

read_sort_order (item, dir);

return item;
522}

524/**
* cafe_desktop_item_new_from_file:
* @file: The filename or directory path to load the CafeDesktopItem from
* @flags: Flags to influence the loading process
*
* This function loads 'file' and turns it into a CafeDesktopItem.
*
* Returns: The newly loaded item.
*/
533CafeDesktopItem *
534cafe_desktop_item_new_from_file (const char *file,
		  CafeDesktopItemLoadFlags flags,
		  GError **error)
537{
CafeDesktopItem *retval;
GFile *gfile;

g_return_val_if_fail (file != NULL, NULL)do { if ((file != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "file != NULL");
 return (((void*)0)); } } while (0);

gfile = g_file_new_for_path (file);
retval = cafe_desktop_item_new_from_gfile (gfile, flags, error);
g_object_unref (gfile);

return retval;
548}

550/**
* cafe_desktop_item_new_from_uri:
* @uri: URI to load the CafeDesktopItem from
* @flags: Flags to influence the loading process
*
* This function loads 'uri' and turns it into a CafeDesktopItem.
*
* Returns: The newly loaded item.
*/
559CafeDesktopItem *
560cafe_desktop_item_new_from_uri (const char *uri,
		 CafeDesktopItemLoadFlags flags,
		 GError **error)
563{
CafeDesktopItem *retval;
GFile *file;

g_return_val_if_fail (uri != NULL, NULL)do { if ((uri != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "uri != NULL"); return
 (((void*)0)); } } while (0);

file = g_file_new_for_uri (uri);
retval = cafe_desktop_item_new_from_gfile (file, flags, error);
g_object_unref (file);

return retval;
574}

576static CafeDesktopItem *
577cafe_desktop_item_new_from_gfile (GFile *file,
		   CafeDesktopItemLoadFlags flags,
		   GError **error)
580{
CafeDesktopItem *retval;
GFile *subfn;
GFileInfo *info;
GFileType type;
GFile *parent;
time_t mtime = 0;
ReadBuf *rb;

g_return_val_if_fail (file != NULL, NULL)do { if ((file != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "file != NULL");
 return (((void*)0)); } } while (0);

info = g_file_query_info (file,
	          G_FILE_ATTRIBUTE_STANDARD_TYPE"standard::type"","G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified",
		  G_FILE_QUERY_INFO_NONE, NULL((void*)0), error);
if (info == NULL((void*)0))
return NULL((void*)0);

type = g_file_info_get_file_type (info);

if (type != G_FILE_TYPE_REGULAR && type != G_FILE_TYPE_DIRECTORY) {
char *uri;

uri = g_file_get_uri (file);
g_set_error (error,
	     /* FIXME: better errors */
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_INVALID_TYPE,
	     _("File '%s' is not a regular file or directory.")((char *) g_dgettext ("cafe-desktop", "File '%s' is not a regular file or directory."
)),
	     uri);

g_free (uri);
g_object_unref (info);

return NULL((void*)0);
}

mtime = g_file_info_get_attribute_uint64 (info,
				  G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified");

g_object_unref (info);

if (type == G_FILE_TYPE_DIRECTORY) {
GFile *child;
GFileInfo *child_info;

child = g_file_get_child (file, ".directory");
child_info = g_file_query_info (child,
				G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified",
				G_FILE_QUERY_INFO_NONE,
				NULL((void*)0), NULL((void*)0));

if (child_info == NULL((void*)0)) {
	g_object_unref (child);

	if (flags & CAFE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS) {
		return NULL((void*)0);
	} else {
		return make_fake_directory (file);
	}
}

mtime = g_file_info_get_attribute_uint64 (child_info,
					  G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified");
g_object_unref (child_info);

subfn = child;
} else {
subfn = g_file_dup (file);
}

rb = readbuf_open (subfn, error);

if (rb == NULL((void*)0)) {
g_object_unref (subfn);
return NULL((void*)0);
}

retval = ditem_load (rb,
	     (flags & CAFE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS) != 0,
	     error);

if (retval == NULL((void*)0)) {
g_object_unref (subfn);
return NULL((void*)0);
}

if (flags & CAFE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS &&
   ! cafe_desktop_item_exists (retval)) {
cafe_desktop_item_unref (retval);
g_object_unref (subfn);
return NULL((void*)0);
}

retval->mtime = DONT_UPDATE_MTIME((time_t)-2);
cafe_desktop_item_set_location_gfile (retval, subfn);
retval->mtime = mtime;

parent = g_file_get_parent (file);
if (parent != NULL((void*)0)) {
read_sort_order (retval, parent);
g_object_unref (parent);
}

g_object_unref (subfn);

return retval;
686}

688/**
* cafe_desktop_item_new_from_string:
* @string: string to load the CafeDesktopItem from
* @length: length of string, or -1 to use strlen
* @flags: Flags to influence the loading process
* @error: place to put errors
*
* This function turns the contents of the string into a CafeDesktopItem.
*
* Returns: The newly loaded item.
*/
699CafeDesktopItem *
700cafe_desktop_item_new_from_string (const char *uri,
		    const char *string,
		    gssize length,
		    CafeDesktopItemLoadFlags flags,
		    GError **error)
705{
CafeDesktopItem *retval;
ReadBuf *rb;

g_return_val_if_fail (string != NULL, NULL)do { if ((string != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "string != NULL"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (length >= -1, NULL)do { if ((length >= -1)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "length >= -1"
); return (((void*)0)); } } while (0);

if (length == -1) {
length = strlen (string);
}

rb = readbuf_new_from_string (uri, string, length);

retval = ditem_load (rb,
	     (flags & CAFE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS) != 0,
	     error);

if (retval == NULL((void*)0)) {
return NULL((void*)0);
}

/* FIXME: Sort order? */

return retval;
729}

731static char *
732lookup_desktop_file_in_data_dir (const char *desktop_file,
                               const char *data_dir)
734{
char *path;

path = g_build_filename (data_dir, "applications", desktop_file, NULL((void*)0));
if (!g_file_test (path, G_FILE_TEST_EXISTS)) {
g_free (path);
return NULL((void*)0);
}
return path;
743}

745static char *
746file_from_basename (const char *basename)
747{
const char * const *system_data_dirs;
const char         *user_data_dir;
char               *retval;
int                 i;

user_data_dir = g_get_user_data_dir ();
system_data_dirs = g_get_system_data_dirs ();

if ((retval = lookup_desktop_file_in_data_dir (basename, user_data_dir))) {
return retval;
}
for (i = 0; system_data_dirs[i]; i++) {
if ((retval = lookup_desktop_file_in_data_dir (basename, system_data_dirs[i]))) {
	return retval;
}
}
return NULL((void*)0);
765}

767/**
* cafe_desktop_item_new_from_basename:
* @basename: The basename of the CafeDesktopItem to load.
* @flags: Flags to influence the loading process
*
* This function loads 'basename' from a system data directory and
* returns its CafeDesktopItem.
*
* Returns: The newly loaded item.
*/
777CafeDesktopItem *
778cafe_desktop_item_new_from_basename (const char *basename,
                                    CafeDesktopItemLoadFlags flags,
                                    GError **error)
781{
CafeDesktopItem *retval;
char *file;

g_return_val_if_fail (basename != NULL, NULL)do { if ((basename != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "basename != NULL"
); return (((void*)0)); } } while (0);

if (!(file = file_from_basename (basename))) {
g_set_error (error,
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,
	     _("Cannot find file '%s'")((char *) g_dgettext ("cafe-desktop", "Cannot find file '%s'"
)),
	     basename);
return NULL((void*)0);
}

retval = cafe_desktop_item_new_from_file (file, flags, error);
g_free (file);

return retval;
800}

802/**
* cafe_desktop_item_save:
* @item: A desktop item
* @under: A new uri (location) for this #CafeDesktopItem
* @force: Save even if it wasn't modified
* @error: #GError return
*
* Writes the specified item to disk.  If the 'under' is NULL, the original
* location is used.  It sets the location of this entry to point to the
* new location.
*
* Returns: boolean. %TRUE if the file was saved, %FALSE otherwise
*/
815gboolean
816cafe_desktop_item_save (CafeDesktopItem *item,
	 const char *under,
	 gboolean force,
	 GError **error)
820{
const char *uri;

if (under == NULL((void*)0) &&
1
Assuming 'under' is not equal to NULL→
   ! force &&
   ! item->modified)
return TRUE(!(0));

if (under1.1
'under' is not equal to NULL
 == NULL((void*)0))
2
←
Taking false branch→
uri = item->location;
else
uri = under;

if (uri2.1
'uri' is not equal to NULL
 == NULL((void*)0)) {
3
←
Taking false branch→
g_set_error (error,
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_NO_FILENAME,
	     _("No filename to save to")((char *) g_dgettext ("cafe-desktop", "No filename to save to"
)));
return FALSE(0);
}

if ( ! ditem_save (item, uri, error))
4
←
Calling 'ditem_save'→
return FALSE(0);

item->modified = FALSE(0);
item->mtime = time (NULL((void*)0));

return TRUE(!(0));
848}

850/**
* cafe_desktop_item_ref:
* @item: A desktop item
*
* Description: Increases the reference count of the specified item.
*
* Returns: the newly referenced @item
*/
858CafeDesktopItem *
859cafe_desktop_item_ref (CafeDesktopItem *item)
860{
g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);

item->refcount++;

return item;
866}

868static void
869free_section (gpointer data,
     gpointer user_data G_GNUC_UNUSED__attribute__ ((__unused__)))
871{
Section *section = data;

g_free (section->name);
section->name = NULL((void*)0);

g_list_foreach (section->keys, (GFunc)g_free, NULL((void*)0));
g_list_free (section->keys);
section->keys = NULL((void*)0);

g_free (section);
882}

884/**
* cafe_desktop_item_unref:
* @item: A desktop item
*
* Decreases the reference count of the specified item, and destroys the item if there are no more references left.
*/
890void
891cafe_desktop_item_unref (CafeDesktopItem *item)
892{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);

item->refcount--;

if(item->refcount != 0)
return;

g_list_foreach (item->languages, (GFunc)g_free, NULL((void*)0));
g_list_free (item->languages);
item->languages = NULL((void*)0);

g_list_foreach (item->keys, (GFunc)g_free, NULL((void*)0));
g_list_free (item->keys);
item->keys = NULL((void*)0);

g_list_foreach (item->sections, free_section, NULL((void*)0));
g_list_free (item->sections);
item->sections = NULL((void*)0);

g_hash_table_destroy (item->main_hash);
item->main_hash = NULL((void*)0);

g_free (item->location);
item->location = NULL((void*)0);

g_free (item);
920}

922static Section *
923find_section (CafeDesktopItem *item, const char *section)
924{
GList *li;
Section *sec;

if (section == NULL((void*)0))
return NULL((void*)0);
if (strcmp (section, "Desktop Entry") == 0)
return NULL((void*)0);

for (li = item->sections; li != NULL((void*)0); li = li->next) {
sec = li->data;
if (strcmp (sec->name, section) == 0)
	return sec;
}

sec = g_new0 (Section, 1)((Section *) g_malloc0_n ((1), sizeof (Section)));
sec->name = g_strdup (section)g_strdup_inline (section);
sec->keys = NULL((void*)0);

item->sections = g_list_append (item->sections, sec);

/* Don't mark the item modified, this is just an empty section,
* it won't be saved even */

return sec;
949}

951static Section *
952section_from_key (CafeDesktopItem *item, const char *key)
953{
char *p;
char *name;
Section *sec;

if (key == NULL((void*)0))
return NULL((void*)0);

p = strchr (key, '/');
if (p == NULL((void*)0))
return NULL((void*)0);

name = g_strndup (key, p - key);

sec = find_section (item, name);

g_free (name);

return sec;
972}

974static const char *
975key_basename (const char *key)
976{
char *p = strrchr (key, '/');
if (p != NULL((void*)0))
return p+1;
else
return key;
982}


985static const char *
986lookup (const CafeDesktopItem *item, const char *key)
987{
return g_hash_table_lookup (item->main_hash, key);
989}

991static const char *
992lookup_locale (const CafeDesktopItem *item, const char *key, const char *locale)
993{
if (locale == NULL((void*)0) ||
   strcmp (locale, "C") == 0) {
return lookup (item, key);
} else {
const char *ret;
char *full = g_strdup_printf ("%s[%s]", key, locale);
ret = lookup (item, full);
g_free (full);
return ret;
}
1004}

1006static const char *
1007lookup_best_locale (const CafeDesktopItem *item, const char *key)
1008{
const char * const *langs_pointer;
int                 i;

langs_pointer = g_get_language_names ();
for (i = 0; langs_pointer[i] != NULL((void*)0); i++) {
const char *ret = NULL((void*)0);

ret = lookup_locale (item, key, langs_pointer[i]);
if (ret != NULL((void*)0))
	return ret;
}

return NULL((void*)0);
1022}

1024static void
1025set (CafeDesktopItem *item, const char *key, const char *value)
1026{
Section *sec = section_from_key (item, key);

if (sec != NULL((void*)0)) {
if (value != NULL((void*)0)) {
	if (g_hash_table_lookup (item->main_hash, key) == NULL((void*)0))
		sec->keys = g_list_append
			(sec->keys,
			 g_strdup (key_basename (key))g_strdup_inline (key_basename (key)));

	g_hash_table_replace (item->main_hash,
			      g_strdup (key)g_strdup_inline (key),
			      g_strdup (value)g_strdup_inline (value));
} else {
	GList *list = g_list_find_custom
		(sec->keys, key_basename (key),
		 (GCompareFunc)strcmp);
	if (list != NULL((void*)0)) {
		g_free (list->data);
		sec->keys =
			g_list_delete_link (sec->keys, list);
	}
	g_hash_table_remove (item->main_hash, key);
}
} else {
if (value != NULL((void*)0)) {
	if (g_hash_table_lookup (item->main_hash, key) == NULL((void*)0))
		item->keys = g_list_append (item->keys,
					    g_strdup (key)g_strdup_inline (key));

	g_hash_table_replace (item->main_hash,
			      g_strdup (key)g_strdup_inline (key),
			      g_strdup (value)g_strdup_inline (value));
} else {
	GList *list = g_list_find_custom
		(item->keys, key, (GCompareFunc)strcmp);
	if (list != NULL((void*)0)) {
		g_free (list->data);
		item->keys =
			g_list_delete_link (item->keys, list);
	}
	g_hash_table_remove (item->main_hash, key);
}
}
item->modified = TRUE(!(0));
1071}

1073static void
1074set_locale (CafeDesktopItem *item, const char *key,
   const char *locale, const char *value)
1076{
if (locale == NULL((void*)0) ||
   strcmp (locale, "C") == 0) {
set (item, key, value);
} else {
char *full = g_strdup_printf ("%s[%s]", key, locale);
set (item, full, value);
g_free (full);

/* add the locale to the list of languages if it wasn't there
 * before */
if (g_list_find_custom (item->languages, locale,
			(GCompareFunc)strcmp) == NULL((void*)0))
	item->languages = g_list_prepend (item->languages,
					  g_strdup (locale)g_strdup_inline (locale));
}
1092}

1094static char **
1095list_to_vector (GSList *list)
1096{
int len = g_slist_length (list);
char **argv;
int i;
GSList *li;

argv = g_new0 (char *, len+1)((char * *) g_malloc0_n ((len+1), sizeof (char *)));

for (i = 0, li = list;
    li != NULL((void*)0);
    li = li->next, i++) {
argv[i] = g_strdup (li->data)g_strdup_inline (li->data);
}
argv[i] = NULL((void*)0);

return argv;
1112}

1114static GSList *
1115make_args (GList *files)
1116{
GSList *list = NULL((void*)0);
GList *li;

for (li = files; li != NULL((void*)0); li = li->next) {
GFile *gfile;
const char *file = li->data;
if (file == NULL((void*)0))
	continue;
gfile = g_file_new_for_uri (file);
list = g_slist_prepend (list, gfile);
}

return g_slist_reverse (list);
1130}

1132static void
1133free_args (GSList *list)
1134{
GSList *li;

for (li = list; li != NULL((void*)0); li = li->next) {
g_object_unref (G_FILE (li->data)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((li->data)), ((g_file_get_type ())))))));
li->data = NULL((void*)0);
}
g_slist_free (list);
1142}

1144static char *
1145escape_single_quotes (const char *s,
      gboolean in_single_quotes,
      gboolean in_double_quotes)
1148{
const char *p;
GString *gs;
const char *pre = "";
const char *post = "";

if ( ! in_single_quotes && ! in_double_quotes) {
pre = "'";
post = "'";
} else if ( ! in_single_quotes && in_double_quotes) {
pre = "\"'";
post = "'\"";
}

if (strchr (s, '\'') == NULL((void*)0)) {
return g_strconcat (pre, s, post, NULL((void*)0));
}

gs = g_string_new (pre);

for (p = s; *p != '\0'; p++) {
if (*p == '\'')
	g_string_append (gs, "'\\''")(__builtin_constant_p ("'\\''") ? __extension__ ({ const char
 * const __val = ("'\\''"); g_string_append_len_inline (gs, __val
, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !(__val
))) : (gssize) -1); }) : g_string_append_len_inline (gs, "'\\''"
, (gssize) -1));
else
	g_string_append_c (gs, *p)g_string_append_c_inline (gs, *p);
}

g_string_append (gs, post)(__builtin_constant_p (post) ? __extension__ ({ const char * const
 __val = (post); g_string_append_len_inline (gs, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (gs, post, (gssize) -1
));

return g_string_free (gs, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((gs),
 ((0))) : g_string_free_and_steal (gs)) : (g_string_free) ((gs
), ((0))));
1178}

1180typedef enum {
URI_TO_STRING,
URI_TO_LOCAL_PATH,
URI_TO_LOCAL_DIRNAME,
URI_TO_LOCAL_BASENAME
1185} ConversionType;

1187static char *
1188convert_uri (GFile          *file,
    ConversionType  conversion)
1190{
char *retval = NULL((void*)0);

switch (conversion) {
case URI_TO_STRING:
retval = g_file_get_uri (file);
break;
case URI_TO_LOCAL_PATH:
retval = g_file_get_path (file);
break;
case URI_TO_LOCAL_DIRNAME:
{
	char *local_path;

	local_path = g_file_get_path (file);
	retval = g_path_get_dirname (local_path);
	g_free (local_path);
}
break;
case URI_TO_LOCAL_BASENAME:
retval = g_file_get_basename (file);
break;
default:
g_assert_not_reached ()do { g_assertion_message_expr ("CafeDesktop", "cafe-desktop-item.c"
, 1213, ((const char*) (__func__)), ((void*)0)); } while (0);
}

return retval;
1217}

1219typedef enum {
ADDED_NONE = 0,
ADDED_SINGLE,
ADDED_ALL
1223} AddedStatus;

1225static AddedStatus
1226append_all_converted (GString        *str,
      ConversionType  conversion,
      GSList         *args,
      gboolean        in_single_quotes,
      gboolean        in_double_quotes,
      AddedStatus     added_status G_GNUC_UNUSED__attribute__ ((__unused__)))
1232{
GSList *l;

for (l = args; l; l = l->next) {
char *converted;
char *escaped;

if (!(converted = convert_uri (l->data, conversion)))
	continue;

g_string_append (str, " ")(__builtin_constant_p (" ") ? __extension__ ({ const char * const
 __val = (" "); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, " ", (gssize) -1
));

escaped = escape_single_quotes (converted,
				in_single_quotes,
				in_double_quotes);
g_string_append (str, escaped)(__builtin_constant_p (escaped) ? __extension__ ({ const char
 * const __val = (escaped); g_string_append_len_inline (str, __val
, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !(__val
))) : (gssize) -1); }) : g_string_append_len_inline (str, escaped
, (gssize) -1));

g_free (escaped);
g_free (converted);
}

return ADDED_ALL;
1254}

1256static AddedStatus
1257append_first_converted (GString         *str,
	ConversionType   conversion,
	GSList         **arg_ptr,
	gboolean         in_single_quotes,
	gboolean         in_double_quotes,
	AddedStatus      added_status)
1263{
GSList *l;
char   *converted = NULL((void*)0);
char   *escaped;

for (l = *arg_ptr; l; l = l->next) {
if ((converted = convert_uri (l->data, conversion)))
	break;

*arg_ptr = l->next;
}

if (!converted)
return added_status;

escaped = escape_single_quotes (converted, in_single_quotes, in_double_quotes);
g_string_append (str, escaped)(__builtin_constant_p (escaped) ? __extension__ ({ const char
 * const __val = (escaped); g_string_append_len_inline (str, __val
, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !(__val
))) : (gssize) -1); }) : g_string_append_len_inline (str, escaped
, (gssize) -1));
g_free (escaped);
g_free (converted);

return added_status != ADDED_ALL ? ADDED_SINGLE : added_status;
1284}

1286static gboolean
1287do_percent_subst (const CafeDesktopItem  *item,
  const char              *arg,
  GString                 *str,
  gboolean                 in_single_quotes,
  gboolean                 in_double_quotes,
  GSList                  *args,
  GSList                 **arg_ptr,
  AddedStatus             *added_status)
1295{
char *esc;
const char *cs;

if (arg[0] != '%' || arg[1] == '\0') {
return FALSE(0);
}

switch (arg[1]) {
case '%':
g_string_append_c (str, '%')g_string_append_c_inline (str, '%');
break;
case 'U':
*added_status = append_all_converted (str,
				      URI_TO_STRING,
				      args,
				      in_single_quotes,
				      in_double_quotes,
				      *added_status);
break;
case 'F':
*added_status = append_all_converted (str,
				      URI_TO_LOCAL_PATH,
				      args,
				      in_single_quotes,
				      in_double_quotes,
				      *added_status);
break;
case 'N':
*added_status = append_all_converted (str,
				      URI_TO_LOCAL_BASENAME,
				      args,
				      in_single_quotes,
				      in_double_quotes,
				      *added_status);
break;
case 'D':
*added_status = append_all_converted (str,
				      URI_TO_LOCAL_DIRNAME,
				      args,
				      in_single_quotes,
				      in_double_quotes,
				      *added_status);
break;
case 'f':
*added_status = append_first_converted (str,
					URI_TO_LOCAL_PATH,
					arg_ptr,
					in_single_quotes,
					in_double_quotes,
					*added_status);
break;
case 'u':
*added_status = append_first_converted (str,
					URI_TO_STRING,
					arg_ptr,
					in_single_quotes,
					in_double_quotes,
					*added_status);
break;
case 'd':
*added_status = append_first_converted (str,
					URI_TO_LOCAL_DIRNAME,
					arg_ptr,
					in_single_quotes,
					in_double_quotes,
					*added_status);
break;
case 'n':
*added_status = append_first_converted (str,
					URI_TO_LOCAL_BASENAME,
					arg_ptr,
					in_single_quotes,
					in_double_quotes,
					*added_status);
break;
case 'm':
/* Note: v0.9.4 of the spec says this is deprecated
 * and replace with --miniicon iconname */
cs = cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_MINI_ICON"MiniIcon");
if (cs != NULL((void*)0)) {
	g_string_append (str, "--miniicon=")(__builtin_constant_p ("--miniicon=") ? __extension__ ({ const
 char * const __val = ("--miniicon="); g_string_append_len_inline
 (str, __val, (__val != ((void*)0)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (str, "--miniicon=", (gssize) -1));
	esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
	g_string_append (str, esc)(__builtin_constant_p (esc) ? __extension__ ({ const char * const
 __val = (esc); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, esc, (gssize) -1
));
}
break;
case 'i':
/* Note: v0.9.4 of the spec says replace with --icon iconname */
cs = cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_ICON"Icon");
if (cs != NULL((void*)0)) {
	g_string_append (str, "--icon=")(__builtin_constant_p ("--icon=") ? __extension__ ({ const char
 * const __val = ("--icon="); g_string_append_len_inline (str
, __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !
(__val))) : (gssize) -1); }) : g_string_append_len_inline (str
, "--icon=", (gssize) -1));
	esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
	g_string_append (str, esc)(__builtin_constant_p (esc) ? __extension__ ({ const char * const
 __val = (esc); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, esc, (gssize) -1
));
}
break;
case 'c':
cs = cafe_desktop_item_get_localestring (item, CAFE_DESKTOP_ITEM_NAME"Name");
if (cs != NULL((void*)0)) {
	esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
	g_string_append (str, esc)(__builtin_constant_p (esc) ? __extension__ ({ const char * const
 __val = (esc); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, esc, (gssize) -1
));
	g_free (esc);
}
break;
case 'k':
if (item->location != NULL((void*)0)) {
	esc = escape_single_quotes (item->location, in_single_quotes, in_double_quotes);
	g_string_append (str, esc)(__builtin_constant_p (esc) ? __extension__ ({ const char * const
 __val = (esc); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, esc, (gssize) -1
));
	g_free (esc);
}
break;
case 'v':
cs = cafe_desktop_item_get_localestring (item, CAFE_DESKTOP_ITEM_DEV"Dev");
if (cs != NULL((void*)0)) {
	esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
	g_string_append (str, esc)(__builtin_constant_p (esc) ? __extension__ ({ const char * const
 __val = (esc); g_string_append_len_inline (str, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (str, esc, (gssize) -1
));
	g_free (esc);
}
break;
default:
/* Maintain special characters - e.g. "%20" */
if (g_ascii_isdigit (arg [1])((g_ascii_table[(guchar) (arg [1])] & G_ASCII_DIGIT) != 0
))
	g_string_append_c (str, '%')g_string_append_c_inline (str, '%');
return FALSE(0);
}

return TRUE(!(0));
1421}

1423static char *
1424expand_string (const CafeDesktopItem  *item,
      const char              *s,
      GSList                  *args,
      GSList                 **arg_ptr,
      AddedStatus             *added_status)
1429{
const char *p;
gboolean escape = FALSE(0);
gboolean single_quot = FALSE(0);
gboolean double_quot = FALSE(0);
GString *gs = g_string_new (NULL((void*)0));

for (p = s; *p != '\0'; p++) {
if (escape) {
	escape = FALSE(0);
	g_string_append_c (gs, *p)g_string_append_c_inline (gs, *p);
} else if (*p == '\\') {
	if ( ! single_quot)
		escape = TRUE(!(0));
	g_string_append_c (gs, *p)g_string_append_c_inline (gs, *p);
} else if (*p == '\'') {
	g_string_append_c (gs, *p)g_string_append_c_inline (gs, *p);
	if ( ! single_quot && ! double_quot) {
		single_quot = TRUE(!(0));
	} else if (single_quot) {
		single_quot = FALSE(0);
	}
} else if (*p == '"') {
	g_string_append_c (gs, *p)g_string_append_c_inline (gs, *p);
	if ( ! single_quot && ! double_quot) {
		double_quot = TRUE(!(0));
	} else if (double_quot) {
		double_quot = FALSE(0);
	}
} else if (*p == '%') {
	if (do_percent_subst (item, p, gs,
			      single_quot, double_quot,
			      args, arg_ptr,
			      added_status)) {
		p++;
	}
} else {
	g_string_append_c (gs, *p)g_string_append_c_inline (gs, *p);
}
}
return g_string_free (gs, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((gs),
 ((0))) : g_string_free_and_steal (gs)) : (g_string_free) ((gs
), ((0))));
1470}

1472#ifdef HAVE_STARTUP_NOTIFICATION
1473static void
1474sn_error_trap_push (SnDisplay *display G_GNUC_UNUSED__attribute__ ((__unused__)),
    Display   *xdisplay G_GNUC_UNUSED__attribute__ ((__unused__)))
1476{
CdkDisplay *cdkdisplay;

cdkdisplay = cdk_display_get_default ();
cdk_x11_display_error_trap_push (cdkdisplay);
1481}

1483static void
1484sn_error_trap_pop (SnDisplay *display G_GNUC_UNUSED__attribute__ ((__unused__)),
   Display   *xdisplay G_GNUC_UNUSED__attribute__ ((__unused__)))
1486{
CdkDisplay *cdkdisplay;

cdkdisplay = cdk_display_get_default ();
cdk_x11_display_error_trap_pop_ignored (cdkdisplay);
1491}

1493static char **
1494make_spawn_environment_for_sn_context (SnLauncherContext *sn_context,
		       char             **envp)
1496{
char **retval;
char **freeme;
int    i, j;
int    desktop_startup_id_len;

retval = freeme = NULL((void*)0);

if (envp == NULL((void*)0)) {
envp = freeme = g_listenv ();
for (i = 0; envp[i]; i++) {
	char *name = envp[i];

	envp[i] = g_strjoin ("=", name, g_getenv (name), NULL((void*)0));
	g_free (name);
}
} else {
for (i = 0; envp[i]; i++)
	;
}

retval = g_new (char *, i + 2)((char * *) g_malloc_n ((i + 2), sizeof (char *)));

desktop_startup_id_len = strlen ("DESKTOP_STARTUP_ID");

for (i = 0, j = 0; envp[i]; i++) {
if (strncmp (envp[i], "DESKTOP_STARTUP_ID", desktop_startup_id_len) != 0) {
	retval[j] = g_strdup (envp[i])g_strdup_inline (envp[i]);
	++j;
       }
}

retval[j] = g_strdup_printf ("DESKTOP_STARTUP_ID=%s",
		     sn_launcher_context_get_startup_id (sn_context));
++j;
retval[j] = NULL((void*)0);

g_strfreev (freeme);

return retval;
1536}

1538/* This should be fairly long, as it's confusing to users if a startup
* ends when it shouldn't (it appears that the startup failed, and
* they have to relaunch the app). Also the timeout only matters when
* there are bugs and apps don't end their own startup sequence.
*
* This timeout is a "last resort" timeout that ignores whether the
* startup sequence has shown activity or not.  Croma and the
* tasklist have smarter, and correspondingly able-to-be-shorter
* timeouts. The reason our timeout is dumb is that we don't monitor
* the sequence (don't use an SnMonitorContext)
*/
1549#define STARTUP_TIMEOUT_LENGTH_SEC30 30 /* seconds */
1550#define STARTUP_TIMEOUT_LENGTH(30 * 1000) (STARTUP_TIMEOUT_LENGTH_SEC30 * 1000)

1552typedef struct
1553{
CdkScreen *screen;
GSList *contexts;
guint timeout_id;
1557} StartupTimeoutData;

1559static void
1560free_startup_timeout (void *data)
1561{
StartupTimeoutData *std = data;

g_slist_foreach (std->contexts,
	 (GFunc) sn_launcher_context_unref,
	 NULL((void*)0));
g_slist_free (std->contexts);

if (std->timeout_id != 0) {
g_source_remove (std->timeout_id);
std->timeout_id = 0;
}

g_free (std);
1575}

1577static gboolean
1578startup_timeout (void *data)
1579{
StartupTimeoutData *std = data;
GSList *tmp;
int min_timeout;

min_timeout = STARTUP_TIMEOUT_LENGTH(30 * 1000);
gint64 now = g_get_real_time ();

tmp = std->contexts;
while (tmp != NULL((void*)0)) {
SnLauncherContext *sn_context = tmp->data;
GSList *next = tmp->next;
double elapsed;
time_t tv_sec;
suseconds_t tv_usec;
gint64 tv;

sn_launcher_context_get_last_active_time (sn_context, &tv_sec, &tv_usec);
tv = (tv_sec * G_USEC_PER_SEC1000000) + tv_usec;
elapsed = (double) (now - tv) / 1000.0;

if (elapsed >= STARTUP_TIMEOUT_LENGTH(30 * 1000)) {
	std->contexts = g_slist_remove (std->contexts,
					sn_context);
	sn_launcher_context_complete (sn_context);
	sn_launcher_context_unref (sn_context);
} else {
	min_timeout = MIN (min_timeout, (STARTUP_TIMEOUT_LENGTH - elapsed))(((min_timeout) < (((30 * 1000) - elapsed))) ? (min_timeout
) : (((30 * 1000) - elapsed)));
}

tmp = next;
}

/* we'll use seconds for the timeout */
if (min_timeout < 1000)
min_timeout = 1000;

if (std->contexts == NULL((void*)0)) {
std->timeout_id = 0;
} else {
std->timeout_id = g_timeout_add_seconds (min_timeout / 1000,
					 startup_timeout,
					 std);
}

/* always remove this one, but we may have reinstalled another one. */
return FALSE(0);
1626}

1628static void
1629add_startup_timeout (CdkScreen         *screen,
     SnLauncherContext *sn_context)
1631{
StartupTimeoutData *data;

data = g_object_get_data (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "cafe-startup-data");
if (data == NULL((void*)0)) {
data = g_new (StartupTimeoutData, 1)((StartupTimeoutData *) g_malloc_n ((1), sizeof (StartupTimeoutData
)));
data->screen = screen;
data->contexts = NULL((void*)0);
data->timeout_id = 0;

g_object_set_data_full (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "cafe-startup-data",
			data, free_startup_timeout);
}

sn_launcher_context_ref (sn_context);
data->contexts = g_slist_prepend (data->contexts, sn_context);

if (data->timeout_id == 0) {
data->timeout_id = g_timeout_add_seconds (
				STARTUP_TIMEOUT_LENGTH_SEC30,
				startup_timeout,
				data);
}
1654}
1655#endif /* HAVE_STARTUP_NOTIFICATION */

1657static inline char *
1658stringify_uris (GSList *args)
1659{
GString *str;

str = g_string_new (NULL((void*)0));

append_all_converted (str, URI_TO_STRING, args, FALSE(0), FALSE(0), ADDED_NONE);

return g_string_free (str, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((str)
, ((0))) : g_string_free_and_steal (str)) : (g_string_free) (
(str), ((0))));
1667}

1669static inline char *
1670stringify_files (GSList *args)
1671{
GString *str;

str = g_string_new (NULL((void*)0));

append_all_converted (str, URI_TO_LOCAL_PATH, args, FALSE(0), FALSE(0), ADDED_NONE);

return g_string_free (str, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((str)
, ((0))) : g_string_free_and_steal (str)) : (g_string_free) (
(str), ((0))));
1679}

1681static char **
1682make_environment_for_screen (CdkScreen  *screen,
	     char      **envp)
1684{
CdkDisplay *display;
char      **retval;
char      **freeme;
char       *display_name;
int         display_index = -1;
int         i, env_len;

g_return_val_if_fail (CDK_IS_SCREEN (screen), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((screen)); GType __t = ((cdk_screen_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("CafeDesktop", ((const char
*) (__func__)), "CDK_IS_SCREEN (screen)"); return (((void*)0)
); } } while (0);

retval = freeme = NULL((void*)0);

if (envp == NULL((void*)0)) {
envp = freeme = g_listenv ();
for (i = 0; envp [i]; i++) {
	char *name = envp[i];

	envp[i] = g_strjoin ("=", name, g_getenv (name), NULL((void*)0));
	g_free (name);
}
}

for (env_len = 0; envp [env_len]; env_len++)
if (strncmp (envp [env_len], "DISPLAY", strlen ("DISPLAY")) == 0)
	display_index = env_len;

retval = g_new (char *, env_len + 1)((char * *) g_malloc_n ((env_len + 1), sizeof (char *)));
retval [env_len] = NULL((void*)0);

display = cdk_screen_get_display (screen);
display_name = g_strdup (cdk_display_get_name (display))g_strdup_inline (cdk_display_get_name (display));

for (i = 0; i < env_len; i++)
if (i == display_index)
	retval [i] = g_strconcat ("DISPLAY=", display_name, NULL((void*)0));
else
	retval [i] = g_strdup (envp[i])g_strdup_inline (envp[i]);

g_assert (i == env_len)do { if (i == env_len) ; else g_assertion_message_expr ("CafeDesktop"
, "cafe-desktop-item.c", 1722, ((const char*) (__func__)), "i == env_len"
); } while (0);

g_free (display_name);
g_strfreev (freeme);

return retval;
1728}

1730static void
1731dummy_child_watch (GPid     pid G_GNUC_UNUSED__attribute__ ((__unused__)),
   gint     status G_GNUC_UNUSED__attribute__ ((__unused__)),
   gpointer user_data G_GNUC_UNUSED__attribute__ ((__unused__)))
1734{
/* Nothing, this is just to ensure we don't double fork
* and break pkexec:
* https://bugzilla.gnome.org/show_bug.cgi?id=675789
*/
1739}

1741static int
1742ditem_execute (const CafeDesktopItem *item,
      const char *exec,
      GList *file_list,
      CdkScreen *screen,
      int workspace,
             char **envp,
      gboolean launch_only_one,
      gboolean use_current_dir,
      gboolean append_uris,
      gboolean append_paths,
      gboolean do_not_reap_child,
      GError **error)
1754{
char **free_me = NULL((void*)0);
int i, ret;
char **term_argv = NULL((void*)0);
int term_argc = 0;
GSList *args, *arg_ptr;
AddedStatus added_status;
const char *working_dir = NULL((void*)0);
char **temp_argv = NULL((void*)0);
int temp_argc = 0;
char *uris, *temp;
char *exec_locale;
int launched = 0;
GPid pid;
1768#ifdef HAVE_STARTUP_NOTIFICATION
CdkDisplay *cdkdisplay;
SnLauncherContext *sn_context;
SnDisplay *sn_display;
const char *startup_class;
1773#endif

g_return_val_if_fail (item, -1)do { if ((item)) { } else { g_return_if_fail_warning ("CafeDesktop"
, ((const char*) (__func__)), "item"); return (-1); } } while
 (0);

if (item->type == CAFE_DESKTOP_ITEM_TYPE_APPLICATION) {
working_dir = cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_PATH"Path");
if (working_dir &&
    !g_file_test (working_dir, G_FILE_TEST_IS_DIR))
	working_dir = NULL((void*)0);
}

if (working_dir == NULL((void*)0) && !use_current_dir)
working_dir = g_get_home_dir ();

if (cafe_desktop_item_get_boolean (item, CAFE_DESKTOP_ITEM_TERMINAL"Terminal")) {
const char *options =
	cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_TERMINAL_OPTIONS"TerminalOptions");

if (options != NULL((void*)0)) {
	g_shell_parse_argv (options,
			    &term_argc,
			    &term_argv,
			    NULL((void*)0) /* error */);
	/* ignore errors */
}

cafe_desktop_prepend_terminal_to_vector (&term_argc, &term_argv);
}

args = make_args (file_list);
arg_ptr = make_args (file_list);

1805#ifdef HAVE_STARTUP_NOTIFICATION
if (screen)
cdkdisplay = cdk_screen_get_display (screen);
else
cdkdisplay = cdk_display_get_default ();

sn_display = sn_display_new (CDK_DISPLAY_XDISPLAY (cdkdisplay)(cdk_x11_display_get_xdisplay (cdkdisplay)),
		     sn_error_trap_push,
		     sn_error_trap_pop);


/* Only initiate notification if desktop file supports it.
* (we could avoid setting up the SnLauncherContext if we aren't going
* to initiate, but why bother)
*/

startup_class = cafe_desktop_item_get_string (item,
				       "StartupWMClass");
if (startup_class ||
   cafe_desktop_item_get_boolean (item, "StartupNotify")) {
const char *name;
const char *icon;

sn_context = sn_launcher_context_new (sn_display,
				      screen ? cdk_x11_screen_get_screen_number (screen) :
				      DefaultScreen (CDK_DISPLAY_XDISPLAY (cdkdisplay))(((_XPrivDisplay)((cdk_x11_display_get_xdisplay (cdkdisplay))
))->default_screen));

name = cafe_desktop_item_get_localestring (item,
					    CAFE_DESKTOP_ITEM_NAME"Name");

if (name == NULL((void*)0))
	name = cafe_desktop_item_get_localestring (item,
						    CAFE_DESKTOP_ITEM_GENERIC_NAME"GenericName");

if (name != NULL((void*)0)) {
	char *description;

	sn_launcher_context_set_name (sn_context, name);

	description = g_strdup_printf (_("Starting %s")((char *) g_dgettext ("cafe-desktop", "Starting %s")), name);

	sn_launcher_context_set_description (sn_context, description);

	g_free (description);
}

icon = cafe_desktop_item_get_string (item,
				      CAFE_DESKTOP_ITEM_ICON"Icon");

if (icon != NULL((void*)0))
	sn_launcher_context_set_icon_name (sn_context, icon);

sn_launcher_context_set_workspace (sn_context, workspace);

if (startup_class != NULL((void*)0))
	sn_launcher_context_set_wmclass (sn_context,
					 startup_class);
} else {
sn_context = NULL((void*)0);
}
1865#endif

if (screen) {
envp = make_environment_for_screen (screen, envp);
if (free_me)
	g_strfreev (free_me);
free_me = envp;
}

exec_locale = g_filename_from_utf8 (exec, -1, NULL((void*)0), NULL((void*)0), NULL((void*)0));

if (exec_locale == NULL((void*)0)) {
exec_locale = g_strdup ("")g_strdup_inline ("");
}

do {
char **real_argv;
char *new_exec;
GSList *vector_list;

added_status = ADDED_NONE;
new_exec = expand_string (item,
			  exec_locale,
			  args, &arg_ptr, &added_status);

if (launched == 0 && added_status == ADDED_NONE && append_uris) {
	uris = stringify_uris (args);
	temp = g_strconcat (new_exec, " ", uris, NULL((void*)0));
	g_free (uris);
	g_free (new_exec);
	new_exec = temp;
	added_status = ADDED_ALL;
}

/* append_uris and append_paths are mutually exlusive */
if (launched == 0 && added_status == ADDED_NONE && append_paths) {
	uris = stringify_files (args);
	temp = g_strconcat (new_exec, " ", uris, NULL((void*)0));
	g_free (uris);
	g_free (new_exec);
	new_exec = temp;
	added_status = ADDED_ALL;
}

if (launched > 0 && added_status == ADDED_NONE) {
	g_free (new_exec);
	break;
}

if ( ! g_shell_parse_argv (new_exec,
			   &temp_argc, &temp_argv, error)) {
	/* The error now comes from g_shell_parse_argv */
	g_free (new_exec);
	ret = -1;
	break;
}
g_free (new_exec);

vector_list = NULL((void*)0);
for(i = 0; i < term_argc; i++)
	vector_list = g_slist_append (vector_list,
				      g_strdup (term_argv[i])g_strdup_inline (term_argv[i]));

for(i = 0; i < temp_argc; i++)
	vector_list = g_slist_append (vector_list,
				      g_strdup (temp_argv[i])g_strdup_inline (temp_argv[i]));

g_strfreev (temp_argv);

real_argv = list_to_vector (vector_list);
g_slist_foreach (vector_list, (GFunc)g_free, NULL((void*)0));
g_slist_free (vector_list);

1938#ifdef HAVE_STARTUP_NOTIFICATION
if (sn_context != NULL((void*)0) &&
    !sn_launcher_context_get_initiated (sn_context)) {
	guint32 launch_time;

	/* This means that we always use the first real_argv[0]
	 * we select for the "binary name", but it's probably
	 * OK to do that. Binary name isn't super-important
	 * anyway, and we can't initiate twice, and we
	 * must initiate prior to fork/exec.
	 */

	sn_launcher_context_set_binary_name (sn_context,
					     real_argv[0]);

	if (item->launch_time > 0)
		launch_time = item->launch_time;
	else
		launch_time = cdk_x11_display_get_user_time (cdkdisplay);

	sn_launcher_context_initiate (sn_context,
				      g_get_prgname () ? g_get_prgname () : "unknown",
				      real_argv[0],
				      launch_time);

	/* Don't allow accidental reuse of same timestamp */
	((CafeDesktopItem *)item)->launch_time = 0;

	envp = make_spawn_environment_for_sn_context (sn_context, envp);
	if (free_me)
		g_strfreev (free_me);
	free_me = envp;
}
1971#endif


if ( ! g_spawn_async (working_dir,
		      real_argv,
		      envp,
		      (do_not_reap_child ? G_SPAWN_DO_NOT_REAP_CHILD : 0) | G_SPAWN_SEARCH_PATH /* flags */,
		      NULL((void*)0), /* child_setup_func */
		      NULL((void*)0), /* child_setup_func_data */
		      (do_not_reap_child ? &pid : NULL((void*)0)) /* child_pid */,
		      error)) {
	/* The error was set for us,
	 * we just can't launch this thingie */
	ret = -1;
	g_strfreev (real_argv);
	break;
} else if (do_not_reap_child) {
	g_child_watch_add (pid, dummy_child_watch, NULL((void*)0));
}

launched ++;

g_strfreev (real_argv);

if (arg_ptr != NULL((void*)0))
	arg_ptr = arg_ptr->next;

/* rinse, repeat until we run out of arguments (That
* is if we were adding singles anyway) */
} while (added_status == ADDED_SINGLE &&
 arg_ptr != NULL((void*)0) &&
 ! launch_only_one);

g_free (exec_locale);
2005#ifdef HAVE_STARTUP_NOTIFICATION
if (sn_context != NULL((void*)0)) {
if (ret < 0)
	sn_launcher_context_complete (sn_context); /* end sequence */
else
	add_startup_timeout (screen ? screen :
			     cdk_display_get_default_screen (cdk_display_get_default ()),
			     sn_context);
sn_launcher_context_unref (sn_context);
}

sn_display_unref (sn_display);
2017#endif /* HAVE_STARTUP_NOTIFICATION */

free_args (args);

if (term_argv)
g_strfreev (term_argv);

if (free_me)
g_strfreev (free_me);

return ret;
2028}

2030/* strip any trailing &, return FALSE if bad things happen and
 we end up with an empty string */
2032static gboolean
2033strip_the_amp (char *exec)
2034{
size_t exec_len;

g_strstrip (exec)g_strchomp (g_strchug (exec));
if (*exec == '\0')
return FALSE(0);

exec_len = strlen (exec);
/* kill any trailing '&' */
if (exec[exec_len-1] == '&') {
exec[exec_len-1] = '\0';
g_strchomp (exec);
}

/* can't exactly launch an empty thing */
if (*exec == '\0')
return FALSE(0);

return TRUE(!(0));
2053}


2056static int
2057cafe_desktop_item_launch_on_screen_with_env (
const CafeDesktopItem       *item,
GList                        *file_list,
CafeDesktopItemLaunchFlags   flags,
CdkScreen                    *screen,
int                           workspace,
char                        **envp,
GError                      **error)
2065{
const char *exec;
char *the_exec;
int ret;

exec = cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_EXEC"Exec");
/* This is a URL, so launch it as a url */
if (item->type == CAFE_DESKTOP_ITEM_TYPE_LINK) {
const char *url;
gboolean    retval;

url = cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_URL"URL");
/* Cafe panel used to put this in Exec */
if (!(url && url[0] != '\0'))
	url = exec;

if (!(url && url[0] != '\0')) {
	g_set_error (error,
		     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
		     CAFE_DESKTOP_ITEM_ERROR_NO_URL,
		     _("No URL to launch")((char *) g_dgettext ("cafe-desktop", "No URL to launch")));
	return -1;
}

retval = ctk_show_uri_on_window  (NULL((void*)0),
                                  url,
                                  CDK_CURRENT_TIME0L,
                                  error);
return retval ? 0 : -1;
}

/* check the type, if there is one set */
if (item->type != CAFE_DESKTOP_ITEM_TYPE_APPLICATION) {
g_set_error (error,
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_NOT_LAUNCHABLE,
	     _("Not a launchable item")((char *) g_dgettext ("cafe-desktop", "Not a launchable item"
)));
return -1;
}


if (exec == NULL((void*)0) ||
   exec[0] == '\0') {
g_set_error (error,
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_NO_EXEC_STRING,
	     _("No command (Exec) to launch")((char *) g_dgettext ("cafe-desktop", "No command (Exec) to launch"
)));
return -1;
}


/* make a new copy and get rid of spaces */
the_exec = g_alloca (strlen (exec) + 1)__builtin_alloca (strlen (exec) + 1);
g_strlcpy (the_exec, exec, strlen (exec) + 1);

if ( ! strip_the_amp (the_exec)) {
g_set_error (error,
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_BAD_EXEC_STRING,
	     _("Bad command (Exec) to launch")((char *) g_dgettext ("cafe-desktop", "Bad command (Exec) to launch"
)));
return -1;
}

ret = ditem_execute (item, the_exec, file_list, screen, workspace, envp,
	     (flags & CAFE_DESKTOP_ITEM_LAUNCH_ONLY_ONE),
	     (flags & CAFE_DESKTOP_ITEM_LAUNCH_USE_CURRENT_DIR),
	     (flags & CAFE_DESKTOP_ITEM_LAUNCH_APPEND_URIS),
	     (flags & CAFE_DESKTOP_ITEM_LAUNCH_APPEND_PATHS),
	     (flags & CAFE_DESKTOP_ITEM_LAUNCH_DO_NOT_REAP_CHILD),
	     error);

return ret;
2137}

2139/**
* cafe_desktop_item_launch:
* @item: A desktop item
* @file_list:  Files/URIs to launch this item with, can be %NULL
* @flags: FIXME
* @error: FIXME
*
* This function runs the program listed in the specified 'item',
* optionally appending additional arguments to its command line.  It uses
* #g_shell_parse_argv to parse the the exec string into a vector which is
* then passed to #g_spawn_async for execution. This can return all
* the errors from CafeURL, #g_shell_parse_argv and #g_spawn_async,
* in addition to it's own.  The files are
* only added if the entry defines one of the standard % strings in it's
* Exec field.
*
* Returns: The the pid of the process spawned.  If more then one
* process was spawned the last pid is returned.  On error -1
* is returned and @error is set.
*/
2159int
2160cafe_desktop_item_launch (const CafeDesktopItem       *item,
	   GList                        *file_list,
	   CafeDesktopItemLaunchFlags   flags,
	   GError                      **error)
2164{
return cafe_desktop_item_launch_on_screen_with_env (
	item, file_list, flags, NULL((void*)0), -1, NULL((void*)0), error);
2167}

2169/**
* cafe_desktop_item_launch_with_env:
* @item: A desktop item
* @file_list:  Files/URIs to launch this item with, can be %NULL
* @flags: FIXME
* @envp: child's environment, or %NULL to inherit parent's
* @error: FIXME
*
* See cafe_desktop_item_launch for a full description. This function
* additionally passes an environment vector for the child process
* which is to be launched.
*
* Returns: The the pid of the process spawned.  If more then one
* process was spawned the last pid is returned.  On error -1
* is returned and @error is set.
*/
2185int
2186cafe_desktop_item_launch_with_env (const CafeDesktopItem       *item,
		    GList                        *file_list,
		    CafeDesktopItemLaunchFlags   flags,
		    char                        **envp,
		    GError                      **error)
2191{
return cafe_desktop_item_launch_on_screen_with_env (
	item, file_list, flags,
	NULL((void*)0), -1, envp, error);
2195}

2197/**
* cafe_desktop_item_launch_on_screen:
* @item: A desktop item
* @file_list:  Files/URIs to launch this item with, can be %NULL
* @flags: FIXME
* @screen: the %CdkScreen on which the application should be launched
* @workspace: the workspace on which the app should be launched (-1 for current)
* @error: FIXME
*
* See cafe_desktop_item_launch for a full description. This function
* additionally attempts to launch the application on a given screen
* and workspace.
*
* Returns: The the pid of the process spawned.  If more then one
* process was spawned the last pid is returned.  On error -1
* is returned and @error is set.
*/
2214int
2215cafe_desktop_item_launch_on_screen (const CafeDesktopItem       *item,
		     GList                        *file_list,
		     CafeDesktopItemLaunchFlags   flags,
		     CdkScreen                    *screen,
		     int                           workspace,
		     GError                      **error)
2221{
return cafe_desktop_item_launch_on_screen_with_env (
	item, file_list, flags,
	screen, workspace, NULL((void*)0), error);
2225}

2227/**
* cafe_desktop_item_drop_uri_list:
* @item: A desktop item
* @uri_list: text as gotten from a text/uri-list
* @flags: FIXME
* @error: FIXME
*
* A list of files or urls dropped onto an icon, the proper (Url or File)
* exec is run you can pass directly string that you got as the
* text/uri-list.  This just parses the list and calls
*
* Returns: The value returned by #cafe_execute_async() upon execution of
* the specified item or -1 on error.  If multiple instances are run, the
* return of the last one is returned.
*/
2242int
2243cafe_desktop_item_drop_uri_list (const CafeDesktopItem *item,
		  const char *uri_list,
		  CafeDesktopItemLaunchFlags flags,
		  GError **error)
2247{
return cafe_desktop_item_drop_uri_list_with_env (item, uri_list,
					  flags, NULL((void*)0), error);
2250}

2252/**
2253* cafe_desktop_item_drop_uri_list_with_env:
2254* @item: A desktop item
2255* @uri_list: text as gotten from a text/uri-list
2256* @flags: FIXME
2257* @envp: child's environment
2258* @error: FIXME
2259*
2260* See cafe_desktop_item_drop_uri_list for a full description. This function
2261* additionally passes an environment vector for the child process
2262* which is to be launched.
2263*
2264* Returns: The value returned by #cafe_execute_async() upon execution of
2265* the specified item or -1 on error.  If multiple instances are run, the
2266* return of the last one is returned.
2267*/
2268int
2269cafe_desktop_item_drop_uri_list_with_env (const CafeDesktopItem *item,
			   const char *uri_list,
			   CafeDesktopItemLaunchFlags flags,
			   char                        **envp,
			   GError **error)
2274{
int ret;
char  *uri;
char **uris;
GList *list = NULL((void*)0);

uris = g_uri_list_extract_uris (uri_list);

for (uri = uris[0]; uri != NULL((void*)0); uri++) {
list = g_list_prepend (list, uri);
}
list = g_list_reverse (list);

ret =  cafe_desktop_item_launch_with_env (
	item, list, flags, envp, error);

g_strfreev (uris);
g_list_free (list);

return ret;
2294}

2296static gboolean
2297exec_exists (const char *exec)
2298{
if (g_path_is_absolute (exec)) {
if (access (exec, X_OK1) == 0)
	return TRUE(!(0));
else
	return FALSE(0);
} else {
char *tryme;

tryme = g_find_program_in_path (exec);
if (tryme != NULL((void*)0)) {
	g_free (tryme);
	return TRUE(!(0));
}
return FALSE(0);
}
2314}

2316/**
* cafe_desktop_item_exists:
* @item: A desktop item
*
* Attempt to figure out if the program that can be executed by this item
* actually exists.  First it tries the TryExec attribute to see if that
* contains a program that is in the path.  Then if there is no such
* attribute, it tries the first word of the Exec attribute.
*
* Returns: A boolean, %TRUE if it exists, %FALSE otherwise.
*/
2327gboolean
2328cafe_desktop_item_exists (const CafeDesktopItem *item)
2329{
const char *try_exec;

g_return_val_if_fail (item != NULL, FALSE)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return ((0)); } } while (0);

try_exec = lookup (item, CAFE_DESKTOP_ITEM_TRY_EXEC"TryExec");

if (try_exec != NULL((void*)0) &&
   ! exec_exists (try_exec)) {
return FALSE(0);
}

if (item->type == CAFE_DESKTOP_ITEM_TYPE_APPLICATION) {
int argc;
char **argv;
const char *exe;
const char *exec;

exec = lookup (item, CAFE_DESKTOP_ITEM_EXEC"Exec");
if (exec == NULL((void*)0))
	return FALSE(0);

if ( ! g_shell_parse_argv (exec, &argc, &argv, NULL((void*)0)))
	return FALSE(0);

if (argc < 1) {
	g_strfreev (argv);
	return FALSE(0);
}

exe = argv[0];

if ( ! exec_exists (exe)) {
	g_strfreev (argv);
	return FALSE(0);
}
g_strfreev (argv);
}

return TRUE(!(0));
2369}

2371/**
* cafe_desktop_item_get_entry_type:
* @item: A desktop item
*
* Gets the type attribute (the 'Type' field) of the item.  This should
* usually be 'Application' for an application, but it can be 'Directory'
* for a directory description.  There are other types available as well.
* The type usually indicates how the desktop item should be handeled and
* how the 'Exec' field should be handeled.
*
* Returns: The type of the specified 'item'. The returned
* memory remains owned by the CafeDesktopItem and should not be freed.
*/
2384CafeDesktopItemType
2385cafe_desktop_item_get_entry_type (const CafeDesktopItem *item)
2386{
g_return_val_if_fail (item != NULL, 0)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (0); } } while (0);
g_return_val_if_fail (item->refcount > 0, 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (0); } } while (0);

return item->type;
2391}

2393void
2394cafe_desktop_item_set_entry_type (CafeDesktopItem *item,
		   CafeDesktopItemType type)
2396{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);

item->type = type;

switch (type) {
case CAFE_DESKTOP_ITEM_TYPE_NULL:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", NULL((void*)0));
break;
case CAFE_DESKTOP_ITEM_TYPE_APPLICATION:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "Application");
break;
case CAFE_DESKTOP_ITEM_TYPE_LINK:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "Link");
break;
case CAFE_DESKTOP_ITEM_TYPE_FSDEVICE:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "FSDevice");
break;
case CAFE_DESKTOP_ITEM_TYPE_MIME_TYPE:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "MimeType");
break;
case CAFE_DESKTOP_ITEM_TYPE_DIRECTORY:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "Directory");
break;
case CAFE_DESKTOP_ITEM_TYPE_SERVICE:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "Service");
break;
case CAFE_DESKTOP_ITEM_TYPE_SERVICE_TYPE:
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "ServiceType");
break;
default:
break;
}
2430}



2434/**
* cafe_desktop_item_get_file_status:
* @item: A desktop item
*
* This function checks the modification time of the on-disk file to
* see if it is more recent than the in-memory data.
*
* Returns: An enum value that specifies whether the item has changed since being loaded.
*/
2443CafeDesktopItemStatus
2444cafe_desktop_item_get_file_status (const CafeDesktopItem *item)
2445{
CafeDesktopItemStatus retval;
GFile *file;
GFileInfo *info;

g_return_val_if_fail (item != NULL, CAFE_DESKTOP_ITEM_DISAPPEARED)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (CAFE_DESKTOP_ITEM_DISAPPEARED); } } while (0);
g_return_val_if_fail (item->refcount > 0, CAFE_DESKTOP_ITEM_DISAPPEARED)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (CAFE_DESKTOP_ITEM_DISAPPEARED); } } while (0);

if (item->location == NULL((void*)0))
return CAFE_DESKTOP_ITEM_DISAPPEARED;

file = g_file_new_for_uri (item->location);
info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified",
		  G_FILE_QUERY_INFO_NONE, NULL((void*)0), NULL((void*)0));

retval = CAFE_DESKTOP_ITEM_UNCHANGED;

if (!g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified"))
retval = CAFE_DESKTOP_ITEM_DISAPPEARED;
else if (item->mtime < g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified"))
retval = CAFE_DESKTOP_ITEM_CHANGED;

g_object_unref (info);
g_object_unref (file);

return retval;
2471}

2473/**
* cafe_desktop_item_find_icon:
* @icon_theme: a #CtkIconTheme
* @icon: icon name, something you'd get out of the Icon key
* @desired_size: FIXME
* @flags: FIXME
*
* Description:  This function goes and looks for the icon file.  If the icon
* is not an absolute filename, this will look for it in the standard places.
* If it can't find the icon, it will return %NULL
*
* Returns: A newly allocated string
*/
2486char *
2487cafe_desktop_item_find_icon (CtkIconTheme *icon_theme,
	      const char  *icon,
	      int          desired_size,
	      int          flags G_GNUC_UNUSED__attribute__ ((__unused__)))
2491{
CtkIconInfo *info;
char *full = NULL((void*)0);

g_return_val_if_fail (icon_theme == NULL ||do { if ((icon_theme == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((icon_theme)); GType __t = ((ctk_icon_theme_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; })))))) { } else { g_return_if_fail_warning ("CafeDesktop"
, ((const char*) (__func__)), "icon_theme == NULL || CTK_IS_ICON_THEME (icon_theme)"
); return (((void*)0)); } } while (0)
	      CTK_IS_ICON_THEME (icon_theme), NULL)do { if ((icon_theme == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((icon_theme)); GType __t = ((ctk_icon_theme_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; })))))) { } else { g_return_if_fail_warning ("CafeDesktop"
, ((const char*) (__func__)), "icon_theme == NULL || CTK_IS_ICON_THEME (icon_theme)"
); return (((void*)0)); } } while (0);

if (icon == NULL((void*)0) || strcmp(icon,"") == 0) {
return NULL((void*)0);
} else if (g_path_is_absolute (icon)) {
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
	return g_strdup (icon)g_strdup_inline (icon);
} else {
	return NULL((void*)0);
}
} else {
char *icon_no_extension;
char *p;

if (icon_theme == NULL((void*)0))
	icon_theme = ctk_icon_theme_get_default ();

icon_no_extension = g_strdup (icon)g_strdup_inline (icon);
p = strrchr (icon_no_extension, '.');
if (p &&
    (strcmp (p, ".png") == 0 ||
     strcmp (p, ".xpm") == 0 ||
     strcmp (p, ".svg") == 0)) {
    *p = 0;
}


info = ctk_icon_theme_lookup_icon (icon_theme,
				   icon_no_extension,
				   desired_size,
				   0);

full = NULL((void*)0);
if (info) {
	full = g_strdup (ctk_icon_info_get_filename (info))g_strdup_inline (ctk_icon_info_get_filename (info));
	g_object_unref (info);
}
g_free (icon_no_extension);
}

return full;

2538}

2540/**
* cafe_desktop_item_get_icon:
* @icon_theme: a #CtkIconTheme
* @item: A desktop item
*
* Description:  This function goes and looks for the icon file.  If the icon
* is not set as an absolute filename, this will look for it in the standard places.
* If it can't find the icon, it will return %NULL
*
* Returns: A newly allocated string
*/
2551char *
2552cafe_desktop_item_get_icon (const CafeDesktopItem *item,
	     CtkIconTheme *icon_theme)
2554{
/* maybe this function should be deprecated in favour of find icon
* -George */
const char *icon;

g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);

icon = cafe_desktop_item_get_string (item, CAFE_DESKTOP_ITEM_ICON"Icon");

return cafe_desktop_item_find_icon (icon_theme, icon,
			     48 /* desired_size */,
			     0 /* flags */);
2567}

2569/**
* cafe_desktop_item_get_location:
* @item: A desktop item
*
* Returns: The file location associated with 'item'.
*
*/
2576const char *
2577cafe_desktop_item_get_location (const CafeDesktopItem *item)
2578{
g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);

return item->location;
2583}

2585/**
* cafe_desktop_item_set_location:
* @item: A desktop item
* @location: A uri string specifying the file location of this particular item.
*
* Set's the 'location' uri of this item.
*/
2592void
2593cafe_desktop_item_set_location (CafeDesktopItem *item, const char *location)
2594{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);

if (item->location != NULL((void*)0) &&
   location != NULL((void*)0) &&
   strcmp (item->location, location) == 0)
return;

g_free (item->location);
item->location = g_strdup (location)g_strdup_inline (location);

/* This is ugly, but useful internally */
if (item->mtime != DONT_UPDATE_MTIME((time_t)-2)) {
item->mtime = 0;

if (item->location) {
	GFile     *file;
	GFileInfo *info;

	file = g_file_new_for_uri (item->location);

	info = g_file_query_info (file,
				  G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified",
				  G_FILE_QUERY_INFO_NONE,
				  NULL((void*)0), NULL((void*)0));
	if (info) {
		if (g_file_info_has_attribute (info,
					       G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified"))
			item->mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified");
		g_object_unref (info);
	}

	g_object_unref (file);
}
}

/* Make sure that save actually saves */
item->modified = TRUE(!(0));
2633}

2635/**
* cafe_desktop_item_set_location_file:
* @item: A desktop item
* @file: A local filename specifying the file location of this particular item.
*
* Set's the 'location' uri of this item to the given @file.
*/
2642void
2643cafe_desktop_item_set_location_file (CafeDesktopItem *item, const char *file)
2644{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);

if (file != NULL((void*)0)) {
GFile *gfile;

gfile = g_file_new_for_path (file);
cafe_desktop_item_set_location_gfile (item, gfile);
g_object_unref (gfile);
} else {
cafe_desktop_item_set_location (item, NULL((void*)0));
}
2657}

2659static void
2660cafe_desktop_item_set_location_gfile (CafeDesktopItem *item, GFile *file)
2661{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);

if (file != NULL((void*)0)) {
char *uri;

uri = g_file_get_uri (file);
cafe_desktop_item_set_location (item, uri);
g_free (uri);
} else {
cafe_desktop_item_set_location (item, NULL((void*)0));
}
2674}

2676/*
* Reading/Writing different sections, NULL is the standard section
*/

2680gboolean
2681cafe_desktop_item_attr_exists (const CafeDesktopItem *item,
		const char *attr)
2683{
g_return_val_if_fail (item != NULL, FALSE)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return ((0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, FALSE)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return ((0)); } } while (0);
g_return_val_if_fail (attr != NULL, FALSE)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return ((0)); } } while (0);

return lookup (item, attr) != NULL((void*)0);
2689}

2691/*
* String type
*/
2694const char *
2695cafe_desktop_item_get_string (const CafeDesktopItem *item,
	       const char *attr)
2697{
g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (attr != NULL, NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return (((void*)0)); } } while (0);

return lookup (item, attr);
2703}

2705void
2706cafe_desktop_item_set_string (CafeDesktopItem *item,
	       const char *attr,
	       const char *value)
2709{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);
g_return_if_fail (attr != NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return; } } while (0);

set (item, attr, value);

if (strcmp (attr, CAFE_DESKTOP_ITEM_TYPE"Type") == 0)
item->type = type_from_string (value);
2718}

2720/*
* LocaleString type
*/
2723const char* cafe_desktop_item_get_localestring(const CafeDesktopItem* item, const char* attr)
2724{
g_return_val_if_fail(item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail(item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);
g_return_val_if_fail(attr != NULL, NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return (((void*)0)); } } while (0);

return lookup_best_locale(item, attr);
2730}

2732const char* cafe_desktop_item_get_localestring_lang(const CafeDesktopItem* item, const char* attr, const char* language)
2733{
g_return_val_if_fail(item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail(item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);
g_return_val_if_fail(attr != NULL, NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return (((void*)0)); } } while (0);

return lookup_locale(item, attr, language);
2739}

2741/**
* cafe_desktop_item_get_string_locale:
* @item: A desktop item
* @attr: An attribute name
*
* Returns the current locale that is used for the given attribute.
* This might not be the same for all attributes. For example, if your
* locale is "en_US.ISO8859-1" but attribute FOO only has "en_US" then
* that would be returned for attr = "FOO". If attribute BAR has
* "en_US.ISO8859-1" then that would be returned for "BAR".
*
* Returns: a string equal to the current locale or NULL
* if the attribute is invalid or there is no matching locale.
*/
2755const char *
2756cafe_desktop_item_get_attr_locale (const CafeDesktopItem *item,
		    const char             *attr)
2758{
const char * const *langs_pointer;
int                 i;

langs_pointer = g_get_language_names ();
for (i = 0; langs_pointer[i] != NULL((void*)0); i++) {
const char *value = NULL((void*)0);

value = lookup_locale (item, attr, langs_pointer[i]);
if (value)
	return langs_pointer[i];
}

return NULL((void*)0);
2772}

2774GList *
2775cafe_desktop_item_get_languages (const CafeDesktopItem *item,
		  const char *attr)
2777{
GList *li;
GList *list = NULL((void*)0);

g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);

for (li = item->languages; li != NULL((void*)0); li = li->next) {
char *language = li->data;
if (attr == NULL((void*)0) ||
    lookup_locale (item, attr, language) != NULL((void*)0)) {
	list = g_list_prepend (list, language);
}
}

return g_list_reverse (list);
2793}

2795static const char *
2796get_language (void)
2797{
const char * const *langs_pointer;
int                 i;

langs_pointer = g_get_language_names ();
for (i = 0; langs_pointer[i] != NULL((void*)0); i++) {
/* find first without encoding  */
if (strchr (langs_pointer[i], '.') == NULL((void*)0)) {
	return langs_pointer[i];
}
}
return NULL((void*)0);
2809}

2811void
2812cafe_desktop_item_set_localestring (CafeDesktopItem *item,
		     const char *attr,
		     const char *value)
2815{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);
g_return_if_fail (attr != NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return; } } while (0);

set_locale (item, attr, get_language (), value);
2821}

2823void
2824cafe_desktop_item_set_localestring_lang (CafeDesktopItem *item,
			  const char *attr,
			  const char *language,
			  const char *value)
2828{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);
g_return_if_fail (attr != NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return; } } while (0);

set_locale (item, attr, language, value);
2834}

2836void
2837cafe_desktop_item_clear_localestring (CafeDesktopItem *item,
		       const char *attr)
2839{
GList *l;

g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);
g_return_if_fail (attr != NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return; } } while (0);

for (l = item->languages; l != NULL((void*)0); l = l->next)
set_locale (item, attr, l->data, NULL((void*)0));

set (item, attr, NULL((void*)0));
2850}

2852/*
* Strings, Regexps types
*/

2856char **
2857cafe_desktop_item_get_strings (const CafeDesktopItem *item,
		const char *attr)
2859{
const char *value;

g_return_val_if_fail (item != NULL, NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return (((void*)0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, NULL)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (attr != NULL, NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return (((void*)0)); } } while (0);

value = lookup (item, attr);
if (value == NULL((void*)0))
return NULL((void*)0);

/* FIXME: there's no way to escape semicolons apparently */
return g_strsplit (value, ";", -1);
2872}

2874void
2875cafe_desktop_item_set_strings (CafeDesktopItem *item,
		const char *attr,
		char **strings)
2878{
char *str, *str2;

g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);
g_return_if_fail (attr != NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return; } } while (0);

str = g_strjoinv (";", strings);
str2 = g_strconcat (str, ";", NULL((void*)0));
/* FIXME: there's no way to escape semicolons apparently */
set (item, attr, str2);
g_free (str);
g_free (str2);
2891}

2893/*
* Boolean type
*/
2896gboolean
2897cafe_desktop_item_get_boolean (const CafeDesktopItem *item,
		const char *attr)
2899{
const char *value;

g_return_val_if_fail (item != NULL, FALSE)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return ((0)); } } while (0);
g_return_val_if_fail (item->refcount > 0, FALSE)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return ((0)); } } while (0);
g_return_val_if_fail (attr != NULL, FALSE)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return ((0)); } } while (0);

value = lookup (item, attr);
if (value == NULL((void*)0))
return FALSE(0);

return (value[0] == 'T' ||
value[0] == 't' ||
value[0] == 'Y' ||
value[0] == 'y' ||
atoi (value) != 0);
2915}

2917void
2918cafe_desktop_item_set_boolean (CafeDesktopItem *item,
		const char *attr,
		gboolean value)
2921{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);
g_return_if_fail (attr != NULL)do { if ((attr != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "attr != NULL");
 return; } } while (0);

set (item, attr, value ? "true" : "false");
2927}

2929void
2930cafe_desktop_item_set_launch_time (CafeDesktopItem *item,
		    guint32           timestamp)
2932{
g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);

item->launch_time = timestamp;
2936}

2938/*
* Clearing attributes
*/
2941void
2942cafe_desktop_item_clear_section (CafeDesktopItem *item,
		  const char *section)
2944{
Section *sec;
GList *li;

g_return_if_fail (item != NULL)do { if ((item != ((void*)0))) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item != NULL");
 return; } } while (0);
g_return_if_fail (item->refcount > 0)do { if ((item->refcount > 0)) { } else { g_return_if_fail_warning
 ("CafeDesktop", ((const char*) (__func__)), "item->refcount > 0"
); return; } } while (0);

sec = find_section (item, section);

if (sec == NULL((void*)0)) {
for (li = item->keys; li != NULL((void*)0); li = li->next) {
	g_hash_table_remove (item->main_hash, li->data);
	g_free (li->data);
	li->data = NULL((void*)0);
}
g_list_free (item->keys);
item->keys = NULL((void*)0);
} else {
for (li = sec->keys; li != NULL((void*)0); li = li->next) {
	char *key = li->data;
	char *full = g_strdup_printf ("%s/%s",
				      sec->name, key);
	g_hash_table_remove (item->main_hash, full);
	g_free (full);
	g_free (key);
	li->data = NULL((void*)0);
}
g_list_free (sec->keys);
sec->keys = NULL((void*)0);
}
item->modified = TRUE(!(0));
2975}

2977/************************************************************
* Parser:                                                  *
************************************************************/

2981static gboolean G_GNUC_CONST__attribute__ ((__const__))
2982standard_is_boolean (const char * key)
2983{
static GHashTable *bools = NULL((void*)0);

if (bools == NULL((void*)0)) {
bools = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (bools,
		     CAFE_DESKTOP_ITEM_NO_DISPLAY"NoDisplay",
		     CAFE_DESKTOP_ITEM_NO_DISPLAY"NoDisplay");
g_hash_table_insert (bools,
		     CAFE_DESKTOP_ITEM_HIDDEN"Hidden",
		     CAFE_DESKTOP_ITEM_HIDDEN"Hidden");
g_hash_table_insert (bools,
		     CAFE_DESKTOP_ITEM_TERMINAL"Terminal",
		     CAFE_DESKTOP_ITEM_TERMINAL"Terminal");
g_hash_table_insert (bools,
		     CAFE_DESKTOP_ITEM_READ_ONLY"ReadOnly",
		     CAFE_DESKTOP_ITEM_READ_ONLY"ReadOnly");
}

return g_hash_table_lookup (bools, key) != NULL((void*)0);
3003}

3005static gboolean G_GNUC_CONST__attribute__ ((__const__))
3006standard_is_strings (const char *key)
3007{
static GHashTable *strings = NULL((void*)0);

if (strings == NULL((void*)0)) {
strings = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (strings,
		     CAFE_DESKTOP_ITEM_FILE_PATTERN"FilePattern",
		     CAFE_DESKTOP_ITEM_FILE_PATTERN"FilePattern");
g_hash_table_insert (strings,
		     CAFE_DESKTOP_ITEM_ACTIONS"Actions",
		     CAFE_DESKTOP_ITEM_ACTIONS"Actions");
g_hash_table_insert (strings,
		     CAFE_DESKTOP_ITEM_MIME_TYPE"MimeType",
		     CAFE_DESKTOP_ITEM_MIME_TYPE"MimeType");
g_hash_table_insert (strings,
		     CAFE_DESKTOP_ITEM_PATTERNS"Patterns",
		     CAFE_DESKTOP_ITEM_PATTERNS"Patterns");
g_hash_table_insert (strings,
		     CAFE_DESKTOP_ITEM_SORT_ORDER"SortOrder",
		     CAFE_DESKTOP_ITEM_SORT_ORDER"SortOrder");
}

return g_hash_table_lookup (strings, key) != NULL((void*)0);
3030}

3032/* If no need to cannonize, returns NULL */
3033static char *
3034cannonize (const char *key, const char *value)
3035{
if (standard_is_boolean (key)) {
if (value[0] == 'T' ||
    value[0] == 't' ||
    value[0] == 'Y' ||
    value[0] == 'y' ||
    atoi (value) != 0) {
	return g_strdup ("true")g_strdup_inline ("true");
} else {
	return g_strdup ("false")g_strdup_inline ("false");
}
} else if (standard_is_strings (key)) {
int len = strlen (value);
if (len == 0 || value[len-1] != ';') {
	return g_strconcat (value, ";", NULL((void*)0));
}
}
/* XXX: Perhaps we should canonize numeric values as well, but this
* has caused some subtle problems before so it needs to be done
* carefully if at all */
return NULL((void*)0);
3056}


3059static char *
3060decode_string_and_dup (const char *s)
3061{
char *p = g_malloc (strlen (s) + 1);
char *q = p;

do {
if (*s == '\\'){
	switch (*(++s)){
	case 's':
		*p++ = ' ';
		break;
	case 't':
		*p++ = '\t';
		break;
	case 'n':
		*p++ = '\n';
		break;
	case '\\':
		*p++ = '\\';
		break;
	case 'r':
		*p++ = '\r';
		break;
	default:
		*p++ = '\\';
		*p++ = *s;
		break;
	}
} else {
	*p++ = *s;
}
} while (*s++);

return q;
3094}

3096static char *
3097escape_string_and_dup (const char *s)
3098{
char *return_value, *p;
const char *q;
int len = 0;

if (s11.1
's' is not equal to NULL
 == NULL((void*)0))
12
←
Taking false branch→
return g_strdup("")g_strdup_inline ("");

q = s;
while (*q){
13
←
Loop condition is true.  Entering loop body→
16
←
Loop condition is true.  Entering loop body→
19
←
Loop condition is false. Execution continues on line 3113→
len++;
if (strchr ("\n\r\t\\", *q) != NULL((void*)0))
14
←
Assuming the condition is false→
15
←
Taking false branch→
17
←
Assuming the condition is false→
18
←
Taking false branch→
	len++;
q++;
}
return_value = p = (char *) g_malloc (len + 1);
do {
22
←
Loop condition is true. Execution continues on line 3115→
switch (*s){
20
←
Control jumps to 'case 92:'  at line 3128→
23
←
Control jumps to 'case 10:'  at line 3120→
case '\t':
	*p++ = '\\';
	*p++ = 't';
	break;
case '\n':
	*p++ = '\\';
	*p++ = 'n';
24
←
Access of the heap area at index 3, while it holds only 3 'char' elements
	break;
case '\r':
	*p++ = '\\';
	*p++ = 'r';
	break;
case '\\':
	*p++ = '\\';
	*p++ = '\\';
	break;
21
←
 Execution continues on line 3135→
default:
	*p++ = *s;
}
} while (*s++);
return return_value;
3137}

3139static gboolean
3140check_locale (const char *locale)
3141{
GIConv cd = g_iconv_open ("UTF-8", locale);
if ((GIConv)-1 == cd)
return FALSE(0);
g_iconv_close (cd);
return TRUE(!(0));
3147}

3149static void
3150insert_locales (GHashTable *encodings, char *enc, ...)
3151{
va_list args;

va_start (args, enc)__builtin_va_start(args, enc);
for (;;) {
char *s;

s = va_arg (args, char *)__builtin_va_arg(args, char *);
if (s == NULL((void*)0))
	break;
g_hash_table_insert (encodings, s, enc);
}
va_end (args)__builtin_va_end(args);
3164}

3166/* make a standard conversion table from the desktop standard spec */
3167static GHashTable *
3168init_encodings (void)
3169{
GHashTable *encodings = g_hash_table_new (g_str_hash, g_str_equal);

/* "C" is plain ascii */
insert_locales (encodings, "ASCII", "C", NULL((void*)0));

insert_locales (encodings, "ARMSCII-8", "by", NULL((void*)0));
insert_locales (encodings, "BIG5", "zh_TW", NULL((void*)0));
insert_locales (encodings, "CP1251", "be", "bg", NULL((void*)0));
if (check_locale ("EUC-CN")) {
insert_locales (encodings, "EUC-CN", "zh_CN", NULL((void*)0));
} else {
insert_locales (encodings, "GB2312", "zh_CN", NULL((void*)0));
}
insert_locales (encodings, "EUC-JP", "ja", NULL((void*)0));
insert_locales (encodings, "EUC-KR", "ko", NULL((void*)0));
/*insert_locales (encodings, "GEORGIAN-ACADEMY", NULL);*/
insert_locales (encodings, "GEORGIAN-PS", "ka", NULL((void*)0));
insert_locales (encodings, "ISO-8859-1", "br", "ca", "da", "de", "en", "es", "eu", "fi", "fr", "gl", "it", "nl", "wa", "no", "pt", "pt", "sv", NULL((void*)0));
insert_locales (encodings, "ISO-8859-2", "cs", "hr", "hu", "pl", "ro", "sk", "sl", "sq", "sr", NULL((void*)0));
insert_locales (encodings, "ISO-8859-3", "eo", NULL((void*)0));
insert_locales (encodings, "ISO-8859-5", "mk", "sp", NULL((void*)0));
insert_locales (encodings, "ISO-8859-7", "el", NULL((void*)0));
insert_locales (encodings, "ISO-8859-9", "tr", NULL((void*)0));
insert_locales (encodings, "ISO-8859-13", "lt", "lv", "mi", NULL((void*)0));
insert_locales (encodings, "ISO-8859-14", "ga", "cy", NULL((void*)0));
insert_locales (encodings, "ISO-8859-15", "et", NULL((void*)0));
insert_locales (encodings, "KOI8-R", "ru", NULL((void*)0));
insert_locales (encodings, "KOI8-U", "uk", NULL((void*)0));
if (check_locale ("TCVN-5712")) {
insert_locales (encodings, "TCVN-5712", "vi", NULL((void*)0));
} else {
insert_locales (encodings, "TCVN", "vi", NULL((void*)0));
}
insert_locales (encodings, "TIS-620", "th", NULL((void*)0));
/*insert_locales (encodings, "VISCII", NULL);*/

return encodings;
3207}

3209static const char *
3210get_encoding_from_locale (const char *locale)
3211{
char lang[3];
const char *encoding;
static GHashTable *encodings = NULL((void*)0);

if (locale == NULL((void*)0))
return NULL((void*)0);

/* if locale includes encoding, use it */
encoding = strchr (locale, '.');
if (encoding != NULL((void*)0)) {
return encoding+1;
}

if (encodings == NULL((void*)0))
encodings = init_encodings ();

/* first try the entire locale (at this point ll_CC) */
encoding = g_hash_table_lookup (encodings, locale);
if (encoding != NULL((void*)0))
return encoding;

/* Try just the language */
strncpy (lang, locale, 2);
lang[2] = '\0';
return g_hash_table_lookup (encodings, lang);
3237}

3239static Encoding
3240get_encoding (ReadBuf *rb)
3241{
gboolean old_kde = FALSE(0);
char     buf [BUFSIZ8192];
gboolean all_valid_utf8 = TRUE(!(0));

while (readbuf_gets (buf, sizeof (buf), rb) != NULL((void*)0)) {
if (strncmp (CAFE_DESKTOP_ITEM_ENCODING"Encoding",
	     buf,
	     strlen (CAFE_DESKTOP_ITEM_ENCODING"Encoding")) == 0) {
	char *p = &buf[strlen (CAFE_DESKTOP_ITEM_ENCODING"Encoding")];
	if (*p == ' ')
		p++;
	if (*p != '=')
		continue;
	p++;
	if (*p == ' ')
		p++;
	if (strcmp (p, "UTF-8") == 0) {
		return ENCODING_UTF8;
	} else if (strcmp (p, "Legacy-Mixed") == 0) {
		return ENCODING_LEGACY_MIXED;
	} else {
		/* According to the spec we're not supposed
		 * to read a file like this */
		return ENCODING_UNKNOWN;
	}
} else if (strcmp ("[KDE Desktop Entry]", buf) == 0) {
	old_kde = TRUE(!(0));
	/* don't break yet, we still want to support
	 * Encoding even here */
}
if (all_valid_utf8 && ! g_utf8_validate (buf, -1, NULL((void*)0)))
	all_valid_utf8 = FALSE(0);
}

if (old_kde)
return ENCODING_LEGACY_MIXED;

/* try to guess by location */
if (rb->uri != NULL((void*)0) && strstr (rb->uri, "cafe/apps/") != NULL((void*)0)) {
/* old cafe */
return ENCODING_LEGACY_MIXED;
}

/* A dilemma, new KDE files are in UTF-8 but have no Encoding
* info, at this time we really can't tell.  The best thing to
* do right now is to just assume UTF-8 if the whole file
* validates as utf8 I suppose */

if (all_valid_utf8)
return ENCODING_UTF8;
else
return ENCODING_LEGACY_MIXED;
3294}

3296static char *
3297decode_string (const char *value, Encoding encoding, const char *locale)
3298{
char *retval = NULL((void*)0);

/* if legacy mixed, then convert */
if (locale != NULL((void*)0) && encoding == ENCODING_LEGACY_MIXED) {
const char *char_encoding = get_encoding_from_locale (locale);
char *utf8_string;
if (char_encoding == NULL((void*)0))
	return NULL((void*)0);
if (strcmp (char_encoding, "ASCII") == 0) {
	return decode_string_and_dup (value);
}
utf8_string = g_convert (value, -1, "UTF-8", char_encoding,
			NULL((void*)0), NULL((void*)0), NULL((void*)0));
if (utf8_string == NULL((void*)0))
	return NULL((void*)0);
retval = decode_string_and_dup (utf8_string);
g_free (utf8_string);
return retval;
/* if utf8, then validate */
} else if (locale != NULL((void*)0) && encoding == ENCODING_UTF8) {
if ( ! g_utf8_validate (value, -1, NULL((void*)0)))
	/* invalid utf8, ignore this key */
	return NULL((void*)0);
return decode_string_and_dup (value);
} else {
/* Meaning this is not a localized string */
return decode_string_and_dup (value);
}
3327}

3329static char *
3330snarf_locale_from_key (const char *key)
3331{
const char *brace;
char *locale, *p;

brace = strchr (key, '[');
if (brace == NULL((void*)0))
return NULL((void*)0);

locale = g_strdup (brace + 1)g_strdup_inline (brace + 1);
if (*locale == '\0') {
g_free (locale);
return NULL((void*)0);
}
p = strchr (locale, ']');
if (p == NULL((void*)0)) {
g_free (locale);
return NULL((void*)0);
}
*p = '\0';
return locale;
3351}

3353static void
3354insert_key (CafeDesktopItem *item,
   Section *cur_section,
   Encoding encoding,
   const char *key,
   const char *value,
   gboolean old_kde,
   gboolean no_translations)
3361{
char *k;
char *val;
/* we always store everything in UTF-8 */
if (cur_section == NULL((void*)0) &&
   strcmp (key, CAFE_DESKTOP_ITEM_ENCODING"Encoding") == 0) {
k = g_strdup (key)g_strdup_inline (key);
val = g_strdup ("UTF-8")g_strdup_inline ("UTF-8");
} else {
char *locale = snarf_locale_from_key (key);
/* If we're ignoring translations */
if (no_translations && locale != NULL((void*)0)) {
	g_free (locale);
	return;
}
val = decode_string (value, encoding, locale);

/* Ignore this key, it's whacked */
if (val == NULL((void*)0)) {
	g_free (locale);
	return;
}

g_strchomp (val);

/* For old KDE entries, we can also split by a comma
 * on sort order, so convert to semicolons */
if (old_kde &&
    cur_section == NULL((void*)0) &&
    strcmp (key, CAFE_DESKTOP_ITEM_SORT_ORDER"SortOrder") == 0 &&
    strchr (val, ';') == NULL((void*)0)) {
	int i;
	for (i = 0; val[i] != '\0'; i++) {
		if (val[i] == ',')
			val[i] = ';';
	}
}

/* Check some types, not perfect, but catches a lot
 * of things */
if (cur_section == NULL((void*)0)) {
	char *cannon = cannonize (key, val);
	if (cannon != NULL((void*)0)) {
		g_free (val);
		val = cannon;
	}
}

k = g_strdup (key)g_strdup_inline (key);

/* Take care of the language part */
if (locale != NULL((void*)0) &&
    strcmp (locale, "C") == 0) {
	char *p;
	/* Whack C locale */
	p = strchr (k, '[');
	*p = '\0';
	g_free (locale);
} else if (locale != NULL((void*)0)) {
	char *p, *brace;

	/* Whack the encoding part */
	p = strchr (locale, '.');
	if (p != NULL((void*)0))
		*p = '\0';

	if (g_list_find_custom (item->languages, locale,
				(GCompareFunc)strcmp) == NULL((void*)0)) {
		item->languages = g_list_prepend
			(item->languages, locale);
	} else {
		g_free (locale);
	}

	/* Whack encoding from encoding in the key */
	brace = strchr (k, '[');
	p = strchr (brace, '.');
	if (p != NULL((void*)0)) {
		*p = ']';
		*(p+1) = '\0';
	}
}
}


if (cur_section == NULL((void*)0)) {
/* only add to list if we haven't seen it before */
if (g_hash_table_lookup (item->main_hash, k) == NULL((void*)0)) {
	item->keys = g_list_prepend (item->keys,
				     g_strdup (k)g_strdup_inline (k));
}
/* later duplicates override earlier ones */
g_hash_table_replace (item->main_hash, k, val);
} else {
char *full = g_strdup_printf
	("%s/%s",
	 cur_section->name, k);
/* only add to list if we haven't seen it before */
if (g_hash_table_lookup (item->main_hash, full) == NULL((void*)0)) {
	cur_section->keys =
		g_list_prepend (cur_section->keys, k);
}
/* later duplicates override earlier ones */
g_hash_table_replace (item->main_hash,
		      full, val);
}
3467}

3469static void
3470setup_type (CafeDesktopItem *item, const char *uri)
3471{
const char *type = g_hash_table_lookup (item->main_hash,
				CAFE_DESKTOP_ITEM_TYPE"Type");
if (type == NULL((void*)0) && uri != NULL((void*)0)) {
char *base = g_path_get_basename (uri);
if (base != NULL((void*)0) &&
    strcmp (base, ".directory") == 0) {
	/* This gotta be a directory */
	g_hash_table_replace (item->main_hash,
			      g_strdup (CAFE_DESKTOP_ITEM_TYPE)g_strdup_inline ("Type"),
			      g_strdup ("Directory")g_strdup_inline ("Directory"));
	item->keys = g_list_prepend
		(item->keys, g_strdup (CAFE_DESKTOP_ITEM_TYPE)g_strdup_inline ("Type"));
	item->type = CAFE_DESKTOP_ITEM_TYPE_DIRECTORY;
} else {
	item->type = CAFE_DESKTOP_ITEM_TYPE_NULL;
}
g_free (base);
} else {
item->type = type_from_string (type);
}
3492}

3494/* fallback to find something suitable for C locale */
3495static char *
3496try_english_key (CafeDesktopItem *item, const char *key)
3497{
char *str;
char *locales[] = { "en_US", "en_GB", "en_AU", "en", NULL((void*)0) };
int i;

str = NULL((void*)0);
for (i = 0; locales[i] != NULL((void*)0) && str == NULL((void*)0); i++) {
str = g_strdup (lookup_locale (item, key, locales[i]))g_strdup_inline (lookup_locale (item, key, locales[i]));
}
if (str != NULL((void*)0)) {
/* We need a 7-bit ascii string, so whack all
 * above 127 chars */
guchar *p;
for (p = (guchar *)str; *p != '\0'; p++) {
	if (*p > 127)
		*p = '?';
}
}
return str;
3516}


3519static void
3520sanitize (CafeDesktopItem *item, const char *uri)
3521{
const char *type;

type = lookup (item, CAFE_DESKTOP_ITEM_TYPE"Type");

/* understand old cafe style url exec thingies */
if (type != NULL((void*)0) && strcmp (type, "URL") == 0) {
const char *exec = lookup (item, CAFE_DESKTOP_ITEM_EXEC"Exec");
set (item, CAFE_DESKTOP_ITEM_TYPE"Type", "Link");
if (exec != NULL((void*)0)) {
	/* Note, this must be in this order */
	set (item, CAFE_DESKTOP_ITEM_URL"URL", exec);
	set (item, CAFE_DESKTOP_ITEM_EXEC"Exec", NULL((void*)0));
}
}

/* we make sure we have Name, Encoding and Version */
if (lookup (item, CAFE_DESKTOP_ITEM_NAME"Name") == NULL((void*)0)) {
char *name = try_english_key (item, CAFE_DESKTOP_ITEM_NAME"Name");
/* If no name, use the basename */
if (name == NULL((void*)0) && uri != NULL((void*)0))
	name = g_path_get_basename (uri);
/* If no uri either, use same default as cafe_desktop_item_new */
if (name == NULL((void*)0)) {
       /* Translators: the "name" mentioned here is the name of
	* an application or a document */
	name = g_strdup (_("No name"))g_strdup_inline (((char *) g_dgettext ("cafe-desktop", "No name"
)));
}
g_hash_table_replace (item->main_hash,
		      g_strdup (CAFE_DESKTOP_ITEM_NAME)g_strdup_inline ("Name"),
		      name);
item->keys = g_list_prepend
	(item->keys, g_strdup (CAFE_DESKTOP_ITEM_NAME)g_strdup_inline ("Name"));
}
if (lookup (item, CAFE_DESKTOP_ITEM_ENCODING"Encoding") == NULL((void*)0)) {
/* We store everything in UTF-8 so write that down */
g_hash_table_replace (item->main_hash,
		      g_strdup (CAFE_DESKTOP_ITEM_ENCODING)g_strdup_inline ("Encoding"),
		      g_strdup ("UTF-8")g_strdup_inline ("UTF-8"));
item->keys = g_list_prepend
	(item->keys, g_strdup (CAFE_DESKTOP_ITEM_ENCODING)g_strdup_inline ("Encoding"));
}
if (lookup (item, CAFE_DESKTOP_ITEM_VERSION"Version") == NULL((void*)0)) {
/* this is the version that we follow, so write it down */
g_hash_table_replace (item->main_hash,
		      g_strdup (CAFE_DESKTOP_ITEM_VERSION)g_strdup_inline ("Version"),
		      g_strdup ("1.0")g_strdup_inline ("1.0"));
item->keys = g_list_prepend
	(item->keys, g_strdup (CAFE_DESKTOP_ITEM_VERSION)g_strdup_inline ("Version"));
}
3571}

3573enum {
FirstBrace,
OnSecHeader,
IgnoreToEOL,
IgnoreToEOLFirst,
KeyDef,
KeyDefOnKey,
KeyValue
3581};

3583static CafeDesktopItem *
3584ditem_load (ReadBuf *rb,
   gboolean no_translations,
   GError **error)
3587{
int state;
char CharBuffer [1024];
char *next = CharBuffer;
int c;
Encoding encoding;
CafeDesktopItem *item;
Section *cur_section = NULL((void*)0);
char *key = NULL((void*)0);
gboolean old_kde = FALSE(0);

encoding = get_encoding (rb);
if (encoding == ENCODING_UNKNOWN) {
/* spec says, don't read this file */
g_set_error (error,
	     CAFE_DESKTOP_ITEM_ERRORcafe_desktop_item_error_quark (),
	     CAFE_DESKTOP_ITEM_ERROR_UNKNOWN_ENCODING,
	     _("Unknown encoding of: %s")((char *) g_dgettext ("cafe-desktop", "Unknown encoding of: %s"
)),
	     rb->uri);
readbuf_close (rb);
return NULL((void*)0);
}

/* Rewind since get_encoding goes through the file */
if (! readbuf_rewind (rb, error)) {
readbuf_close (rb);
/* spec says, don't read this file */
return NULL((void*)0);
}

item = cafe_desktop_item_new ();
item->modified = FALSE(0);

/* Note: location and mtime are filled in by the new_from_file
* function since it has those values */

3623#define OVERFLOW (next == &CharBuffer [sizeof(CharBuffer)-1])

state = FirstBrace;
while ((c = readbuf_getc (rb)) != EOF(-1)) {
if (c == '\r')		/* Ignore Carriage Return */
	continue;

switch (state) {

case OnSecHeader:
	if (c == ']' || OVERFLOW) {
		*next = '\0';
		next = CharBuffer;

		/* keys were inserted in reverse */
		if (cur_section != NULL((void*)0) &&
		    cur_section->keys != NULL((void*)0)) {
			cur_section->keys = g_list_reverse
				(cur_section->keys);
		}
		if (strcmp (CharBuffer,
			    "KDE Desktop Entry") == 0) {
			/* Main section */
			cur_section = NULL((void*)0);
			old_kde = TRUE(!(0));
		} else if (strcmp (CharBuffer,
				   "Desktop Entry") == 0) {
			/* Main section */
			cur_section = NULL((void*)0);
		} else {
			cur_section = g_new0 (Section, 1)((Section *) g_malloc0_n ((1), sizeof (Section)));
			cur_section->name =
				g_strdup (CharBuffer)g_strdup_inline (CharBuffer);
			cur_section->keys = NULL((void*)0);
			item->sections = g_list_prepend
				(item->sections, cur_section);
		}
		state = IgnoreToEOL;
	} else if (c == '[') {
		/* FIXME: probably error out instead of ignoring this */
	} else {
		*next++ = c;
	}
	break;

case IgnoreToEOL:
case IgnoreToEOLFirst:
	if (c == '\n'){
		if (state == IgnoreToEOLFirst)
			state = FirstBrace;
		else
			state = KeyDef;
		next = CharBuffer;
	}
	break;

case FirstBrace:
case KeyDef:
case KeyDefOnKey:
	if (c == '#') {
		if (state == FirstBrace)
			state = IgnoreToEOLFirst;
		else
			state = IgnoreToEOL;
		break;
	}

	if (c == '[' && state != KeyDefOnKey){
		state = OnSecHeader;
		next = CharBuffer;
		g_free (key);
		key = NULL((void*)0);
		break;
	}
	/* On first pass, don't allow dangling keys */
	if (state == FirstBrace)
		break;

	if ((c == ' ' && state != KeyDefOnKey) || c == '\t')
		break;

	if (c == '\n' || OVERFLOW) { /* Abort Definition */
		next = CharBuffer;
		state = KeyDef;
		break;
	}

	if (c == '=' || OVERFLOW){
		*next = '\0';

		g_free (key);
		key = g_strdup (CharBuffer)g_strdup_inline (CharBuffer);
		state = KeyValue;
		next = CharBuffer;
	} else {
		*next++ = c;
		state = KeyDefOnKey;
	}
	break;

case KeyValue:
	if (OVERFLOW || c == '\n'){
		*next = '\0';

		insert_key (item, cur_section, encoding,
			    key, CharBuffer, old_kde,
			    no_translations);

		g_free (key);
		key = NULL((void*)0);

		state = (c == '\n') ? KeyDef : IgnoreToEOL;
		next = CharBuffer;
	} else {
		*next++ = c;
	}
	break;

} /* switch */

} /* while ((c = getc_unlocked (f)) != EOF) */
if (c == EOF(-1) && state == KeyValue) {
*next = '\0';

insert_key (item, cur_section, encoding,
	    key, CharBuffer, old_kde,
	    no_translations);

g_free (key);
key = NULL((void*)0);
}

3755#undef OVERFLOW

/* keys were inserted in reverse */
if (cur_section != NULL((void*)0) &&
   cur_section->keys != NULL((void*)0)) {
cur_section->keys = g_list_reverse (cur_section->keys);
}
/* keys were inserted in reverse */
item->keys = g_list_reverse (item->keys);
/* sections were inserted in reverse */
item->sections = g_list_reverse (item->sections);

/* sanitize some things */
sanitize (item, rb->uri);

/* make sure that we set up the type */
setup_type (item, rb->uri);

readbuf_close (rb);

return item;
3776}

3778static void stream_printf (GFileOutputStream *stream,
	   const char *format, ...) G_GNUC_PRINTF (2, 3)__attribute__((__format__ (__printf__, 2, 3)));

3781static void
3782stream_printf (GFileOutputStream *stream, const char *format, ...)
3783{
  va_list args;
  gchar *s;

  va_start (args, format)__builtin_va_start(args, format);
  s = g_strdup_vprintf (format, args);
  va_end (args)__builtin_va_end(args);

  /* FIXME: what about errors */
  g_output_stream_write (G_OUTPUT_STREAM (stream)((((GOutputStream*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((stream)), ((g_output_stream_get_type ())))))), s, strlen (s),
    	   NULL((void*)0), NULL((void*)0));
  g_free (s);
3795}

3797static void
3798dump_section (CafeDesktopItem *item, GFileOutputStream *stream, Section *section)
3799{
GList *li;

stream_printf (stream, "[%s]\n", section->name);
for (li = section->keys; li != NULL((void*)0); li = li->next) {
const char *key = li->data;
char *full = g_strdup_printf ("%s/%s", section->name, key);
const char *value = g_hash_table_lookup (item->main_hash, full);
if (value != NULL((void*)0)) {
	char *val = escape_string_and_dup (value);
	stream_printf (stream, "%s=%s\n", key, val);
	g_free (val);
}
g_free (full);
}
3814}

3816static gboolean
3817ditem_save (CafeDesktopItem *item, const char *uri, GError **error)
3818{
GList *li;
GFile *file;
GFileOutputStream *stream;

file = g_file_new_for_uri (uri);
stream = g_file_replace (file, NULL((void*)0), FALSE(0), G_FILE_CREATE_NONE,
		 NULL((void*)0), error);
if (stream == NULL((void*)0))
5
←
Assuming 'stream' is not equal to NULL→
6
←
Taking false branch→
return FALSE(0);

stream_printf (stream, "[Desktop Entry]\n");
for (li = item->keys; li != NULL((void*)0); li = li->next) {
7
←
Assuming 'li' is not equal to NULL→
8
←
Loop condition is true.  Entering loop body→
const char *key = li->data;
const char *value = g_hash_table_lookup (item->main_hash, key);
if (value != NULL((void*)0)) {
9
←
Assuming 'value' is not equal to NULL→
10
←
Taking true branch→
	char *val = escape_string_and_dup (value);
11
←
Calling 'escape_string_and_dup'→
	stream_printf (stream, "%s=%s\n", key, val);
	g_free (val);
}
}

if (item->sections != NULL((void*)0))
stream_printf (stream, "\n");

for (li = item->sections; li != NULL((void*)0); li = li->next) {
Section *section = li->data;

/* Don't write empty sections */
if (section->keys == NULL((void*)0))
	continue;

dump_section (item, stream, section);

if (li->next != NULL((void*)0))
	stream_printf (stream, "\n");
}

g_object_unref (stream);
g_object_unref (file);

return TRUE(!(0));
3860}

3862static gpointer
3863_cafe_desktop_item_copy (gpointer boxed)
3864{
return cafe_desktop_item_copy (boxed);
3866}

3868static void
3869_cafe_desktop_item_free (gpointer boxed)
3870{
cafe_desktop_item_unref (boxed);
3872}

3874GType
3875cafe_desktop_item_get_type (void)
3876{
static GType type = 0;

if (type == 0) {
type = g_boxed_type_register_static ("CafeDesktopItem",
				     _cafe_desktop_item_copy,
				     _cafe_desktop_item_free);
}

return type;
3886}

3888GQuark
3889cafe_desktop_item_error_quark (void)
3890{
static GQuark q = 0;
if (q == 0)
q = g_quark_from_static_string ("cafe-desktop-item-error-quark");

return q;
3896}