/* -*- 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 	

       parser->line_num += 1;

       return TRUE;

     }

   /* Skip space before '=' */

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

     p++;

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

     {

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

       parser_free (parser);

       return FALSE;

     }

   if (p == line_end)

     {

       report_error (parser, "No '=' in key/value pair", BUS_DESKTOP_PARSE_ERROR_INVALID_SYNTAX, error);

       parser_free (parser);

       return FALSE;

     }

   /* Skip the '=' */

   p++;

   /* Skip space after '=' */

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

     p++;

   value_start = p;

   value = unescape_string (parser, &parser->data, value_start, line_end, error);

   if (value == NULL)

     {

       parser_free (parser);

       return FALSE;

     }

   line = new_line (parser);

   if (line == NULL)

     {

       dbus_free (value);

       parser_free (parser);

       BUS_SET_OOM (error);

       return FALSE;

     }

   if (!_dbus_string_init (&key))

     {

       dbus_free (value);

       parser_free (parser);

       BUS_SET_OOM (error);

       return FALSE;

     }

   if (!_dbus_string_copy_len (&parser->data, key_start, key_end - key_start,

                               &key, 0))

     {

       _dbus_string_free (&key);

       dbus_free (value);

       parser_free (parser);

       BUS_SET_OOM (error);

       return FALSE;

     }

   if (!_dbus_string_steal_data (&key, &tmp))

     {

       _dbus_string_free (&key);

       dbus_free (value);

       parser_free (parser);

       BUS_SET_OOM (error);

       return FALSE;

     }

   _dbus_string_free (&key);

   line->key = tmp;

   line->value = value;

   if (line_end == parser->len)

     parser->pos = parser->len;

   else

     parser->pos = line_end + 1;

   parser->line_num += 1;

   return TRUE;

 }

 static void

 report_error (BusDesktopFileParser *parser,

 	      char                 *message,

 	      const char           *error_name,

 	      DBusError            *error)

 {

   const char *section_name = NULL;

   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   if (parser->current_section != -1)

     section_name = parser->desktop_file->sections[parser->current_section].section_name;

   if (section_name)

     dbus_set_error (error, error_name,

                     "Error in section %s at line %d: %s\n", section_name, parser->line_num, message);

   else

     dbus_set_error (error, error_name,

                     "Error at line %d: %s\n", parser->line_num, message);

 }

 #if 0

 static void

 dump_desktop_file (BusDesktopFile *file)

 {

   int i;

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

     {

       int j;

       printf ("[%s]\n", file->sections[i].section_name);

       for (j = 0; j < file->sections[i].n_lines; j++)

 	{

 	  printf ("%s=%s\n", file->sections[i].lines[j].key,

 		  file->sections[i].lines[j].value);

 	}

     }

 }

 #endif

 BusDesktopFile*

 bus_desktop_file_load (DBusString *filename,

 		       DBusError  *error)

 {

   DBusString str;

   BusDesktopFileParser parser;

   DBusStat sb;

   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   /* Clearly there's a race here, but it's just to make it unlikely

    * that we do something silly, we still handle doing it below.

    */

   if (!_dbus_stat (filename, &sb, error))

     return NULL;

   if (sb.size > _DBUS_ONE_KILOBYTE * 128)

     {

       dbus_set_error (error, DBUS_ERROR_FAILED,

                       "Desktop file size (%ld bytes) is too large", (long) sb.size);

       return NULL;

     }

   if (!_dbus_string_init (&str))

     {

       BUS_SET_OOM (error);

       return NULL;

     }

   if (!_dbus_file_get_contents (&str, filename, error))

     {

       _dbus_string_free (&str);

       return NULL;

     }

   if (!_dbus_string_validate_utf8 (&str, 0, _dbus_string_get_length (&str)))

     {

       _dbus_string_free (&str);

       dbus_set_error (error, DBUS_ERROR_FAILED,

                       "invalid UTF-8");   

       return NULL;

     }

   parser.desktop_file = dbus_new0 (BusDesktopFile, 1);

   if (parser.desktop_file == NULL)

     {

       _dbus_string_free (&str);

       BUS_SET_OOM (error);

       return NULL;

     }

   parser.data = str;

   parser.line_num = 1;

   parser.pos = 0;

   parser.len = _dbus_string_get_length (&parser.data);

   parser.current_section = -1;

   while (parser.pos < parser.len)

     {

       if (_dbus_string_get_byte (&parser.data, parser.pos) == '[')

 	{

 	  if (!parse_section_start (&parser, error))

             {

               return NULL;

             }

 	}

       else if (is_blank_line (&parser) ||

 	       _dbus_string_get_byte (&parser.data, parser.pos) == '#')

 	parse_comment_or_blank (&parser);

       else

 	{

 	  if (!parse_key_value (&parser, error))

             {

               return NULL;

             }

 	}

     }

   _dbus_string_free (&parser.data);

   return parser.desktop_file;

 }

 static BusDesktopFileSection *

 lookup_section (BusDesktopFile *desktop_file,

 		const char     *section_name)

 {

   BusDesktopFileSection *section;

   int i;

   if (section_name == NULL)

     return NULL;

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

     {

       section = &desktop_file->sections[i];

       if (strcmp (section->section_name, section_name) == 0)

 	return section;

     }

   return NULL;

 }

 static BusDesktopFileLine *

 lookup_line (BusDesktopFile        *desktop_file,

 	     BusDesktopFileSection *section,

 	     const char            *keyname)

 {

   BusDesktopFileLine *line;

   int i;

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

     {

       line = &section->lines[i];

       if (strcmp (line->key, keyname) == 0)

 	return line;

     }

   return NULL;

 }

 dbus_bool_t

 bus_desktop_file_get_raw (BusDesktopFile  *desktop_file,

 			  const char      *section_name,

 			  const char      *keyname,

 			  const char     **val)

 {

   BusDesktopFileSection *section;

   BusDesktopFileLine *line;

   *val = NULL;

   section = lookup_section (desktop_file, section_name);

   if (!section)

     return FALSE;

   line = lookup_line (desktop_file,

 		      section,

 		      keyname);

   if (!line)

     return FALSE;

   *val = line->value;

   return TRUE;

 }

 dbus_bool_t

 bus_desktop_file_get_string (BusDesktopFile  *desktop_file,

 			     const char      *section,

 			     const char      *keyname,

 			     char           **val,

 			     DBusError       *error)

 {

   const char *raw;

   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   *val = NULL;

   if (!bus_desktop_file_get_raw (desktop_file, section, keyname, &raw))

     {

       dbus_set_error (error, DBUS_ERROR_FAILED,

                       "No \"%s\" key in .service file\n", keyname);

       return FALSE;

     }

   *val = _dbus_strdup (raw);

   if (*val == NULL)

     {

       BUS_SET_OOM (error);

       return FALSE;

     }

   return TRUE;

 }