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

/*

 * Copyright 2012 Red Hat, Inc.

 *           2012 Stef Walter <stefw@gnome.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 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.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Author: Stef Walter <stefw@gnome.org>

 */

#include "config.h"

#include "shell-keyring-prompt.h"

#include "shell-secure-text-buffer.h"

#define GCR_API_SUBJECT_TO_CHANGE

#include <gcr/gcr-base.h>

#include <glib/gi18n.h>

#include <string.h>

typedef struct _ShellPasswordPromptPrivate  ShellPasswordPromptPrivate;

typedef enum

{

  PROMPTING_NONE,

  PROMPTING_FOR_CONFIRM,

  PROMPTING_FOR_PASSWORD

} PromptingMode;

struct _ShellKeyringPrompt

{

  GObject parent;

  gchar *title;

  gchar *message;

  gchar *description;

  gchar *warning;

  gchar *choice_label;

  gboolean choice_chosen;

  gboolean password_new;

  guint password_strength;

  gchar *continue_label;

  gchar *cancel_label;

  GTask *task;

  ClutterText *password_actor;

  ClutterText *confirm_actor;

  PromptingMode mode;

  gboolean shown;

};

enum {

  PROP_0,

  PROP_TITLE,

  PROP_MESSAGE,

  PROP_DESCRIPTION,

  PROP_WARNING,

  PROP_CHOICE_LABEL,

  PROP_CHOICE_CHOSEN,

  PROP_PASSWORD_NEW,

  PROP_PASSWORD_STRENGTH,

  PROP_CALLER_WINDOW,

  PROP_CONTINUE_LABEL,

  PROP_CANCEL_LABEL,

  PROP_PASSWORD_VISIBLE,

  PROP_CONFIRM_VISIBLE,

  PROP_WARNING_VISIBLE,

  PROP_CHOICE_VISIBLE,

  PROP_PASSWORD_ACTOR,

  PROP_CONFIRM_ACTOR

};

static void    shell_keyring_prompt_iface     (GcrPromptIface *iface);

G_DEFINE_TYPE_WITH_CODE (ShellKeyringPrompt, shell_keyring_prompt, G_TYPE_OBJECT,

                         G_IMPLEMENT_INTERFACE (GCR_TYPE_PROMPT, shell_keyring_prompt_iface);

);

enum {

  SIGNAL_SHOW_PASSWORD,

  SIGNAL_SHOW_CONFIRM,

  SIGNAL_LAST

};

static gint signals[SIGNAL_LAST];

static void

shell_keyring_prompt_init (ShellKeyringPrompt *self)

{

}

static gchar *

remove_mnemonics (const GValue *value)

{

  const gchar mnemonic = '_';

  gchar *stripped_label, *temp;

  const gchar *label;

  g_return_val_if_fail (value != NULL, NULL);

  g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);

  label = g_value_get_string (value);

  g_return_val_if_fail (label != NULL, NULL);

  /* Stripped label will have the original label lenght at most */

  stripped_label = temp = g_new (gchar, strlen(label) + 1);

  g_assert (stripped_label != NULL);

  while (*label != '\0')

    {

      if (*label == mnemonic)

        label++;

      *(temp++) = *(label++);

    }

  *temp = '\0';

  return stripped_label;

}

static void

shell_keyring_prompt_set_property (GObject      *obj,

                                   guint         prop_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (obj);

  switch (prop_id) {

  case PROP_TITLE:

    g_free (self->title);

    self->title = g_value_dup_string (value);

    g_object_notify (obj, "title");

    break;

  case PROP_MESSAGE:

    g_free (self->message);

    self->message = g_value_dup_string (value);

    g_object_notify (obj, "message");

    break;

  case PROP_DESCRIPTION:

    g_free (self->description);

    self->description = g_value_dup_string (value);

    g_object_notify (obj, "description");

    break;

  case PROP_WARNING:

    g_free (self->warning);

    self->warning = g_value_dup_string (value);

    if (!self->warning)

        self->warning = g_strdup ("");

    g_object_notify (obj, "warning");

    g_object_notify (obj, "warning-visible");

    break;

  case PROP_CHOICE_LABEL:

    g_free (self->choice_label);

    self->choice_label = remove_mnemonics (value);

    if (!self->choice_label)

        self->choice_label = g_strdup ("");

    g_object_notify (obj, "choice-label");

    g_object_notify (obj, "choice-visible");

    break;

  case PROP_CHOICE_CHOSEN:

    self->choice_chosen = g_value_get_boolean (value);

    g_object_notify (obj, "choice-chosen");

    break;

  case PROP_PASSWORD_NEW:

    self->password_new = g_value_get_boolean (value);

    g_object_notify (obj, "password-new");

    g_object_notify (obj, "confirm-visible");

    break;

  case PROP_CALLER_WINDOW:

    /* ignored */

    break;

  case PROP_CONTINUE_LABEL:

    g_free (self->continue_label);

    self->continue_label = remove_mnemonics (value);

    g_object_notify (obj, "continue-label");

    break;

  case PROP_CANCEL_LABEL:

    g_free (self->cancel_label);

    self->cancel_label = remove_mnemonics (value);

    g_object_notify (obj, "cancel-label");

    break;

  case PROP_PASSWORD_ACTOR:

    shell_keyring_prompt_set_password_actor (self, g_value_get_object (value));

    break;

  case PROP_CONFIRM_ACTOR:

    shell_keyring_prompt_set_confirm_actor (self, g_value_get_object (value));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);

    break;

  }

}

static void

shell_keyring_prompt_get_property (GObject    *obj,

                                   guint       prop_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (obj);

  switch (prop_id) {

  case PROP_TITLE:

    g_value_set_string (value, self->title ? self->title : "");

    break;

  case PROP_MESSAGE:

    g_value_set_string (value, self->message ? self->message : "");

    break;

  case PROP_DESCRIPTION:

    g_value_set_string (value, self->description ? self->description : "");

    break;

  case PROP_WARNING:

    g_value_set_string (value, self->warning ? self->warning : "");

    break;

  case PROP_CHOICE_LABEL:

    g_value_set_string (value, self->choice_label ? self->choice_label : "");

    break;

  case PROP_CHOICE_CHOSEN:

    g_value_set_boolean (value, self->choice_chosen);

    break;

  case PROP_PASSWORD_NEW:

    g_value_set_boolean (value, self->password_new);

    break;

  case PROP_PASSWORD_STRENGTH:

    g_value_set_int (value, self->password_strength);

    break;

  case PROP_CALLER_WINDOW:

    g_value_set_string (value, "");

    break;

  case PROP_CONTINUE_LABEL:

    g_value_set_string (value, self->continue_label);

    break;

  case PROP_CANCEL_LABEL:

    g_value_set_string (value, self->cancel_label);

    break;

  case PROP_PASSWORD_VISIBLE:

    g_value_set_boolean (value, self->mode == PROMPTING_FOR_PASSWORD);

    break;

  case PROP_CONFIRM_VISIBLE:

    g_value_set_boolean (value, self->password_new &&

                                self->mode == PROMPTING_FOR_PASSWORD);

    break;

  case PROP_WARNING_VISIBLE:

    g_value_set_boolean (value, self->warning && self->warning[0]);

    break;

  case PROP_CHOICE_VISIBLE:

    g_value_set_boolean (value, self->choice_label && self->choice_label[0]);

    break;

  case PROP_PASSWORD_ACTOR:

    g_value_set_object (value, shell_keyring_prompt_get_password_actor (self));

    break;

  case PROP_CONFIRM_ACTOR:

    g_value_set_object (value, shell_keyring_prompt_get_confirm_actor (self));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);

    break;

  }

}

static void

shell_keyring_prompt_dispose (GObject *obj)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (obj);

  if (self->shown)

    gcr_prompt_close (GCR_PROMPT (self));

  if (self->task)

    shell_keyring_prompt_cancel (self);

  g_assert (self->task == NULL);

  shell_keyring_prompt_set_password_actor (self, NULL);

  shell_keyring_prompt_set_confirm_actor (self, NULL);

  G_OBJECT_CLASS (shell_keyring_prompt_parent_class)->dispose (obj);

}

static void

shell_keyring_prompt_finalize (GObject *obj)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (obj);

  g_free (self->title);

  g_free (self->message);

  g_free (self->description);

  g_free (self->warning);

  g_free (self->choice_label);

  g_free (self->continue_label);

  g_free (self->cancel_label);

  G_OBJECT_CLASS (shell_keyring_prompt_parent_class)->finalize (obj);

}

static void

shell_keyring_prompt_class_init (ShellKeyringPromptClass *klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->get_property = shell_keyring_prompt_get_property;

  gobject_class->set_property = shell_keyring_prompt_set_property;

  gobject_class->dispose = shell_keyring_prompt_dispose;

  gobject_class->finalize = shell_keyring_prompt_finalize;

  g_object_class_override_property (gobject_class, PROP_TITLE, "title");

  g_object_class_override_property (gobject_class, PROP_MESSAGE, "message");

  g_object_class_override_property (gobject_class, PROP_DESCRIPTION, "description");

  g_object_class_override_property (gobject_class, PROP_WARNING, "warning");

  g_object_class_override_property (gobject_class, PROP_PASSWORD_NEW, "password-new");

  g_object_class_override_property (gobject_class, PROP_PASSWORD_STRENGTH, "password-strength");

  g_object_class_override_property (gobject_class, PROP_CHOICE_LABEL, "choice-label");

  g_object_class_override_property (gobject_class, PROP_CHOICE_CHOSEN, "choice-chosen");

  g_object_class_override_property (gobject_class, PROP_CALLER_WINDOW, "caller-window");

  g_object_class_override_property (gobject_class, PROP_CONTINUE_LABEL, "continue-label");

  g_object_class_override_property (gobject_class, PROP_CANCEL_LABEL, "cancel-label");

  /**

   * ShellKeyringPrompt:password-visible:

   *

   * Whether the password entry is visible or not.

   */

  g_object_class_install_property (gobject_class, PROP_PASSWORD_VISIBLE,

             g_param_spec_boolean ("password-visible", "Password visible", "Password field is visible",

                                   FALSE, G_PARAM_READABLE));

  /**

    * ShellKeyringPrompt:confirm-visible:

    *

    * Whether the password confirm entry is visible or not.

    */

  g_object_class_install_property (gobject_class, PROP_CONFIRM_VISIBLE,

             g_param_spec_boolean ("confirm-visible", "Confirm visible", "Confirm field is visible",

                                   FALSE, G_PARAM_READABLE));

  /**

   * ShellKeyringPrompt:warning-visible:

   *

   * Whether the warning label is visible or not.

   */

  g_object_class_install_property (gobject_class, PROP_WARNING_VISIBLE,

             g_param_spec_boolean ("warning-visible", "Warning visible", "Warning is visible",

                                   FALSE, G_PARAM_READABLE));

  /**

   * ShellKeyringPrompt:choice-visible:

   *

   * Whether the choice check box is visible or not.

   */

  g_object_class_install_property (gobject_class, PROP_CHOICE_VISIBLE,

             g_param_spec_boolean ("choice-visible", "Choice visible", "Choice is visible",

                                   FALSE, G_PARAM_READABLE));

  /**

   * ShellKeyringPrompt:password-actor:

   *

   * Text field for password

   */

  g_object_class_install_property (gobject_class, PROP_PASSWORD_ACTOR,

              g_param_spec_object ("password-actor", "Password actor", "Text field for password",

                                   CLUTTER_TYPE_TEXT, G_PARAM_READWRITE));

  /**

   * ShellKeyringPrompt:confirm-actor:

   *

   * Text field for confirmation password

   */

  g_object_class_install_property (gobject_class, PROP_CONFIRM_ACTOR,

              g_param_spec_object ("confirm-actor", "Confirm actor", "Text field for confirming password",

                                   CLUTTER_TYPE_TEXT, G_PARAM_READWRITE));

  signals[SIGNAL_SHOW_PASSWORD] = g_signal_new ("show-password", G_TYPE_FROM_CLASS (klass),

                                                0, 0, NULL, NULL,

                                                g_cclosure_marshal_VOID__VOID,

                                                G_TYPE_NONE, 0);

  signals[SIGNAL_SHOW_CONFIRM] =  g_signal_new ("show-confirm", G_TYPE_FROM_CLASS (klass),

                                                0, 0, NULL, NULL,

                                                g_cclosure_marshal_VOID__VOID,

                                                G_TYPE_NONE, 0);

}

static void

shell_keyring_prompt_password_async (GcrPrompt          *prompt,

                                     GCancellable       *cancellable,

                                     GAsyncReadyCallback callback,

                                     gpointer            user_data)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (prompt);

  GObject *obj;

  if (self->task != NULL) {

      g_warning ("this prompt can only show one prompt at a time");

      return;

  }

  self->mode = PROMPTING_FOR_PASSWORD;

  self->task = g_task_new (self, NULL, callback, user_data);

  g_task_set_source_tag (self->task, shell_keyring_prompt_password_async);

  obj = G_OBJECT (self);

  g_object_notify (obj, "password-visible");

  g_object_notify (obj, "confirm-visible");

  g_object_notify (obj, "warning-visible");

  g_object_notify (obj, "choice-visible");

  self->shown = TRUE;

  g_signal_emit (self, signals[SIGNAL_SHOW_PASSWORD], 0);

}

static const gchar *

shell_keyring_prompt_password_finish (GcrPrompt    *prompt,

                                      GAsyncResult *result,

                                      GError      **error)

{

  g_return_val_if_fail (g_task_get_source_object (G_TASK (result)) == prompt, NULL);

  g_return_val_if_fail (g_async_result_is_tagged (result,

                        shell_keyring_prompt_password_async), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);

}

static void

shell_keyring_prompt_confirm_async (GcrPrompt          *prompt,

                                    GCancellable       *cancellable,

                                    GAsyncReadyCallback callback,

                                    gpointer            user_data)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (prompt);

  GObject *obj;

  if (self->task != NULL) {

      g_warning ("this prompt is already prompting");

      return;

  }

  self->mode = PROMPTING_FOR_CONFIRM;

  self->task = g_task_new (self, NULL, callback, user_data);

  g_task_set_source_tag (self->task, shell_keyring_prompt_confirm_async);

  obj = G_OBJECT (self);

  g_object_notify (obj, "password-visible");

  g_object_notify (obj, "confirm-visible");

  g_object_notify (obj, "warning-visible");

  g_object_notify (obj, "choice-visible");

  self->shown = TRUE;

  g_signal_emit (self, signals[SIGNAL_SHOW_CONFIRM], 0);

}

static GcrPromptReply

shell_keyring_prompt_confirm_finish (GcrPrompt    *prompt,

                                     GAsyncResult *result,

                                     GError      **error)

{

  GTask *task = G_TASK (result);

  gssize res;

  g_return_val_if_fail (g_task_get_source_object (task) == prompt,

                        GCR_PROMPT_REPLY_CANCEL);

  g_return_val_if_fail (g_async_result_is_tagged (result,

                        shell_keyring_prompt_confirm_async), GCR_PROMPT_REPLY_CANCEL);

  res = g_task_propagate_int (task, error);

  return res == -1 ? GCR_PROMPT_REPLY_CANCEL : (GcrPromptReply)res;

}

static void

shell_keyring_prompt_close (GcrPrompt *prompt)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (prompt);

  /*

   * We expect keyring.js to connect to this signal and do the

   * actual work of closing the prompt.

   */

  self->shown = FALSE;

}

static void

shell_keyring_prompt_iface (GcrPromptIface *iface)

{

  iface->prompt_password_async = shell_keyring_prompt_password_async;

  iface->prompt_password_finish = shell_keyring_prompt_password_finish;

  iface->prompt_confirm_async = shell_keyring_prompt_confirm_async;

  iface->prompt_confirm_finish = shell_keyring_prompt_confirm_finish;

  iface->prompt_close = shell_keyring_prompt_close;

}

/**

 * shell_keyring_prompt_new:

 *

 * Create new internal prompt base

 *

 * Returns: (transfer full): new internal prompt

 */

ShellKeyringPrompt *

shell_keyring_prompt_new (void)

{

	return g_object_new (SHELL_TYPE_KEYRING_PROMPT, NULL);

}

/**

 * shell_keyring_prompt_get_password_actor:

 * @self: the internal prompt

 *

 * Get the prompt password text actor

 *

 * Returns: (transfer none) (nullable): the password actor

 */

ClutterText *

shell_keyring_prompt_get_password_actor (ShellKeyringPrompt *self)

{

  g_return_val_if_fail (SHELL_IS_KEYRING_PROMPT (self), NULL);

  return self->password_actor;

}

/**

 * shell_keyring_prompt_get_confirm_actor:

 * @self: the internal prompt

 *

 * Get the prompt password text actor

 *

 * Returns: (transfer none) (nullable): the password actor

 */

ClutterText *

shell_keyring_prompt_get_confirm_actor (ShellKeyringPrompt *self)

{

  g_return_val_if_fail (SHELL_IS_KEYRING_PROMPT (self), NULL);

  return self->confirm_actor;

}

static guint

calculate_password_strength (const gchar *password)

{

  int upper, lower, digit, misc;

  gdouble pwstrength;

  int length, i;

  /*

   * This code is based on the Master Password dialog in Firefox

   * (pref-masterpass.js)

   * Original code triple-licensed under the MPL, GPL, and LGPL

   * so is license-compatible with this file

   */

  length = strlen (password);

  /* Always return 0 for empty passwords */

  if (length == 0)

    return 0;

  upper = 0;

  lower = 0;

  digit = 0;

  misc = 0;

  for (i = 0; i < length ; i++)

    {

      if (g_ascii_isdigit (password[i]))

        digit++;

      else if (g_ascii_islower (password[i]))

        lower++;

      else if (g_ascii_isupper (password[i]))

        upper++;

      else

        misc++;

    }

  if (length > 5)

    length = 5;

  if (digit > 3)

    digit = 3;

  if (upper > 3)

    upper = 3;

  if (misc > 3)

    misc = 3;

  pwstrength = ((length * 1) - 2) +

      (digit * 1) +

      (misc * 1.5) +

      (upper * 1);

  /* Always return 1+ for non-empty passwords */

  if (pwstrength < 1.0)

    pwstrength = 1.0;

  if (pwstrength > 10.0)

    pwstrength = 10.0;

  return (guint)pwstrength;

}

static void

on_password_changed (ClutterText *text,

                     gpointer user_data)

{

  ShellKeyringPrompt *self = SHELL_KEYRING_PROMPT (user_data);

  const gchar *password;

  password = clutter_text_get_text (self->password_actor);

  self->password_strength = calculate_password_strength (password);

  g_object_notify (G_OBJECT (self), "password-strength");

}

/**

 * shell_keyring_prompt_set_password_actor:

 * @self: the internal prompt

 * @password_actor: (nullable): the password actor

 *

 * Set the prompt password text actor

 */

void

shell_keyring_prompt_set_password_actor (ShellKeyringPrompt *self,

                                         ClutterText *password_actor)

{

  ClutterTextBuffer *buffer;

  g_return_if_fail (SHELL_IS_KEYRING_PROMPT (self));

  g_return_if_fail (password_actor == NULL || CLUTTER_IS_TEXT (password_actor));

  if (password_actor)

    {

      buffer = shell_secure_text_buffer_new ();

      clutter_text_set_buffer (password_actor, buffer);

      g_object_unref (buffer);

      g_signal_connect (password_actor, "text-changed", G_CALLBACK (on_password_changed), self);

      g_object_ref (password_actor);

    }

  if (self->password_actor)

    {

      g_signal_handlers_disconnect_by_func (self->password_actor, on_password_changed, self);

      g_object_unref (self->password_actor);

    }

  self->password_actor = password_actor;

  g_object_notify (G_OBJECT (self), "password-actor");

}

/**

 * shell_keyring_prompt_set_confirm_actor:

 * @self: the internal prompt

 * @confirm_actor: (nullable): the confirm password actor

 *

 * Set the prompt password confirmation text actor

 */

void

shell_keyring_prompt_set_confirm_actor (ShellKeyringPrompt *self,

                                        ClutterText *confirm_actor)

{

  ClutterTextBuffer *buffer;

  g_return_if_fail (SHELL_IS_KEYRING_PROMPT (self));

  g_return_if_fail (confirm_actor == NULL || CLUTTER_IS_TEXT (confirm_actor));

  if (confirm_actor)

    {

      buffer = shell_secure_text_buffer_new ();

      clutter_text_set_buffer (confirm_actor, buffer);

      g_object_unref (buffer);

      g_object_ref (confirm_actor);

    }

  if (self->confirm_actor)

    g_object_unref (self->confirm_actor);

  self->confirm_actor = confirm_actor;

  g_object_notify (G_OBJECT (self), "confirm-actor");

}

/**

 * shell_keyring_prompt_complete:

 * @self: the internal prompt

 *

 * Called by the implementation when the prompt completes. There are various

 * checks done. %TRUE is returned if the prompt actually should complete.

 *

 * Returns: whether the prompt completed

 */

gboolean

shell_keyring_prompt_complete (ShellKeyringPrompt *self)

{

  GTask *res;

  PromptingMode mode;

  const gchar *password;

  const gchar *confirm;

  const gchar *env;

  g_return_val_if_fail (SHELL_IS_KEYRING_PROMPT (self), FALSE);

  g_return_val_if_fail (self->mode != PROMPTING_NONE, FALSE);

  g_return_val_if_fail (self->task != NULL, FALSE);

  password = clutter_text_get_text (self->password_actor);

  if (self->mode == PROMPTING_FOR_PASSWORD)

    {

      /* Is it a new password? */

      if (self->password_new)

        {

          confirm = clutter_text_get_text (self->confirm_actor);

          /* Do the passwords match? */

          if (!g_str_equal (password, confirm))

            {

              gcr_prompt_set_warning (GCR_PROMPT (self), _("Passwords do not match."));

              return FALSE;

          }

          /* Don't allow blank passwords if in paranoid mode */

          env = g_getenv ("GNOME_KEYRING_PARANOID");

          if (env && *env)

            {

              gcr_prompt_set_warning (GCR_PROMPT (self), _("Password cannot be blank"));

              return FALSE;

            }

        }

      self->password_strength = calculate_password_strength (password);

      g_object_notify (G_OBJECT (self), "password-strength");

    }

  res = self->task;

  mode = self->mode;

  self->task = NULL;

  self->mode = PROMPTING_NONE;

  if (mode == PROMPTING_FOR_CONFIRM)

    g_task_return_int (res, (gssize)GCR_PROMPT_REPLY_CONTINUE);

  else

    g_task_return_pointer (res, (gpointer)password, NULL);

  g_object_unref (res);

  return TRUE;

}

/**

 * shell_keyring_prompt_cancel:

 * @self: the internal prompt

 *

 * Called by implementation when the prompt is cancelled.

 */

void

shell_keyring_prompt_cancel (ShellKeyringPrompt *self)

{

  GTask *res;

  PromptingMode mode;

  g_return_if_fail (SHELL_IS_KEYRING_PROMPT (self));

  /*

   * If cancelled while not prompting, we should just close the prompt,

   * the user wants it to go away.

   */

  if (self->mode == PROMPTING_NONE)

    {

      if (self->shown)

        gcr_prompt_close (GCR_PROMPT (self));

      return;

    }

  g_return_if_fail (self->task != NULL);

  res = self->task;

  mode = self->mode;

  self->task = NULL;

  self->mode = PROMPTING_NONE;

  if (mode == PROMPTING_FOR_CONFIRM)

    g_task_return_int (res, (gssize) GCR_PROMPT_REPLY_CANCEL);

  else

    g_task_return_pointer (res, NULL, NULL);

  g_object_unref (res);

}