/* -*- mode: C; c-file-style: "gnu" -*- */

/* desktop-file.c  .desktop file parser

 *

 * Copyright (C) 2003  CodeFactory AB

 * Copyright (C) 2003  Red Hat Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

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

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 * 

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

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#ifndef __SYMBIAN32__

#include <dbus/dbus-sysdeps.h>

#include <dbus/dbus-internals.h>

#else

#include "dbus-sysdeps.h"

#include "dbus-internals.h"

#endif //__SYMBIAN32__

#include "desktop-file.h"

#include "utils.h"

typedef struct

{

  char *key;

  char *value;

} BusDesktopFileLine;

typedef struct

{

  char *section_name;

  int n_lines;

  BusDesktopFileLine *lines;

  int n_allocated_lines;  

} BusDesktopFileSection;

struct BusDesktopFile

{

  int n_sections;

  BusDesktopFileSection *sections;

  int n_allocated_sections;

};

/**

 * Parser for service files.

 */

typedef struct

{

  DBusString data; /**< The data from the file */

  BusDesktopFile *desktop_file; /**< The resulting object */

  int current_section;    /**< The current section being parsed */

  int pos;          /**< Current position */

  int len;          /**< Length */

  int line_num;     /**< Current line number */

} BusDesktopFileParser;

#define VALID_KEY_CHAR 1

#define VALID_LOCALE_CHAR 2

unsigned char valid[256] = { 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x3 , 0x2 , 0x0 , 

   0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 

   0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x0 , 0x0 , 0x0 , 0x0 , 0x2 , 

   0x0 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 

   0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

   0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 

};

static void report_error (BusDesktopFileParser *parser,

			  char                 *message,

			  const char           *error_name,

			  DBusError            *error);

static void

parser_free (BusDesktopFileParser *parser)

{

  bus_desktop_file_free (parser->desktop_file);

  _dbus_string_free (&parser->data);

}

static void

bus_desktop_file_line_free (BusDesktopFileLine *line)

{

  dbus_free (line->key);

  dbus_free (line->value);

}

static void

bus_desktop_file_section_free (BusDesktopFileSection *section)

{

  int i;

  for (i = 0; i < section->n_lines; i++)

    bus_desktop_file_line_free (&section->lines[i]);

  dbus_free (section->lines);

  dbus_free (section->section_name);

}

void

bus_desktop_file_free (BusDesktopFile *desktop_file)

{

  int i;

  for (i = 0; i < desktop_file->n_sections; i++)

    bus_desktop_file_section_free (&desktop_file->sections[i]);

  dbus_free (desktop_file->sections);

  dbus_free (desktop_file);

}

static dbus_bool_t

grow_lines_in_section (BusDesktopFileSection *section)

{

  BusDesktopFileLine *lines;

  int new_n_lines;

  if (section->n_allocated_lines == 0)

    new_n_lines = 1;

  else

    new_n_lines = section->n_allocated_lines*2;

  lines = dbus_realloc (section->lines,

                        sizeof (BusDesktopFileLine) * new_n_lines);

  if (lines == NULL)

    return FALSE;

  section->lines = lines;

  section->n_allocated_lines = new_n_lines;

  return TRUE;

}

static dbus_bool_t

grow_sections (BusDesktopFile *desktop_file)

{

  int new_n_sections;

  BusDesktopFileSection *sections;

  if (desktop_file->n_allocated_sections == 0)

    new_n_sections = 1;

  else

    new_n_sections = desktop_file->n_allocated_sections*2;

  sections = dbus_realloc (desktop_file->sections,

                           sizeof (BusDesktopFileSection) * new_n_sections);

  if (sections == NULL)

    return FALSE;

  desktop_file->sections = sections;

  desktop_file->n_allocated_sections = new_n_sections;

  return TRUE;

}

static char *

unescape_string (BusDesktopFileParser *parser,

                 const DBusString     *str,

                 int                   pos,

                 int                   end_pos,

                 DBusError            *error)

{

  char *retval, *q;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  /* len + 1 is enough, because unescaping never makes the

   * string longer

   */

  retval = dbus_malloc (end_pos - pos + 1);

  if (retval == NULL)

    {

      BUS_SET_OOM (error);

      return NULL;

    }

  q = retval;

  while (pos < end_pos)

    {

      if (_dbus_string_get_byte (str, pos) == 0)

	{

	  /* Found an embedded null */

	  dbus_free (retval);

          report_error (parser, "Text to be unescaped contains embedded nul",

                        BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error);

	  return NULL;

	}

      if (_dbus_string_get_byte (str, pos) == '\\')

	{

	  pos ++;

	  if (pos >= end_pos)

	    {

	      /* Escape at end of string */

	      dbus_free (retval);

              report_error (parser, "Text to be unescaped ended in \\",

                            BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error);

	      return NULL;

	    }

	  switch (_dbus_string_get_byte (str, pos))

	    {

	    case 's':

              *q++ = ' ';

              break;

           case 't':

              *q++ = '\t';

              break;

           case 'n':

              *q++ = '\n';

              break;

           case 'r':

              *q++ = '\r';

              break;

           case '\\':

              *q++ = '\\';

              break;

           default:

	     /* Invalid escape code */

	     dbus_free (retval);

             report_error (parser, "Text to be unescaped had invalid escape sequence",

                           BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error);

             return NULL;

	    }

	  pos++;

	}

      else

	{

	  *q++ =_dbus_string_get_byte (str, pos);

	  pos++;

	}

    }

  *q = 0;

  return retval;

}

static BusDesktopFileSection* 

new_section (BusDesktopFile *desktop_file,

             const char     *name)

{

  int n;

  char *name_copy;

  if (desktop_file->n_allocated_sections == desktop_file->n_sections)

    {

      if (!grow_sections (desktop_file))

        return NULL;

    }

  name_copy = _dbus_strdup (name);

  if (name_copy == NULL)

    return NULL;

  n = desktop_file->n_sections;

  desktop_file->sections[n].section_name = name_copy;

  desktop_file->sections[n].n_lines = 0;

  desktop_file->sections[n].lines = NULL;

  desktop_file->sections[n].n_allocated_lines = 0;

  if (!grow_lines_in_section (&desktop_file->sections[n]))

    {

      dbus_free (desktop_file->sections[n].section_name);

      desktop_file->sections[n].section_name = NULL;

      return NULL;

    }

  desktop_file->n_sections += 1;

  return &desktop_file->sections[n];  

}

static BusDesktopFileSection* 

open_section (BusDesktopFileParser *parser,

              char                 *name)

{  

  BusDesktopFileSection *section;

  section = new_section (parser->desktop_file, name);

  if (section == NULL)

    return NULL;

  parser->current_section = parser->desktop_file->n_sections - 1;

  _dbus_assert (&parser->desktop_file->sections[parser->current_section] == section);

  return section;

}

static BusDesktopFileLine *

new_line (BusDesktopFileParser *parser)

{

  BusDesktopFileSection *section;

  BusDesktopFileLine *line;

  section = &parser->desktop_file->sections[parser->current_section];

  if (section->n_allocated_lines == section->n_lines)

    {

      if (!grow_lines_in_section (section))

        return NULL;

    }

  line = &section->lines[section->n_lines++];

  memset (line, 0, sizeof (BusDesktopFileLine));

  return line;

}

static dbus_bool_t

is_blank_line (BusDesktopFileParser *parser)

{

  int p;

  char c;

  p = parser->pos;

  c = _dbus_string_get_byte (&parser->data, p);

  while (c && c != '\n')

    {

      if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f'))

	return FALSE;

      p++;

      c = _dbus_string_get_byte (&parser->data, p);

    }

  return TRUE;

}

static void

parse_comment_or_blank (BusDesktopFileParser *parser)

{

  int line_end;

#ifdef __SYMBIAN32__

  int eol_len;

#endif  

#ifdef __SYMBIAN32__  

  if (!_dbus_string_find_eol (&parser->data, parser->pos, &line_end, &eol_len))

    line_end = parser->len;

#else

  if (!_dbus_string_find (&parser->data, parser->pos, "\n", &line_end))

    line_end = parser->len;

#endif  

  if (line_end == parser->len)

    parser->pos = parser->len;

  else

#ifdef __SYMBAN32__

  	parser->pos = line_end + eol_len;

#else  

    parser->pos = line_end + 1;

#endif     

  parser->line_num += 1;

}

static dbus_bool_t

is_valid_section_name (const char *name)

{

  /* 5. Group names may contain all ASCII characters except for control characters and '[' and ']'. */

  while (*name)

    {

      if (!((*name >= 'A' && *name <= 'Z') || (*name >= 'a' || *name <= 'z') ||

	    *name == '\n' || *name == '\t'))

	return FALSE;

      name++;

    }

  return TRUE;

}

static dbus_bool_t

parse_section_start (BusDesktopFileParser *parser, DBusError *error)

{

  int line_end;

#ifdef __SYMBIAN32__

  int eol_len;

#endif  

  char *section_name;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

#ifdef __SYMBIAN32__  

  if (!_dbus_string_find_eol (&parser->data, parser->pos, &line_end, &eol_len))

    line_end = parser->len;

#else

  if (!_dbus_string_find (&parser->data, parser->pos, "\n", &line_end))

    line_end = parser->len;

#endif //__SYMBIAN32__	  

  if (line_end - parser->pos <= 2 ||

      _dbus_string_get_byte (&parser->data, line_end - 1) != ']')

    {

      report_error (parser, "Invalid syntax for section header", BUS_DESKTOP_PARSE_ERROR_INVALID_SYNTAX, error);

      parser_free (parser);

      return FALSE;

    }

  section_name = unescape_string (parser,

                                  &parser->data, parser->pos + 1, line_end - 1,

                                  error);

  if (section_name == NULL)

    {

      parser_free (parser);

      return FALSE;

    }

  if (!is_valid_section_name (section_name))

    {

      report_error (parser, "Invalid characters in section name", BUS_DESKTOP_PARSE_ERROR_INVALID_CHARS, error);

      parser_free (parser);

      dbus_free (section_name);

      return FALSE;

    }

  if (open_section (parser, section_name) == NULL)

    {

      dbus_free (section_name);

      parser_free (parser);

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (line_end == parser->len)

    parser->pos = parser->len;

  else

#ifdef __SYMBIAN32__  

    parser->pos = line_end + eol_len;

#else

    parser->pos = line_end + 1;

#endif    

  parser->line_num += 1;

  dbus_free (section_name);

  return TRUE;

}

static dbus_bool_t

parse_key_value (BusDesktopFileParser *parser, DBusError *error)

{

  int line_end;

  int key_start, key_end;

  int value_start;

  int p;

  char *value, *tmp;

  DBusString key;

  BusDesktopFileLine *line;

#ifdef __SYMBIAN32__

  int eol_len;

#endif    

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

#ifdef __SYMBIAN32__

  if (!_dbus_string_find_eol (&parser->data, parser->pos, &line_end, &eol_len))

    line_end = parser->len;

#else  

  if (!_dbus_string_find (&parser->data, parser->pos, "\n", &line_end))

    line_end = parser->len;

#endif  

  p = parser->pos;

  key_start = p;

  while (p < line_end &&

	 (valid[_dbus_string_get_byte (&parser->data, p)] & VALID_KEY_CHAR))

    p++;

  key_end = p;

  if (key_start == key_end)

    {

      report_error (parser, "Empty key name", BUS_DESKTOP_PARSE_ERROR_INVALID_SYNTAX, error);

      parser_free (parser);

      return FALSE;

    }

  /* We ignore locales for now */

  if (p < line_end && _dbus_string_get_byte (&parser->data, p) == '[')

    {

      if (line_end == parser->len)

	parser->pos = parser->len;

      else

#ifdef __SYMBIAN32__

	parser->pos = line_end + eol_len;

#else      

	parser->pos = line_end + 1;

#endif