Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 518 insertions, 0 deletions

diff --git a/app/plug-in/gimpenvirontable.c b/app/plug-in/gimpenvirontable.c
new file mode 100644
index 0000000..82f2840
--- /dev/null
+++ b/app/plug-in/gimpenvirontable.c
@@ -0,0 +1,518 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpenvirontable.c
+ * (C) 2002 Manish Singh <yosh@gimp.org>
+ *
+ * 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 3 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, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gio/gio.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
+
+#include "plug-in-types.h"
+
+#include "gimpenvirontable.h"
+
+#include "gimp-intl.h"
+
+
+typedef struct _GimpEnvironValue GimpEnvironValue;
+
+struct _GimpEnvironValue
+{
+  gchar *value;
+  gchar *separator;
+};
+
+
+static void     gimp_environ_table_finalize       (GObject               *object);
+
+static void     gimp_environ_table_load_env_file  (GimpEnvironTable      *environ_table,
+                                                   GFile                 *file);
+static gboolean gimp_environ_table_legal_name     (gchar                 *name);
+
+static void     gimp_environ_table_populate       (GimpEnvironTable      *environ_table);
+static void     gimp_environ_table_populate_one   (const gchar           *name,
+                                                   GimpEnvironValue      *val,
+                                                   GPtrArray             *env_array);
+static gboolean gimp_environ_table_pass_through   (GimpEnvironTable      *environ_table,
+                                                   const gchar           *name);
+
+static void     gimp_environ_table_clear_vars     (GimpEnvironTable      *environ_table);
+static void     gimp_environ_table_clear_internal (GimpEnvironTable      *environ_table);
+static void     gimp_environ_table_clear_envp     (GimpEnvironTable      *environ_table);
+
+static void     gimp_environ_table_free_value     (GimpEnvironValue      *val);
+
+
+G_DEFINE_TYPE (GimpEnvironTable, gimp_environ_table, G_TYPE_OBJECT)
+
+#define parent_class gimp_environ_table_parent_class
+
+
+static void
+gimp_environ_table_class_init (GimpEnvironTableClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = gimp_environ_table_finalize;
+}
+
+static void
+gimp_environ_table_init (GimpEnvironTable *environ_table)
+{
+}
+
+static void
+gimp_environ_table_finalize (GObject *object)
+{
+  GimpEnvironTable *environ_table = GIMP_ENVIRON_TABLE (object);
+
+  gimp_environ_table_clear_all (environ_table);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+GimpEnvironTable *
+gimp_environ_table_new (gboolean verbose)
+{
+  GimpEnvironTable *table = g_object_new (GIMP_TYPE_ENVIRON_TABLE, NULL);
+
+  table->verbose = verbose;
+
+  return table;
+}
+
+static guint
+gimp_environ_table_str_hash (gconstpointer v)
+{
+#ifdef G_OS_WIN32
+  gchar *p      = g_ascii_strup ((const gchar *) v, -1);
+  guint  retval = g_str_hash (p);
+
+  g_free (p);
+
+  return retval;
+#else
+  return g_str_hash (v);
+#endif
+}
+
+static gboolean
+gimp_environ_table_str_equal (gconstpointer v1,
+                              gconstpointer v2)
+{
+#ifdef G_OS_WIN32
+  gchar    *string1 = g_ascii_strup ((const gchar *) v1, -1);
+  gchar    *string2 = g_ascii_strup ((const gchar *) v2, -1);
+  gboolean  retval  = g_str_equal (string1, string2);
+
+  g_free (string1);
+  g_free (string2);
+
+  return retval;
+#else
+  return g_str_equal (v1, v2);
+#endif
+}
+
+void
+gimp_environ_table_load (GimpEnvironTable *environ_table,
+                         GList            *path)
+{
+  GList *list;
+
+  g_return_if_fail (GIMP_IS_ENVIRON_TABLE (environ_table));
+
+  gimp_environ_table_clear (environ_table);
+
+  environ_table->vars =
+    g_hash_table_new_full (gimp_environ_table_str_hash,
+                           gimp_environ_table_str_equal,
+                           g_free,
+                           (GDestroyNotify) gimp_environ_table_free_value);
+
+  for (list = path; list; list = g_list_next (list))
+    {
+      GFile           *dir = list->data;
+      GFileEnumerator *enumerator;
+
+      enumerator =
+        g_file_enumerate_children (dir,
+                                   G_FILE_ATTRIBUTE_STANDARD_NAME ","
+                                   G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
+                                   G_FILE_ATTRIBUTE_STANDARD_TYPE,
+                                   G_FILE_QUERY_INFO_NONE,
+                                   NULL, NULL);
+
+      if (enumerator)
+        {
+          GFileInfo *info;
+
+          while ((info = g_file_enumerator_next_file (enumerator,
+                                                      NULL, NULL)))
+            {
+              if (! g_file_info_get_is_hidden (info) &&
+                  g_file_info_get_file_type (info) == G_FILE_TYPE_REGULAR)
+                {
+                  GFile *file = g_file_enumerator_get_child (enumerator, info);
+
+                  gimp_environ_table_load_env_file (environ_table, file);
+
+                  g_object_unref (file);
+                }
+
+              g_object_unref (info);
+            }
+
+          g_object_unref (enumerator);
+        }
+    }
+}
+
+void
+gimp_environ_table_add (GimpEnvironTable *environ_table,
+                        const gchar      *name,
+                        const gchar      *value,
+                        const gchar      *separator)
+{
+  GimpEnvironValue *val;
+
+  g_return_if_fail (GIMP_IS_ENVIRON_TABLE (environ_table));
+
+  gimp_environ_table_clear_envp (environ_table);
+
+  if (! environ_table->internal)
+    environ_table->internal =
+      g_hash_table_new_full (g_str_hash, g_str_equal,
+                             g_free,
+                             (GDestroyNotify) gimp_environ_table_free_value);
+
+  val = g_slice_new (GimpEnvironValue);
+
+  val->value     = g_strdup (value);
+  val->separator = g_strdup (separator);
+
+  g_hash_table_insert (environ_table->internal, g_strdup (name), val);
+}
+
+void
+gimp_environ_table_remove (GimpEnvironTable *environ_table,
+                           const gchar      *name)
+{
+  g_return_if_fail (GIMP_IS_ENVIRON_TABLE (environ_table));
+
+  if (! environ_table->internal)
+    return;
+
+  gimp_environ_table_clear_envp (environ_table);
+
+  g_hash_table_remove (environ_table->internal, name);
+
+  if (g_hash_table_size (environ_table->internal) == 0)
+    gimp_environ_table_clear_internal (environ_table);
+}
+
+void
+gimp_environ_table_clear (GimpEnvironTable *environ_table)
+{
+  g_return_if_fail (GIMP_IS_ENVIRON_TABLE (environ_table));
+
+  gimp_environ_table_clear_envp (environ_table);
+
+  gimp_environ_table_clear_vars (environ_table);
+}
+
+void
+gimp_environ_table_clear_all (GimpEnvironTable *environ_table)
+{
+  g_return_if_fail (GIMP_IS_ENVIRON_TABLE (environ_table));
+
+  gimp_environ_table_clear_envp (environ_table);
+
+  gimp_environ_table_clear_vars (environ_table);
+  gimp_environ_table_clear_internal (environ_table);
+}
+
+gchar **
+gimp_environ_table_get_envp (GimpEnvironTable *environ_table)
+{
+  g_return_val_if_fail (GIMP_IS_ENVIRON_TABLE (environ_table), NULL);
+
+  /* Hmm.. should we return a copy here in the future? Not thread safe atm,
+   * but the rest of it isn't either.
+   */
+
+  if (! environ_table->envp)
+    gimp_environ_table_populate (environ_table);
+
+  return environ_table->envp;
+}
+
+
+/* private */
+
+static void
+gimp_environ_table_load_env_file (GimpEnvironTable *environ_table,
+                                  GFile            *file)
+{
+  GInputStream     *input;
+  GDataInputStream *data_input;
+  gchar            *buffer;
+  gsize             buffer_len;
+  GError           *error = NULL;
+
+  if (environ_table->verbose)
+    g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file));
+
+  input = G_INPUT_STREAM (g_file_read (file, NULL, &error));
+  if (! input)
+    {
+      g_message (_("Could not open '%s' for reading: %s"),
+                 gimp_file_get_utf8_name (file),
+                 error->message);
+      g_clear_error (&error);
+      return;
+    }
+
+  data_input = g_data_input_stream_new (input);
+  g_object_unref (input);
+
+  while ((buffer = g_data_input_stream_read_line (data_input, &buffer_len,
+                                                  NULL, &error)))
+    {
+      gchar *name;
+      gchar *value;
+      gchar *separator;
+      gchar *p;
+      gchar *q;
+
+      /* Skip comments */
+      if (buffer[0] == '#')
+        {
+          g_free (buffer);
+          continue;
+        }
+
+      p = strchr (buffer, '=');
+      if (! p)
+        {
+          g_free (buffer);
+          continue;
+        }
+
+      *p = '\0';
+
+      name = buffer;
+      value = p + 1;
+
+      if (name[0] == '\0')
+        {
+          g_message (_("Empty variable name in environment file %s"),
+                     gimp_file_get_utf8_name (file));
+          g_free (buffer);
+          continue;
+        }
+
+      separator = NULL;
+
+      q = strchr (name, ' ');
+      if (q)
+        {
+          *q = '\0';
+
+          separator = name;
+          name = q + 1;
+        }
+
+      if (! gimp_environ_table_legal_name (name))
+        {
+          g_message (_("Illegal variable name in environment file %s: %s"),
+                     gimp_file_get_utf8_name (file), name);
+          g_free (buffer);
+          continue;
+        }
+
+      if (! g_hash_table_lookup (environ_table->vars, name))
+        {
+          GimpEnvironValue *val = g_slice_new (GimpEnvironValue);
+
+          val->value     = gimp_config_path_expand (value, FALSE, NULL);
+          val->separator = g_strdup (separator);
+
+          g_hash_table_insert (environ_table->vars, g_strdup (name), val);
+        }
+
+      g_free (buffer);
+    }
+
+  if (error)
+    {
+      g_message (_("Error reading '%s': %s"),
+                 gimp_file_get_utf8_name (file),
+                 error->message);
+      g_clear_error (&error);
+    }
+
+  g_object_unref (data_input);
+}
+
+static gboolean
+gimp_environ_table_legal_name (gchar *name)
+{
+  gchar *s;
+
+  if (! g_ascii_isalpha (*name) && (*name != '_'))
+    return FALSE;
+
+  for (s = name + 1; *s; s++)
+    if (! g_ascii_isalnum (*s) && (*s != '_'))
+      return FALSE;
+
+  return TRUE;
+}
+
+static void
+gimp_environ_table_populate (GimpEnvironTable *environ_table)
+{
+  gchar     **env = g_listenv ();
+  gchar     **var;
+  GPtrArray  *env_array;
+
+  var = env;
+  env_array = g_ptr_array_new ();
+
+  while (*var)
+    {
+      /* g_listenv() only returns the names of environment variables
+       * that are correctly specified (name=value) in the environ
+       * array (Unix) or the process environment string table (Win32).
+       */
+
+      if (gimp_environ_table_pass_through (environ_table, *var))
+        g_ptr_array_add (env_array, g_strconcat (*var, "=", g_getenv (*var), NULL));
+
+      var++;
+    }
+
+  g_strfreev (env);
+
+  if (environ_table->vars)
+    g_hash_table_foreach (environ_table->vars,
+                          (GHFunc) gimp_environ_table_populate_one,
+                          env_array);
+
+  if (environ_table->internal)
+    g_hash_table_foreach (environ_table->internal,
+                          (GHFunc) gimp_environ_table_populate_one,
+                          env_array);
+
+  g_ptr_array_add (env_array, NULL);
+
+  environ_table->envp = (gchar **) g_ptr_array_free (env_array, FALSE);
+
+#ifdef ENVP_DEBUG
+  var = environ_table->envp;
+
+  g_print ("GimpEnvironTable:\n");
+  while (*var)
+    {
+      g_print ("%s\n", *var);
+      var++;
+    }
+#endif /* ENVP_DEBUG */
+}
+
+static void
+gimp_environ_table_populate_one (const gchar      *name,
+                                 GimpEnvironValue *val,
+                                 GPtrArray        *env_array)
+{
+  const gchar *old;
+  gchar *var = NULL;
+
+  if (val->separator)
+    {
+      old = g_getenv (name);
+
+      if (old)
+        var = g_strconcat (name, "=", val->value, val->separator, old, NULL);
+    }
+
+  if (! var)
+    var = g_strconcat (name, "=", val->value, NULL);
+
+  g_ptr_array_add (env_array, var);
+}
+
+static gboolean
+gimp_environ_table_pass_through (GimpEnvironTable *environ_table,
+                                 const gchar      *name)
+{
+  gboolean vars, internal;
+
+  vars = environ_table->vars &&
+         g_hash_table_lookup (environ_table->vars, name);
+
+  internal = environ_table->internal &&
+             g_hash_table_lookup (environ_table->internal, name);
+
+  return (!vars && !internal);
+}
+
+static void
+gimp_environ_table_clear_vars (GimpEnvironTable *environ_table)
+{
+  if (environ_table->vars)
+    {
+      g_hash_table_destroy (environ_table->vars);
+      environ_table->vars = NULL;
+    }
+}
+
+static void
+gimp_environ_table_clear_internal (GimpEnvironTable *environ_table)
+{
+  if (environ_table->internal)
+    {
+      g_hash_table_destroy (environ_table->internal);
+      environ_table->internal = NULL;
+    }
+}
+
+static void
+gimp_environ_table_clear_envp (GimpEnvironTable *environ_table)
+{
+  if (environ_table->envp)
+    {
+      g_strfreev (environ_table->envp);
+      environ_table->envp = NULL;
+    }
+}
+
+static void
+gimp_environ_table_free_value (GimpEnvironValue *val)
+{
+  g_free (val->value);
+  g_free (val->separator);
+
+  g_slice_free (GimpEnvironValue, val);
+}