/* gkeyfile.c - key file parser

 *

 *  Copyright 2004  Red Hat, Inc.  

 *

 * Written by Ray Strode <rstrode@redhat.com>

 *            Matthias Clasen <mclasen@redhat.com>

 * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

 *

 * GLib is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation; either version 2 of the

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

 *

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

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

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

 * Lesser General Public License for more details.

 *

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

 * License along with GLib; see the file COPYING.LIB.  If not,

 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 *   Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include "gkeyfile.h"

#include <errno.h>

#include <fcntl.h>

#include <locale.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef G_OS_WIN32

#include <io.h>

#ifndef S_ISREG

#define S_ISREG(mode) ((mode)&_S_IFREG)

#endif

#endif  /* G_OS_WIN23 */

#include "gconvert.h"

#include "gdataset.h"

#include "gerror.h"

#include "gfileutils.h"

#include "ghash.h"

#include "glibintl.h"

#include "glist.h"

#include "gslist.h"

#include "gmem.h"

#include "gmessages.h"

#include "gstdio.h"

#include "gstring.h"

#include "gstrfuncs.h"

#include "gutils.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include <glib.h>

#include <glib_wsd.h>

#endif /* __SYMBIAN32__ */

typedef struct _GKeyFileGroup GKeyFileGroup;

struct _GKeyFile

{

  GList *groups;

  GKeyFileGroup *start_group;

  GKeyFileGroup *current_group;

  GString *parse_buffer; /* Holds up to one line of not-yet-parsed data */

  /* Used for sizing the output buffer during serialization

   */

  gsize approximate_size;

  gchar list_separator;

  GKeyFileFlags flags;

};

typedef struct _GKeyFileKeyValuePair GKeyFileKeyValuePair;

struct _GKeyFileGroup

{

  const gchar *name;  /* NULL for above first group (which will be comments) */

  GKeyFileKeyValuePair *comment; /* Special comment that is stuck to the top of a group */

  GList *key_value_pairs; 

  /* Used in parallel with key_value_pairs for

   * increased lookup performance

   */

  GHashTable *lookup_map;

};

struct _GKeyFileKeyValuePair

{

  gchar *key;  /* NULL for comments */

  gchar *value;

};

static gint                  find_file_in_data_dirs            (const gchar            *file,

								gchar                 **output_file,

								gchar                ***data_dirs,

								GError                **error);

static gboolean              g_key_file_load_from_fd           (GKeyFile               *key_file,

								gint                    fd,

								GKeyFileFlags           flags,

								GError                **error);

static GList                *g_key_file_lookup_group_node      (GKeyFile               *key_file,

			                                        const gchar            *group_name);

static GKeyFileGroup        *g_key_file_lookup_group           (GKeyFile               *key_file,

								const gchar            *group_name);

static GList                *g_key_file_lookup_key_value_pair_node  (GKeyFile       *key_file,

			                                             GKeyFileGroup  *group,

                                                                     const gchar    *key);

static GKeyFileKeyValuePair *g_key_file_lookup_key_value_pair       (GKeyFile       *key_file,

                                                                     GKeyFileGroup  *group,

                                                                     const gchar    *key);

static void                  g_key_file_remove_group_node          (GKeyFile      *key_file,

							  	    GList         *group_node);

static void                  g_key_file_remove_key_value_pair_node (GKeyFile      *key_file,

                                                                    GKeyFileGroup *group,

                                                                    GList         *pair_node);

static void                  g_key_file_add_key                (GKeyFile               *key_file,

								GKeyFileGroup          *group,

								const gchar            *key,

								const gchar            *value);

static void                  g_key_file_add_group              (GKeyFile               *key_file,

								const gchar            *group_name);

static void                  g_key_file_key_value_pair_free    (GKeyFileKeyValuePair   *pair);

static gboolean              g_key_file_line_is_comment        (const gchar            *line);

static gboolean              g_key_file_line_is_group          (const gchar            *line);

static gboolean              g_key_file_line_is_key_value_pair (const gchar            *line);

static gchar                *g_key_file_parse_value_as_string  (GKeyFile               *key_file,

								const gchar            *value,

								GSList                **separators,

								GError                **error);

static gchar                *g_key_file_parse_string_as_value  (GKeyFile               *key_file,

								const gchar            *string,

								gboolean                escape_separator);

static gint                  g_key_file_parse_value_as_integer (GKeyFile               *key_file,

								const gchar            *value,

								GError                **error);

static gchar                *g_key_file_parse_integer_as_value (GKeyFile               *key_file,

								gint                    value);

static gboolean              g_key_file_parse_value_as_boolean (GKeyFile               *key_file,

								const gchar            *value,

								GError                **error);

static gchar                *g_key_file_parse_boolean_as_value (GKeyFile               *key_file,

								gboolean                value);

static gchar                *g_key_file_parse_value_as_comment (GKeyFile               *key_file,

                                                                const gchar            *value);

static gchar                *g_key_file_parse_comment_as_value (GKeyFile               *key_file,

                                                                const gchar            *comment);

static void                  g_key_file_parse_key_value_pair   (GKeyFile               *key_file,

								const gchar            *line,

								gsize                   length,

								GError                **error);

static void                  g_key_file_parse_comment          (GKeyFile               *key_file,

								const gchar            *line,

								gsize                   length,

								GError                **error);

static void                  g_key_file_parse_group            (GKeyFile               *key_file,

								const gchar            *line,

								gsize                   length,

								GError                **error);

static gchar                *key_get_locale                    (const gchar            *key);

static void                  g_key_file_parse_data             (GKeyFile               *key_file,

								const gchar            *data,

								gsize                   length,

								GError                **error);

static void                  g_key_file_flush_parse_buffer     (GKeyFile               *key_file,

								GError                **error);

#if EMULATOR

PLS(error_quark ,g_key_file_error_quark,GQuark)

#define error_quark  (*FUNCTION_NAME(error_quark ,g_key_file_error_quark)())

#endif /* EMULATOR */

EXPORT_C GQuark

g_key_file_error_quark (void)

{

  #if !(EMULATOR)

  static GQuark error_quark = 0;

  #endif /* EMULATOR */

  if (error_quark == 0)

    error_quark = g_quark_from_static_string ("g-key-file-error-quark");

  return error_quark;

}

#if EMULATOR

#undef error_quark

#endif /* EMULATOR */

static void

g_key_file_init (GKeyFile *key_file)

{  

  key_file->current_group = g_new0 (GKeyFileGroup, 1);

  key_file->groups = g_list_prepend (NULL, key_file->current_group);

  key_file->start_group = NULL;

  key_file->parse_buffer = g_string_sized_new (128);

  key_file->approximate_size = 0;

  key_file->list_separator = ';';

  key_file->flags = 0;

}

static void

g_key_file_clear (GKeyFile *key_file)

{

  GList *tmp, *group_node;

  if (key_file->parse_buffer)

    g_string_free (key_file->parse_buffer, TRUE);

  tmp = key_file->groups;

  while (tmp != NULL)

    {

      group_node = tmp;

      tmp = tmp->next;

      g_key_file_remove_group_node (key_file, group_node);

    }

  g_assert (key_file->groups == NULL);

}

/**

 * g_key_file_new:

 *

 * Creates a new empty #GKeyFile object. Use g_key_file_load_from_file(),

 * g_key_file_load_from_data() or g_key_file_load_from_data_dirs() to

 * read an existing key file.

 *

 * Return value: an empty #GKeyFile.

 *

 * Since: 2.6

 **/

EXPORT_C GKeyFile *

g_key_file_new (void)

{

  GKeyFile *key_file;

  key_file = g_new0 (GKeyFile, 1);

  g_key_file_init (key_file);

  return key_file;

}

/**

 * g_key_file_set_list_separator:

 * @key_file: a #GKeyFile 

 * @separator: the separator

 *

 * Sets the character which is used to separate

 * values in lists. Typically ';' or ',' are used

 * as separators. The default list separator is ';'.

 *

 * Since: 2.6

 */

EXPORT_C void

g_key_file_set_list_separator (GKeyFile *key_file,

			       gchar     separator)

{

  key_file->list_separator = separator;

}

/* Iterates through all the directories in *dirs trying to

 * open file.  When it successfully locates and opens a file it

 * returns the file descriptor to the open file.  It also

 * outputs the absolute path of the file in output_file and

 * leaves the unchecked directories in *dirs.

 */

static gint

find_file_in_data_dirs (const gchar   *file,

                        gchar        **output_file,

                        gchar       ***dirs,

                        GError       **error)

{

  gchar **data_dirs, *data_dir, *path;

  gint fd;

  path = NULL;

  fd = -1;

  if (dirs == NULL)

    return fd;

  data_dirs = *dirs;

  while (data_dirs && (data_dir = *data_dirs) && fd < 0)

    {

      gchar *candidate_file, *sub_dir;

      candidate_file = (gchar *) file;

      sub_dir = g_strdup ("");

      while (candidate_file != NULL && fd < 0)

        {

          gchar *p;

          path = g_build_filename (data_dir, sub_dir,

                                   candidate_file, NULL);

          fd = g_open (path, O_RDONLY, 0);

          if (fd < 0)

            {

              g_free (path);

              path = NULL;

            }

          candidate_file = strchr (candidate_file, '-');

          if (candidate_file == NULL)

            break;

          candidate_file++;

          g_free (sub_dir);

          sub_dir = g_strndup (file, candidate_file - file - 1);

          for (p = sub_dir; *p != '\0'; p++)

            {

              if (*p == '-')

                *p = G_DIR_SEPARATOR;

            }

        }

      g_free (sub_dir);

      data_dirs++;

    }

  *dirs = data_dirs;

  if (fd < 0)

    {

      g_set_error (error, G_KEY_FILE_ERROR,

                   G_KEY_FILE_ERROR_NOT_FOUND,

                   _("Valid key file could not be "

                     "found in data dirs")); 

    }

  if (output_file != NULL && fd > 0)

    *output_file = g_strdup (path);

  g_free (path);

  return fd;

}

static gboolean

g_key_file_load_from_fd (GKeyFile       *key_file,

			 gint            fd,

			 GKeyFileFlags   flags,

			 GError        **error)

{

  GError *key_file_error = NULL;

  gssize bytes_read;

  struct stat stat_buf;

  gchar read_buf[4096];

  if (fstat (fd, &stat_buf) < 0)

    {

      g_set_error (error, G_FILE_ERROR,

                   g_file_error_from_errno (errno),

                   "%s", g_strerror (errno));

      return FALSE;

    }

  if (!S_ISREG (stat_buf.st_mode))

    {

      g_set_error (error, G_KEY_FILE_ERROR,

                   G_KEY_FILE_ERROR_PARSE,

                   _("Not a regular file"));

      return FALSE;

    }

  if (stat_buf.st_size == 0)

    {

      g_set_error (error, G_KEY_FILE_ERROR,

                   G_KEY_FILE_ERROR_PARSE,

                   _("File is empty"));

      return FALSE;

    }

  if (key_file->approximate_size > 0)

    {

      g_key_file_clear (key_file);

      g_key_file_init (key_file);

    }

  key_file->flags = flags;

  bytes_read = 0;

  do

    {

      bytes_read = read (fd, read_buf, 4096);

      if (bytes_read == 0)  /* End of File */

        break;

      if (bytes_read < 0)

        {

          if (errno == EINTR || errno == EAGAIN)

            continue;

          g_set_error (error, G_FILE_ERROR,

                       g_file_error_from_errno (errno),

                       "%s", g_strerror (errno));

          return FALSE;

        }

      g_key_file_parse_data (key_file, 

			     read_buf, bytes_read,

			     &key_file_error);

    }

  while (!key_file_error);

  if (key_file_error)

    {

      g_propagate_error (error, key_file_error);

      return FALSE;

    }

  g_key_file_flush_parse_buffer (key_file, &key_file_error);

  if (key_file_error)

    {

      g_propagate_error (error, key_file_error);

      return FALSE;

    }

  return TRUE;

}

/**

 * g_key_file_load_from_file:

 * @key_file: an empty #GKeyFile struct

 * @file: the path of a filename to load, in the GLib file name encoding

 * @flags: flags from #GKeyFileFlags

 * @error: return location for a #GError, or %NULL

 *

 * Loads a key file into an empty #GKeyFile structure.

 * If the file could not be loaded then %error is set to 

 * either a #GFileError or #GKeyFileError.

 *

 * Return value: %TRUE if a key file could be loaded, %FALSE othewise

 * Since: 2.6

 **/

EXPORT_C gboolean

g_key_file_load_from_file (GKeyFile       *key_file,

			   const gchar    *file,

			   GKeyFileFlags   flags,

			   GError        **error)

{

  GError *key_file_error = NULL;

  gint fd;

  g_return_val_if_fail (key_file != NULL, FALSE);

  g_return_val_if_fail (file != NULL, FALSE);

  fd = g_open (file, O_RDONLY, 0);

  if (fd < 0)

    {

      g_set_error (error, G_FILE_ERROR,

                   g_file_error_from_errno (errno),

                   "%s", g_strerror (errno));

      return FALSE;

    }

  g_key_file_load_from_fd (key_file, fd, flags, &key_file_error);

  close (fd);

  if (key_file_error)

    {

      g_propagate_error (error, key_file_error);

      return FALSE;

    }

  return TRUE;

}

/**

 * g_key_file_load_from_data:

 * @key_file: an empty #GKeyFile struct

 * @data: key file loaded in memory.

 * @length: the length of @data in bytes

 * @flags: flags from #GKeyFileFlags

 * @error: return location for a #GError, or %NULL

 *

 * Loads a key file from memory into an empty #GKeyFile structure.  If

 * the object cannot be created then %error is set to a

 * #GKeyFileError. 

 *

 * Return value: %TRUE if a key file could be loaded, %FALSE othewise

 * Since: 2.6

 **/

EXPORT_C gboolean

g_key_file_load_from_data (GKeyFile       *key_file,

			   const gchar    *data,

			   gsize           length,

			   GKeyFileFlags   flags,

			   GError        **error)

{

  GError *key_file_error = NULL;

  g_return_val_if_fail (key_file != NULL, FALSE);

  g_return_val_if_fail (data != NULL, FALSE);

  g_return_val_if_fail (length != 0, FALSE);