/*

 * Copyright © 2001, 2002 Havoc Pennington

 * Copyright © 2002 Red Hat, Inc.

 * Copyright © 2002 Sun Microsystems

 * Copyright © 2003 Mariano Suarez-Alvarez

 * Copyright © 2008, 2017 Christian Persch

 *

 * 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 <http://www.gnu.org/licenses/>.

 */

#include <config.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#include <glib.h>

#include <glib/gi18n.h>

#include <glib/gprintf.h>

#include "terminal-options.h"

#include "terminal-client-utils.h"

#include "terminal-defines.h"

#include "terminal-schemas.h"

#include "terminal-screen.h"

#include "terminal-app.h"

#include "terminal-util.h"

#include "terminal-version.h"

#include "terminal-libgsystem.h"

static int verbosity = 1;

void

terminal_fprintf (FILE* fp,

                  int verbosity_level,

                  const char* format,

                  ...)

{

  if (verbosity < verbosity_level)

    return;

  va_list args;

  va_start(args, format);

  gs_free char *str = g_strdup_vprintf(format, args);

  va_end(args);

  gs_strfreev char **lines = g_strsplit_set(str, "\n\r", -1);

  for (gsize i = 0; lines[i]; ++i) {

    if (lines[i][0] != '\0')

      g_fprintf(fp, "# %s\n", lines[i]);

  }

}

#if GLIB_CHECK_VERSION (2, 50, 0)

/* Need to install a special log writer so we never output

 * anything without the '# ' prepended, in case --print-environment

 * is used.

 */

GLogWriterOutput

terminal_log_writer (GLogLevelFlags log_level,

                     const GLogField *fields,

                     gsize n_fields,

                     gpointer user_data)

{

  for (gsize i = 0; i < n_fields; i++) {

    if (g_str_equal (fields[i].key, "MESSAGE"))

      terminal_printerr ("%s\n", (const char*)fields[i].value);

  }

  return G_LOG_WRITER_HANDLED;

}

#endif /* GLIB 2.50 */

static GOptionContext *get_goption_context (TerminalOptions *options);

static TerminalSettingsList *

terminal_options_ensure_profiles_list (TerminalOptions *options)

{

  if (options->profiles_list == NULL)

    options->profiles_list = terminal_profiles_list_new ();

  return options->profiles_list;

}

static char *

terminal_util_key_file_get_string_unescape (GKeyFile *key_file,

                                            const char *group,

                                            const char *key,

                                            GError **error)

{

  char *escaped, *unescaped;

  escaped = g_key_file_get_string (key_file, group, key, error);

  if (!escaped)

    return NULL;

  unescaped = g_strcompress (escaped);

  g_free (escaped);

  return unescaped;

}

static char **

terminal_util_key_file_get_argv (GKeyFile *key_file,

                                 const char *group,

                                 const char *key,

                                 int *argc,

                                 GError **error)

{

  char **argv;

  char *flat;

  gboolean retval;

  flat = terminal_util_key_file_get_string_unescape (key_file, group, key, error);

  if (!flat)

    return NULL;

  retval = g_shell_parse_argv (flat, argc, &argv, error);

  g_free (flat);

  if (retval)

    return argv;

  return NULL;

}

static InitialTab*

initial_tab_new (char *profile /* adopts */)

{

  InitialTab *it;

  it = g_slice_new (InitialTab);

  it->profile = profile;

  it->exec_argv = NULL;

  it->title = NULL;

  it->working_dir = NULL;

  it->zoom = 1.0;

  it->zoom_set = FALSE;

  it->active = FALSE;

  it->fd_list = NULL;

  it->fd_array = NULL;

  return it;

}

static void

initial_tab_free (InitialTab *it)

{

  g_free (it->profile);

  g_strfreev (it->exec_argv);

  g_free (it->title);

  g_free (it->working_dir);

  g_clear_object (&it->fd_list);

  if (it->fd_array)

    g_array_unref (it->fd_array);

  g_slice_free (InitialTab, it);

}

static InitialWindow*

initial_window_new (guint source_tag)

{

  InitialWindow *iw;

  iw = g_slice_new0 (InitialWindow);

  iw->source_tag = source_tag;

  return iw;

}

static void

initial_window_free (InitialWindow *iw)

{

  g_list_free_full (iw->tabs, (GDestroyNotify) initial_tab_free);

  g_free (iw->geometry);

  g_free (iw->role);

  g_slice_free (InitialWindow, iw);

}

static void

apply_window_defaults (TerminalOptions *options,

                       InitialWindow *iw)

{

  if (options->default_role)

    {

      iw->role = options->default_role;

      options->default_role = NULL;

    }

  if (iw->geometry == NULL)

    iw->geometry = g_strdup (options->default_geometry);

  if (options->default_window_menubar_forced)

    {

      iw->force_menubar_state = TRUE;

      iw->menubar_state = options->default_window_menubar_state;

      options->default_window_menubar_forced = FALSE;

    }

  iw->start_fullscreen |= options->default_fullscreen;

  iw->start_maximized |= options->default_maximize;

}

static void

apply_tab_defaults (TerminalOptions *options,

                    InitialTab *it)

{

  it->wait = options->default_wait;

}

static InitialWindow*

add_new_window (TerminalOptions *options,

                char *profile /* adopts */,

                gboolean implicit_if_first_window)

{

  InitialWindow *iw;

  InitialTab *it;

  iw = initial_window_new (0);

  iw->implicit_first_window = (options->initial_windows == NULL) && implicit_if_first_window;

  apply_window_defaults (options, iw);

  it = initial_tab_new (profile);

  iw->tabs = g_list_prepend (NULL, it);

  apply_tab_defaults (options, it);

  options->initial_windows = g_list_append (options->initial_windows, iw);

  return iw;

}

static InitialWindow*

ensure_top_window (TerminalOptions *options,

                   gboolean implicit_if_first_window)

{

  InitialWindow *iw;

  if (options->initial_windows == NULL)

    iw = add_new_window (options, NULL /* profile */, implicit_if_first_window);

  else

      iw = g_list_last (options->initial_windows)->data;

  g_assert_nonnull (iw->tabs);

  return iw;

}

static InitialTab*

ensure_top_tab (TerminalOptions *options)

{

  InitialWindow *iw;

  InitialTab *it;

  iw = ensure_top_window (options, TRUE);

  g_assert_nonnull (iw->tabs);

  it = g_list_last (iw->tabs)->data;

  return it;

}

/* handle deprecated command line options */

static void

deprecated_option_warning (const gchar *option_name)

{

  terminal_printerr (_("Option “%s” is deprecated and might be removed in a later version of gnome-terminal."),

                     option_name);

  terminal_printerr ("\n");

}

static void

deprecated_command_option_warning (const char *option_name)

{

  deprecated_option_warning (option_name);

  /* %s is being replaced with "-- " (without quotes), which must be used literally, not translatable */

  terminal_printerr (_("Use “%s” to terminate the options and put the command line to execute after it."), "-- ");

  terminal_printerr ("\n");

}

static gboolean

unsupported_option_callback (const gchar *option_name,

                             const gchar *value,

                             gpointer     data,

                             GError     **error)

{

  terminal_printerr (_("Option “%s” is no longer supported in this version of gnome-terminal."),

              option_name);

  terminal_printerr ("\n");

  return TRUE; /* we do not want to bail out here but continue */

}

static gboolean

unsupported_option_fatal_callback (const gchar *option_name,

                                   const gchar *value,

                                   gpointer     data,

                                   GError     **error)

{

  g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,

               _("Option “%s” is no longer supported in this version of gnome-terminal."),

               option_name);

  return FALSE;

}

static gboolean G_GNUC_NORETURN

option_version_cb (const gchar *option_name,

                   const gchar *value,

                   gpointer     data,

                   GError     **error)

{

  terminal_print ("GNOME Terminal %s using VTE %u.%u.%u %s\n",

                  VERSION,

                  vte_get_major_version (),

                  vte_get_minor_version (),

                  vte_get_micro_version (),

                  vte_get_features ());

  exit (EXIT_SUCCESS);

}

static gboolean

option_verbosity_cb (const gchar *option_name,

                     const gchar *value,

                     gpointer     data,

                     GError     **error)

{

  if (g_str_equal (option_name, "--quiet") || g_str_equal (option_name, "-q"))

    verbosity = 0;

  else

    verbosity++;

  return TRUE;

}

static gboolean

option_app_id_callback (const gchar *option_name,

                          const gchar *value,

                          gpointer     data,

                          GError     **error)

{

  TerminalOptions *options = data;

  if (!g_application_id_is_valid (value)) {

    g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,

                 "\"%s\" is not a valid application ID", value);

    return FALSE;

  }

  g_free (options->server_app_id);

  options->server_app_id = g_strdup (value);

  return TRUE;

}

static gboolean

option_command_callback (const gchar *option_name,

                         const gchar *value,

                         gpointer     data,

                         GError     **error)

{

  TerminalOptions *options = data;

  GError *err = NULL;

  char  **exec_argv;

  deprecated_command_option_warning (option_name);

  if (!g_shell_parse_argv (value, NULL, &exec_argv, &err))

    {

      g_set_error(error,

                  G_OPTION_ERROR,

                  G_OPTION_ERROR_BAD_VALUE,

                  _("Argument to “%s” is not a valid command: %s"),

                   "--command/-e",

                  err->message);

      g_error_free (err);

      return FALSE;

    }

  if (options->initial_windows)

    {

      InitialTab *it = ensure_top_tab (options);

      g_strfreev (it->exec_argv);

      it->exec_argv = exec_argv;

    }

  else

    {

      g_strfreev (options->exec_argv);

      options->exec_argv = exec_argv;

    }

  return TRUE;

}

static gboolean

option_profile_cb (const gchar *option_name,

                   const gchar *value,

                   gpointer     data,

                   GError     **error)

{

  TerminalOptions *options = data;

  char *profile;

  profile = terminal_profiles_list_dup_uuid_or_name (terminal_options_ensure_profiles_list (options),

                                                     value, error);

  if (profile == NULL)

  {

      terminal_printerr ("Profile '%s' specified but not found. Attempting to fall back "

                         "to the default profile.\n", value);

      g_clear_error (error);

      profile = terminal_profiles_list_dup_uuid_or_name (terminal_options_ensure_profiles_list (options),

                                                         NULL, error);

  }

  if (profile == NULL)

      return FALSE;

  if (options->initial_windows)

    {

      InitialTab *it = ensure_top_tab (options);

      g_free (it->profile);

      it->profile = profile;

    }

  else

    {

      g_free (options->default_profile);

      options->default_profile = profile;

    }

  return TRUE;

}

static gboolean

option_profile_id_cb (const gchar *option_name,

                      const gchar *value,

                      gpointer     data,

                      GError     **error)

{

  TerminalOptions *options = data;

  char *profile;

  profile = terminal_profiles_list_dup_uuid (terminal_options_ensure_profiles_list (options),

                                             value, error);

  if (profile == NULL)

    return FALSE;

  if (options->initial_windows)

    {

      InitialTab *it = ensure_top_tab (options);

      g_free (it->profile);

      it->profile = profile;

    }

  else

    {

      g_free (options->default_profile);

      options->default_profile = profile;

    }

  return TRUE;

}

static gboolean

option_window_callback (const gchar *option_name,

                        const gchar *value,

                        gpointer     data,

                        GError     **error)

{

  TerminalOptions *options = data;

  char *profile;

  if (value != NULL) {

    profile = terminal_profiles_list_dup_uuid_or_name (terminal_options_ensure_profiles_list (options),

                                                       value, error);

    if (value && profile == NULL) {

      terminal_printerr ("Profile '%s' specified but not found. Attempting to fall back "

                         "to the default profile.\n", value);

      g_clear_error (error);

      profile = terminal_profiles_list_dup_uuid_or_name (terminal_options_ensure_profiles_list (options),

                                                         NULL, error);

    }

    if (profile == NULL)

      return FALSE;

  } else

    profile = NULL;

  add_new_window (options, profile /* adopts */, FALSE);

  return TRUE;

}

static gboolean

option_tab_callback (const gchar *option_name,

                     const gchar *value,

                     gpointer     data,

                     GError     **error)

{

  TerminalOptions *options = data;

  char *profile;

  if (value != NULL) {

    profile = terminal_profiles_list_dup_uuid_or_name (terminal_options_ensure_profiles_list (options),

                                                       value, error);

    if (profile == NULL)

      return FALSE;

  } else

    profile = NULL;

  if (options->initial_windows)

    {

      InitialWindow *iw;

      iw = g_list_last (options->initial_windows)->data;

      iw->tabs = g_list_append (iw->tabs, initial_tab_new (profile /* adopts */));

    }

  else

    add_new_window (options, profile /* adopts */, TRUE);

  return TRUE;

}

static gboolean

option_role_callback (const gchar *option_name,

                      const gchar *value,

                      gpointer     data,

                      GError     **error)

{

  TerminalOptions *options = data;

  InitialWindow *iw;

  if (options->initial_windows)

    {

      iw = g_list_last (options->initial_windows)->data;

      iw->role = g_strdup (value);

    }

  else if (!options->default_role)

    options->default_role = g_strdup (value);

  else

    {

      g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED,

                   "%s", _("Two roles given for one window"));

      return FALSE;

    }

  return TRUE;

}

static gboolean

option_show_menubar_callback (const gchar *option_name,

                              const gchar *value,

                              gpointer     data,

                              GError     **error)

{

  TerminalOptions *options = data;

  InitialWindow *iw;

  if (options->initial_windows)

    {

      iw = g_list_last (options->initial_windows)->data;

      if (iw->force_menubar_state && iw->menubar_state == TRUE)

        {

          terminal_printerr_detail (_("“%s” option given twice for the same window\n"),

                                    "--show-menubar");

          return TRUE;

        }

      iw->force_menubar_state = TRUE;

      iw->menubar_state = TRUE;

    }

  else

    {

      options->default_window_menubar_forced = TRUE;

      options->default_window_menubar_state = TRUE;

    }

  return TRUE;

}

static gboolean

option_hide_menubar_callback (const gchar *option_name,

                              const gchar *value,

                              gpointer     data,

                              GError     **error)

{

  TerminalOptions *options = data;

  InitialWindow *iw;

  if (options->initial_windows)

    {

      iw = g_list_last (options->initial_windows)->data;

      if (iw->force_menubar_state && iw->menubar_state == FALSE)

        {

          terminal_printerr_detail (_("“%s” option given twice for the same window\n"),

                                    "--hide-menubar");

          return TRUE;

        }

      iw->force_menubar_state = TRUE;

      iw->menubar_state = FALSE;

    }

  else

    {

      options->default_window_menubar_forced = TRUE;

      options->default_window_menubar_state = FALSE;

    }

  return TRUE;

}

static gboolean

option_maximize_callback (const gchar *option_name,

                          const gchar *value,

                          gpointer     data,

                          GError     **error)

{

  TerminalOptions *options = data;

  InitialWindow *iw;

  if (options->initial_windows)

    {

      iw = g_list_last (options->initial_windows)->data;

      iw->start_maximized = TRUE;

    }

  else

    options->default_maximize = TRUE;

  return TRUE;

}

static gboolean

option_fullscreen_callback (const gchar *option_name,

                            const gchar *value,

                            gpointer     data,

                            GError     **error)

{

  TerminalOptions *options = data;

  if (options->initial_windows)

    {

      InitialWindow *iw;

      iw = g_list_last (options->initial_windows)->data;

      iw->start_fullscreen = TRUE;

    }

  else

    options->default_fullscreen = TRUE;

  return TRUE;

}

static gboolean

option_geometry_callback (const gchar *option_name,

                          const gchar *value,

                          gpointer     data,

                          GError     **error)

{

  TerminalOptions *options = data;

  if (options->initial_windows)

    {

      InitialWindow *iw;

      iw = g_list_last (options->initial_windows)->data;

      iw->geometry = g_strdup (value);

    }

  else

    options->default_geometry = g_strdup (value);

  return TRUE;

}

static gboolean

option_load_config_cb (const gchar *option_name,

                       const gchar *value,

                       gpointer     data,

                       GError     **error)

{

  TerminalOptions *options = data;

  GFile *file;

  char *config_file;

  GKeyFile *key_file;

  gboolean result;

  file = g_file_new_for_commandline_arg (value);

  config_file = g_file_get_path (file);

  g_object_unref (file);

  key_file = g_key_file_new ();

  result = g_key_file_load_from_file (key_file, config_file, 0, error) &&

           terminal_options_merge_config (options, key_file,

                                          strcmp (option_name, "load-config") == 0 ? SOURCE_DEFAULT : SOURCE_SESSION,

                                          error);

  g_key_file_free (key_file);

  g_free (config_file);

  return result;

}

static gboolean

option_title_callback (const gchar *option_name,

                       const gchar *value,

                       gpointer     data,

                       GError     **error)

{

  TerminalOptions *options = data;

  if (options->initial_windows)

    {

      InitialTab *it = ensure_top_tab (options);

      g_free (it->title);

      it->title = g_strdup (value);

    }

  else

    {

      g_free (options->default_title);

      options->default_title = g_strdup (value);

    }

  return TRUE;

}

static gboolean

option_working_directory_callback (const gchar *option_name,

                                   const gchar *value,

                                   gpointer     data,

                                   GError     **error)

{

  TerminalOptions *options = data;

  if (options->initial_windows)

    {

      InitialTab *it = ensure_top_tab (options);

      g_free (it->working_dir);

      it->working_dir = g_strdup (value);

    }

  else

    {

      g_free (options->default_working_dir);

      options->default_working_dir = g_strdup (value);

    }

  return TRUE;

}

static gboolean

option_wait_cb (const gchar *option_name,

                const gchar *value,

                gpointer     data,

                GError     **error)

{

  TerminalOptions *options = data;

  if (options->initial_windows)

    {

      InitialTab *it = ensure_top_tab (options);

      g_free (it->working_dir);

      it->wait = TRUE;

    }

  else

    {

      options->default_wait = TRUE;

    }

  return TRUE;

}

static gboolean

option_pass_fd_cb (const gchar *option_name,

                   const gchar *value,

                   gpointer     data,

                   GError     **error)

{

  TerminalOptions *options = data;

  errno = 0;

  char *end;

  gint64 v = g_ascii_strtoll (value, &end, 10);

  if (errno || end == value || v == -1 || v < G_MININT || v > G_MAXINT) {

    g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,

                 "Failed to parse \"%s\" as file descriptor number",

                 value);

    return FALSE;

  }

  int fd = v;

  if (fd == STDIN_FILENO ||

      fd == STDOUT_FILENO ||

      fd == STDERR_FILENO) {

    g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,

                 "FD passing of %s is not supported",

                 fd == STDIN_FILENO ? "stdin" : fd == STDOUT_FILENO ? "stdout" : "stderr");

    return FALSE;

  }

  InitialTab *it = ensure_top_tab (options);

  if (it->fd_list == NULL)

    it->fd_list = g_unix_fd_list_new ();

  if (it->fd_array == NULL)

    it->fd_array = g_array_sized_new (FALSE /* zero terminate */,

                                      TRUE /* clear */,

                                      sizeof (PassFdElement),

                                      8 /* that should be plenty */);

  for (guint i = 0; i < it->fd_array->len; i++) {

    PassFdElement *e = &g_array_index (it->fd_array, PassFdElement, i);

    if (e->fd == fd) {

      g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,

                   _("Cannot pass FD %d twice"), fd);

      return FALSE;

    }

  }

  int idx = g_unix_fd_list_append (it->fd_list, fd, error);

  if (idx == -1) {

    g_prefix_error (error, "%d: ", fd);

    return FALSE;

  }

  PassFdElement e = { idx, fd };

  g_array_append_val (it->fd_array, e);

#if 0

  if (fd == STDOUT_FILENO ||

      fd == STDERR_FILENO)

    verbosity = 0;

  if (fd == STDIN_FILENO)

    it->wait = TRUE;

#endif

  return TRUE;

}

static gboolean

option_active_callback (const gchar *option_name,

                        const gchar *value,

                        gpointer     data,

                        GError     **error)

{

  TerminalOptions *options = data;

  InitialTab *it;

  it = ensure_top_tab (options);

  it->active = TRUE;

  return TRUE;

}

static gboolean

option_zoom_callback (const gchar *option_name,

                      const gchar *value,

                      gpointer     data,

                      GError     **error)

{

  TerminalOptions *options = data;

  double zoom;