gio/gtlspassword.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2011 Collabora, Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Stef Walter <stefw@collabora.co.uk>
  21  */
  22
  23 #include "config.h"
  24 #include "glib.h"
  25 #include "glibintl.h"
  26
  27 #include "gioenumtypes.h"
  28 #include "gtlspassword.h"
  29
  30 #include <string.h>
  31
  32 /**
  33  * SECTION:gtlspassword
  34  * @title: GTlsPassword
  35  * @short_description: TLS Passwords for prompting
  36  * @include: gio/gio.h
  37  *
  38  * Holds a password used in TLS.
  39  */
  40
  41 /**
  42  * GTlsPassword:
  43  *
  44  * An abstract interface representing a password used in TLS. Often used in
  45  * user interaction such as unlocking a key storage token.
  46  *
  47  * Since: 2.30
  48  */
  49
  50 enum
  51 {
  52   PROP_0,
  53   PROP_FLAGS,
  54   PROP_DESCRIPTION,
  55   PROP_WARNING
  56 };
  57
  58 struct _GTlsPasswordPrivate
  59 {
  60   guchar *value;
  61   gsize length;
  62   GDestroyNotify destroy;
  63   GTlsPasswordFlags flags;
  64   gchar *description;
  65   gchar *warning;
  66 };
  67
  68 G_DEFINE_TYPE (GTlsPassword, g_tls_password, G_TYPE_OBJECT);
  69
  70 static void
  71 g_tls_password_init (GTlsPassword *password)
  72 {
  73   password->priv = G_TYPE_INSTANCE_GET_PRIVATE (password, G_TYPE_TLS_PASSWORD,
  74                                               GTlsPasswordPrivate);
  75 }
  76
  77 static const guchar *
  78 g_tls_password_real_get_value (GTlsPassword  *password,
  79                                gsize         *length)
  80 {
  81   if (length)
  82     *length = password->priv->length;
  83   return password->priv->value;
  84 }
  85
  86 static void
  87 g_tls_password_real_set_value (GTlsPassword  *password,
  88                                guchar        *value,
  89                                gssize         length,
  90                                GDestroyNotify destroy)
  91 {
  92   if (password->priv->destroy)
  93       (password->priv->destroy) (password->priv->value);
  94   password->priv->destroy = NULL;
  95   password->priv->value = NULL;
  96   password->priv->length = 0;
  97
  98   if (length < 0)
  99     length = strlen ((gchar*) value);
 100
 101   password->priv->value = value;
 102   password->priv->length = length;
 103   password->priv->destroy = destroy;
 104 }
 105
 106 static const gchar*
 107 g_tls_password_real_get_default_warning (GTlsPassword  *password)
 108 {
 109   GTlsPasswordFlags flags;
 110
 111   flags = g_tls_password_get_flags (password);
 112
 113   if (flags & G_TLS_PASSWORD_FINAL_TRY)
 114     return _("This is the last chance to enter the password correctly before your access is locked out.");
 115   if (flags & G_TLS_PASSWORD_MANY_TRIES)
 116     return _("Several password entered have been incorrect, and your access will be locked out after further failures.");
 117   if (flags & G_TLS_PASSWORD_RETRY)
 118     return _("The password entered is incorrect.");
 119
 120   return NULL;
 121 }
 122
 123 static void
 124 g_tls_password_get_property (GObject    *object,
 125                              guint       prop_id,
 126                              GValue     *value,
 127                              GParamSpec *pspec)
 128 {
 129   GTlsPassword *password = G_TLS_PASSWORD (object);
 130
 131   switch (prop_id)
 132     {
 133     case PROP_FLAGS:
 134       g_value_set_flags (value, g_tls_password_get_flags (password));
 135       break;
 136     case PROP_WARNING:
 137       g_value_set_string (value, g_tls_password_get_warning (password));
 138       break;
 139     case PROP_DESCRIPTION:
 140       g_value_set_string (value, g_tls_password_get_description (password));
 141       break;
 142     default:
 143       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 144       break;
 145     }
 146 }
 147
 148 static void
 149 g_tls_password_set_property (GObject    *object,
 150                              guint       prop_id,
 151                              const GValue     *value,
 152                              GParamSpec *pspec)
 153 {
 154   GTlsPassword *password = G_TLS_PASSWORD (object);
 155
 156   switch (prop_id)
 157     {
 158     case PROP_FLAGS:
 159       g_tls_password_set_flags (password, g_value_get_flags (value));
 160       break;
 161     case PROP_WARNING:
 162       g_tls_password_set_warning (password, g_value_get_string (value));
 163       break;
 164     case PROP_DESCRIPTION:
 165       g_tls_password_set_description (password, g_value_get_string (value));
 166       break;
 167     default:
 168       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 169       break;
 170     }
 171 }
 172
 173 static void
 174 g_tls_password_finalize (GObject *object)
 175 {
 176   GTlsPassword *password = G_TLS_PASSWORD (object);
 177
 178   g_tls_password_real_set_value (password, NULL, 0, NULL);
 179   g_free (password->priv->warning);
 180   g_free (password->priv->description);
 181
 182   G_OBJECT_CLASS (g_tls_password_parent_class)->finalize (object);
 183 }
 184
 185 static void
 186 g_tls_password_class_init (GTlsPasswordClass *klass)
 187 {
 188   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 189
 190   klass->get_value = g_tls_password_real_get_value;
 191   klass->set_value = g_tls_password_real_set_value;
 192   klass->get_default_warning = g_tls_password_real_get_default_warning;
 193
 194   gobject_class->get_property = g_tls_password_get_property;
 195   gobject_class->set_property = g_tls_password_set_property;
 196   gobject_class->finalize = g_tls_password_finalize;
 197
 198   g_type_class_add_private (klass, sizeof (GTlsPasswordPrivate));
 199
 200   g_object_class_install_property (gobject_class, PROP_FLAGS,
 201              g_param_spec_flags ("flags", "Flags", "Flags about the password",
 202                                  G_TYPE_TLS_PASSWORD_FLAGS, G_TLS_PASSWORD_NONE,
 203                                  G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 204
 205   g_object_class_install_property (gobject_class, PROP_DESCRIPTION,
 206              g_param_spec_string ("description", "Description", "Description of what the password is for",
 207                                   "", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 208
 209   g_object_class_install_property (gobject_class, PROP_WARNING,
 210              g_param_spec_string ("warning", "Warning", "Warning about the password",
 211                                  "", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 212
 213 }
 214
 215 /**
 216  * g_tls_password_new:
 217  * @flags: the password flags
 218  * @description: description of what the password is for
 219  *
 220  * Create a new #GTlsPassword object.
 221  *
 222  * Returns: (transfer full): The newly allocated password object
 223  */
 224 GTlsPassword *
 225 g_tls_password_new (GTlsPasswordFlags  flags,
 226                     const gchar       *description)
 227 {
 228   return g_object_new (G_TYPE_TLS_PASSWORD,
 229                        "flags", flags,
 230                        "description", description,
 231                        NULL);
 232 }
 233
 234 /**
 235  * g_tls_password_get_value:
 236  * @password: a #GTlsPassword object
 237  * @length: (allow-none): location to place the length of the password.
 238  *
 239  * Get the password value. If @length is not %NULL then it will be filled
 240  * in with the length of the password value.
 241  *
 242  * Returns: The password value owned by the password object.
 243  *
 244  * Since: 2.30
 245  */
 246 const guchar *
 247 g_tls_password_get_value (GTlsPassword  *password,
 248                           gsize         *length)
 249 {
 250   g_return_val_if_fail (G_IS_TLS_PASSWORD (password), NULL);
 251   return G_TLS_PASSWORD_GET_CLASS (password)->get_value (password, length);
 252 }
 253
 254 /**
 255  * g_tls_password_set_value:
 256  * @password: a #GTlsPassword object
 257  * @value: the new password value
 258  * @length: the length of the password, or -1
 259  *
 260  * Set the value for this password. The @value will be copied by the password
 261  * object.
 262  *
 263  * Specify the @length, for a non-null-terminated password. Pass -1 as
 264  * @length if using a null-terminated password, and @length will be calculated
 265  * automatically.
 266  *
 267  * Since: 2.30
 268  */
 269 void
 270 g_tls_password_set_value (GTlsPassword  *password,
 271                           const guchar  *value,
 272                           gssize         length)
 273 {
 274   g_return_if_fail (G_IS_TLS_PASSWORD (password));
 275
 276   if (length < 0)
 277     length = strlen ((gchar *)value);
 278
 279   g_tls_password_set_value_full (password, g_memdup (value, length), length, g_free);
 280 }
 281
 282 /**
 283  * g_tls_password_set_value_full:
 284  * @password: a #GTlsPassword object
 285  * @value: the value for the password
 286  * @length: the length of the password, or -1
 287  * @destroy: (allow-none): a function to use to free the password.
 288  *
 289  * Provide the value for this password.
 290  *
 291  * The @value will be owned by the password object, and later freed using
 292  * the @destroy function callback.
 293  *
 294  * Specify the @length, for a non-null-terminated password. Pass -1 as
 295  * @length if using a null-terminated password, and @length will be calculated
 296  * automatically.
 297  *
 298  * Since: 2.30
 299  */
 300 void
 301 g_tls_password_set_value_full (GTlsPassword  *password,
 302                                guchar        *value,
 303                                gssize         length,
 304                                GDestroyNotify destroy)
 305 {
 306   g_return_if_fail (G_IS_TLS_PASSWORD (password));
 307   G_TLS_PASSWORD_GET_CLASS (password)->set_value (password, value,
 308                                                   length, destroy);
 309 }
 310
 311 /**
 312  * g_tls_password_get_flags:
 313  * @password: a #GTlsPassword object
 314  *
 315  * Get flags about the password.
 316  *
 317  * Return value: The flags about the password.
 318  *
 319  * Since: 2.30
 320  */
 321 GTlsPasswordFlags
 322 g_tls_password_get_flags (GTlsPassword *password)
 323 {
 324   g_return_val_if_fail (G_IS_TLS_PASSWORD (password), G_TLS_PASSWORD_NONE);
 325   return password->priv->flags;
 326 }
 327
 328 /**
 329  * g_tls_password_set_flags:
 330  * @password: a #GTlsPassword object
 331  * @flags: The flags about the password
 332  *
 333  * Set flags about the password.
 334  *
 335  * Since: 2.30
 336  */
 337 void
 338 g_tls_password_set_flags (GTlsPassword      *password,
 339                           GTlsPasswordFlags  flags)
 340 {
 341   g_return_if_fail (G_IS_TLS_PASSWORD (password));
 342
 343   password->priv->flags = flags;
 344
 345   g_object_notify (G_OBJECT (password), "flags");
 346 }
 347
 348 /**
 349  * g_tls_password_get_description:
 350  * @password: a #GTlsPassword object
 351  *
 352  * Get a description string about what the password will be used for.
 353  *
 354  * Return value: The description of the password.
 355  *
 356  * Since: 2.30
 357  */
 358 const gchar*
 359 g_tls_password_get_description (GTlsPassword *password)
 360 {
 361   g_return_val_if_fail (G_IS_TLS_PASSWORD (password), NULL);
 362   return password->priv->description;
 363 }
 364
 365 /**
 366  * g_tls_password_set_description:
 367  * @password: a #GTlsPassword object
 368  * @description: The description of the password
 369  *
 370  * Set a description string about what the password will be used for.
 371  *
 372  * Since: 2.30
 373  */
 374 void
 375 g_tls_password_set_description (GTlsPassword      *password,
 376                                 const gchar       *description)
 377 {
 378   gchar *copy;
 379
 380   g_return_if_fail (G_IS_TLS_PASSWORD (password));
 381
 382   copy = g_strdup (description);
 383   g_free (password->priv->description);
 384   password->priv->description = copy;
 385
 386   g_object_notify (G_OBJECT (password), "description");
 387 }
 388
 389 /**
 390  * g_tls_password_get_warning:
 391  * @password: a #GTlsPassword object
 392  *
 393  * Get a user readable translated warning. Usually this warning is a
 394  * representation of the password flags returned from
 395  * g_tls_password_get_flags().
 396  *
 397  * Return value: The warning.
 398  *
 399  * Since: 2.30
 400  */
 401 const gchar *
 402 g_tls_password_get_warning (GTlsPassword      *password)
 403 {
 404   g_return_val_if_fail (G_IS_TLS_PASSWORD (password), NULL);
 405
 406   if (password->priv->warning == NULL)
 407     return G_TLS_PASSWORD_GET_CLASS (password)->get_default_warning (password);
 408
 409   return password->priv->warning;
 410 }
 411
 412 /**
 413  * g_tls_password_set_warning:
 414  * @password: a #GTlsPassword object
 415  * @warning: The user readable warning
 416  *
 417  * Set a user readable translated warning. Usually this warning is a
 418  * representation of the password flags returned from
 419  * g_tls_password_get_flags().
 420  *
 421  * Since: 2.30
 422  */
 423 void
 424 g_tls_password_set_warning (GTlsPassword      *password,
 425                             const gchar       *warning)
 426 {
 427   gchar *copy;
 428
 429   g_return_if_fail (G_IS_TLS_PASSWORD (password));
 430
 431   copy = g_strdup (warning);
 432   g_free (password->priv->warning);
 433   password->priv->warning = copy;
 434
 435   g_object_notify (G_OBJECT (password), "warning");
 436 }