gio/gmountoperation.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   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: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26
  27 #include "gmountoperation.h"
  28 #include "gioenumtypes.h"
  29 #include "gio-marshal.h"
  30 #include "glibintl.h"
  31
  32 #include "gioalias.h"
  33
  34 /**
  35  * SECTION:gmountoperation
  36  * @short_description: Authentication methods for mountable locations
  37  * @include: gio/gio.h
  38  *
  39  * #GMountOperation provides a mechanism for authenticating mountable
  40  * operations, such as loop mounting files, hard drive partitions or
  41  * server locations.
  42  *
  43  * Mounting operations are handed a #GMountOperation that then can use
  44  * if they require any privileges or authentication for their volumes
  45  * to be mounted (e.g. a hard disk partition or an encrypted filesystem),
  46  * or if they are implementing a remote server protocol which requires
  47  * user credentials such as FTP or WebDAV.
  48  *
  49  * Users should instantiate a subclass of this that implements all
  50  * the various callbacks to show the required dialogs, such as
  51  * #GtkMountOperation.
  52  **/
  53
  54 G_DEFINE_TYPE (GMountOperation, g_mount_operation, G_TYPE_OBJECT);
  55
  56 enum {
  57   ASK_PASSWORD,
  58   ASK_QUESTION,
  59   REPLY,
  60   ABORTED,
  61   LAST_SIGNAL
  62 };
  63
  64 static guint signals[LAST_SIGNAL] = { 0 };
  65
  66 struct _GMountOperationPrivate {
  67   char *password;
  68   char *user;
  69   char *domain;
  70   gboolean anonymous;
  71   GPasswordSave password_save;
  72   int choice;
  73 };
  74
  75 enum {
  76   PROP_0,
  77   PROP_USERNAME,
  78   PROP_PASSWORD,
  79   PROP_ANONYMOUS,
  80   PROP_DOMAIN,
  81   PROP_PASSWORD_SAVE,
  82   PROP_CHOICE
  83 };
  84
  85 static void
  86 g_mount_operation_set_property (GObject      *object,
  87                                 guint         prop_id,
  88                                 const GValue *value,
  89                                 GParamSpec   *pspec)
  90 {
  91   GMountOperation *operation;
  92
  93   operation = G_MOUNT_OPERATION (object);
  94
  95   switch (prop_id)
  96     {
  97     case PROP_USERNAME:
  98       g_mount_operation_set_username (operation,
  99                                       g_value_get_string (value));
 100       break;
 101
 102     case PROP_PASSWORD:
 103       g_mount_operation_set_password (operation,
 104                                       g_value_get_string (value));
 105       break;
 106
 107     case PROP_ANONYMOUS:
 108       g_mount_operation_set_anonymous (operation,
 109                                        g_value_get_boolean (value));
 110       break;
 111
 112     case PROP_DOMAIN:
 113       g_mount_operation_set_domain (operation,
 114                                     g_value_get_string (value));
 115       break;
 116
 117     case PROP_PASSWORD_SAVE:
 118       g_mount_operation_set_password_save (operation,
 119                                            g_value_get_enum (value));
 120       break;
 121
 122     case PROP_CHOICE:
 123       g_mount_operation_set_choice (operation,
 124                                     g_value_get_int (value));
 125       break;
 126
 127     default:
 128       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 129       break;
 130     }
 131 }
 132
 133
 134 static void
 135 g_mount_operation_get_property (GObject    *object,
 136                                 guint       prop_id,
 137                                 GValue     *value,
 138                                 GParamSpec *pspec)
 139 {
 140   GMountOperation *operation;
 141   GMountOperationPrivate *priv;
 142
 143   operation = G_MOUNT_OPERATION (object);
 144   priv = operation->priv;
 145
 146   switch (prop_id)
 147     {
 148     case PROP_USERNAME:
 149       g_value_set_string (value, priv->user);
 150       break;
 151
 152     case PROP_PASSWORD:
 153       g_value_set_string (value, priv->password);
 154       break;
 155
 156     case PROP_ANONYMOUS:
 157       g_value_set_boolean (value, priv->anonymous);
 158       break;
 159
 160     case PROP_DOMAIN:
 161       g_value_set_string (value, priv->domain);
 162       break;
 163
 164     case PROP_PASSWORD_SAVE:
 165       g_value_set_enum (value, priv->password_save);
 166       break;
 167
 168     case PROP_CHOICE:
 169       g_value_set_int (value, priv->choice);
 170       break;
 171
 172     default:
 173       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 174       break;
 175     }
 176 }
 177
 178
 179 static void
 180 g_mount_operation_finalize (GObject *object)
 181 {
 182   GMountOperation *operation;
 183   GMountOperationPrivate *priv;
 184
 185   operation = G_MOUNT_OPERATION (object);
 186
 187   priv = operation->priv;
 188
 189   g_free (priv->password);
 190   g_free (priv->user);
 191   g_free (priv->domain);
 192
 193   G_OBJECT_CLASS (g_mount_operation_parent_class)->finalize (object);
 194 }
 195
 196 static gboolean
 197 reply_non_handled_in_idle (gpointer data)
 198 {
 199   GMountOperation *op = data;
 200
 201   g_mount_operation_reply (op, G_MOUNT_OPERATION_UNHANDLED);
 202   return FALSE;
 203 }
 204
 205 static void
 206 ask_password (GMountOperation *op,
 207               const char      *message,
 208               const char      *default_user,
 209               const char      *default_domain,
 210               GAskPasswordFlags flags)
 211 {
 212   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 213                    reply_non_handled_in_idle,
 214                    g_object_ref (op),
 215                    g_object_unref);
 216 }
 217
 218 static void
 219 ask_question (GMountOperation *op,
 220               const char      *message,
 221               const char      *choices[])
 222 {
 223   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 224                    reply_non_handled_in_idle,
 225                    g_object_ref (op),
 226                    g_object_unref);
 227 }
 228
 229 static void
 230 g_mount_operation_class_init (GMountOperationClass *klass)
 231 {
 232   GObjectClass *object_class;
 233
 234   g_type_class_add_private (klass, sizeof (GMountOperationPrivate));
 235
 236   object_class = G_OBJECT_CLASS (klass);
 237   object_class->finalize = g_mount_operation_finalize;
 238   object_class->get_property = g_mount_operation_get_property;
 239   object_class->set_property = g_mount_operation_set_property;
 240
 241   klass->ask_password = ask_password;
 242   klass->ask_question = ask_question;
 243
 244   /**
 245    * GMountOperation::ask-password:
 246    * @op: a #GMountOperation requesting a password.
 247    * @message: string containing a message to display to the user.
 248    * @default_user: string containing the default user name.
 249    * @default_domain: string containing the default domain.
 250    * @flags: a set of #GAskPasswordFlags.
 251    *
 252    * Emitted when a mount operation asks the user for a password.
 253    *
 254    * If the message contains a line break, the first line should be
 255    * presented as a heading. For example, it may be used as the
 256    * primary text in a #GtkMessageDialog.
 257    */
 258   signals[ASK_PASSWORD] =
 259     g_signal_new (I_("ask-password"),
 260                   G_TYPE_FROM_CLASS (object_class),
 261                   G_SIGNAL_RUN_LAST,
 262                   G_STRUCT_OFFSET (GMountOperationClass, ask_password),
 263                   NULL, NULL,
 264                   _gio_marshal_VOID__STRING_STRING_STRING_FLAGS,
 265                   G_TYPE_NONE, 4,
 266                   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_ASK_PASSWORD_FLAGS);
 267
 268   /**
 269    * GMountOperation::ask-question:
 270    * @op: a #GMountOperation asking a question.
 271    * @message: string containing a message to display to the user.
 272    * @choices: an array of strings for each possible choice.
 273    *
 274    * Emitted when asking the user a question and gives a list of
 275    * choices for the user to choose from.
 276    *
 277    * If the message contains a line break, the first line should be
 278    * presented as a heading. For example, it may be used as the
 279    * primary text in a #GtkMessageDialog.
 280    */
 281   signals[ASK_QUESTION] =
 282     g_signal_new (I_("ask-question"),
 283                   G_TYPE_FROM_CLASS (object_class),
 284                   G_SIGNAL_RUN_LAST,
 285                   G_STRUCT_OFFSET (GMountOperationClass, ask_question),
 286                   NULL, NULL,
 287                   _gio_marshal_VOID__STRING_BOXED,
 288                   G_TYPE_NONE, 2,
 289                   G_TYPE_STRING, G_TYPE_STRV);
 290
 291   /**
 292    * GMountOperation::reply:
 293    * @op: a #GMountOperation.
 294    * @result: a #GMountOperationResult indicating how the request was handled
 295    *
 296    * Emitted when the user has replied to the mount operation.
 297    */
 298   signals[REPLY] =
 299     g_signal_new (I_("reply"),
 300                   G_TYPE_FROM_CLASS (object_class),
 301                   G_SIGNAL_RUN_LAST,
 302                   G_STRUCT_OFFSET (GMountOperationClass, reply),
 303                   NULL, NULL,
 304                   g_cclosure_marshal_VOID__ENUM,
 305                   G_TYPE_NONE, 1,
 306                   G_TYPE_MOUNT_OPERATION_RESULT);
 307
 308   /**
 309    * GMountOperation::aborted:
 310    *
 311    * Emitted by the backend when e.g. a device becomes unavailable
 312    * while a mount operation is in progress.
 313    *
 314    * Implementations of GMountOperation should handle this signal
 315    * by dismissing open password dialogs.
 316    *
 317    * Since: 2.20
 318    */
 319   signals[ABORTED] =
 320     g_signal_new (I_("aborted"),
 321                   G_TYPE_FROM_CLASS (object_class),
 322                   G_SIGNAL_RUN_LAST,
 323                   G_STRUCT_OFFSET (GMountOperationClass, aborted),
 324                   NULL, NULL,
 325                   g_cclosure_marshal_VOID__VOID,
 326                   G_TYPE_NONE, 0);
 327
 328   /**
 329    * GMountOperation:username:
 330    *
 331    * The user name that is used for authentication when carrying out
 332    * the mount operation.
 333    */
 334   g_object_class_install_property (object_class,
 335                                    PROP_USERNAME,
 336                                    g_param_spec_string ("username",
 337                                                         P_("Username"),
 338                                                         P_("The user name"),
 339                                                         NULL,
 340                                                         G_PARAM_READWRITE|
 341                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 342
 343   /**
 344    * GMountOperation:password:
 345    *
 346    * The password that is used for authentication when carrying out
 347    * the mount operation.
 348    */
 349   g_object_class_install_property (object_class,
 350                                    PROP_PASSWORD,
 351                                    g_param_spec_string ("password",
 352                                                         P_("Password"),
 353                                                         P_("The password"),
 354                                                         NULL,
 355                                                         G_PARAM_READWRITE|
 356                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 357
 358   /**
 359    * GMountOperation:anonymous:
 360    *
 361    * Whether to use an anonymous user when authenticating.
 362    */
 363   g_object_class_install_property (object_class,
 364                                    PROP_ANONYMOUS,
 365                                    g_param_spec_boolean ("anonymous",
 366                                                          P_("Anonymous"),
 367                                                          P_("Whether to use an anonymous user"),
 368                                                          FALSE,
 369                                                          G_PARAM_READWRITE|
 370                                                          G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 371
 372   /**
 373    * GMountOperation:domain:
 374    *
 375    * The domain to use for the mount operation.
 376    */
 377   g_object_class_install_property (object_class,
 378                                    PROP_DOMAIN,
 379                                    g_param_spec_string ("domain",
 380                                                         P_("Domain"),
 381                                                         P_("The domain of the mount operation"),
 382                                                         NULL,
 383                                                         G_PARAM_READWRITE|
 384                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 385
 386   /**
 387    * GMountOperation:password-save:
 388    *
 389    * Determines if and how the password information should be saved.
 390    */
 391   g_object_class_install_property (object_class,
 392                                    PROP_PASSWORD_SAVE,
 393                                    g_param_spec_enum ("password-save",
 394                                                       P_("Password save"),
 395                                                       P_("How passwords should be saved"),
 396                                                       G_TYPE_PASSWORD_SAVE,
 397                                                       G_PASSWORD_SAVE_NEVER,
 398                                                       G_PARAM_READWRITE|
 399                                                       G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 400
 401   /**
 402    * GMountOperation:choice:
 403    *
 404    * The index of the user's choice when a question is asked during the
 405    * mount operation. See the #GMountOperation::ask-question signal.
 406    */
 407   g_object_class_install_property (object_class,
 408                                    PROP_CHOICE,
 409                                    g_param_spec_int ("choice",
 410                                                      P_("Choice"),
 411                                                      P_("The users choice"),
 412                                                      0, G_MAXINT, 0,
 413                                                      G_PARAM_READWRITE|
 414                                                      G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 415 }
 416
 417 static void
 418 g_mount_operation_init (GMountOperation *operation)
 419 {
 420   operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
 421                                                  G_TYPE_MOUNT_OPERATION,
 422                                                  GMountOperationPrivate);
 423 }
 424
 425 /**
 426  * g_mount_operation_new:
 427  *
 428  * Creates a new mount operation.
 429  *
 430  * Returns: a #GMountOperation.
 431  **/
 432 GMountOperation *
 433 g_mount_operation_new (void)
 434 {
 435   return g_object_new (G_TYPE_MOUNT_OPERATION, NULL);
 436 }
 437
 438 /**
 439  * g_mount_operation_get_username
 440  * @op: a #GMountOperation.
 441  *
 442  * Get the user name from the mount operation.
 443  *
 444  * Returns: a string containing the user name.
 445  **/
 446 const char *
 447 g_mount_operation_get_username (GMountOperation *op)
 448 {
 449   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 450   return op->priv->user;
 451 }
 452
 453 /**
 454  * g_mount_operation_set_username:
 455  * @op: a #GMountOperation.
 456  * @username: input username.
 457  *
 458  * Sets the user name within @op to @username.
 459  **/
 460 void
 461 g_mount_operation_set_username (GMountOperation *op,
 462                                 const char      *username)
 463 {
 464   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 465   g_free (op->priv->user);
 466   op->priv->user = g_strdup (username);
 467   g_object_notify (G_OBJECT (op), "username");
 468 }
 469
 470 /**
 471  * g_mount_operation_get_password:
 472  * @op: a #GMountOperation.
 473  *
 474  * Gets a password from the mount operation.
 475  *
 476  * Returns: a string containing the password within @op.
 477  **/
 478 const char *
 479 g_mount_operation_get_password (GMountOperation *op)
 480 {
 481   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 482   return op->priv->password;
 483 }
 484
 485 /**
 486  * g_mount_operation_set_password:
 487  * @op: a #GMountOperation.
 488  * @password: password to set.
 489  *
 490  * Sets the mount operation's password to @password.
 491  *
 492  **/
 493 void
 494 g_mount_operation_set_password (GMountOperation *op,
 495                                 const char      *password)
 496 {
 497   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 498   g_free (op->priv->password);
 499   op->priv->password = g_strdup (password);
 500   g_object_notify (G_OBJECT (op), "password");
 501 }
 502
 503 /**
 504  * g_mount_operation_get_anonymous:
 505  * @op: a #GMountOperation.
 506  *
 507  * Check to see whether the mount operation is being used
 508  * for an anonymous user.
 509  *
 510  * Returns: %TRUE if mount operation is anonymous.
 511  **/
 512 gboolean
 513 g_mount_operation_get_anonymous (GMountOperation *op)
 514 {
 515   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), FALSE);
 516   return op->priv->anonymous;
 517 }
 518
 519 /**
 520  * g_mount_operation_set_anonymous:
 521  * @op: a #GMountOperation.
 522  * @anonymous: boolean value.
 523  *
 524  * Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
 525  **/
 526 void
 527 g_mount_operation_set_anonymous (GMountOperation *op,
 528                                  gboolean         anonymous)
 529 {
 530   GMountOperationPrivate *priv;
 531   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 532   priv = op->priv;
 533
 534   if (priv->anonymous != anonymous)
 535     {
 536       priv->anonymous = anonymous;
 537       g_object_notify (G_OBJECT (op), "anonymous");
 538     }
 539 }
 540
 541 /**
 542  * g_mount_operation_get_domain:
 543  * @op: a #GMountOperation.
 544  *
 545  * Gets the domain of the mount operation.
 546  *
 547  * Returns: a string set to the domain.
 548  **/
 549 const char *
 550 g_mount_operation_get_domain (GMountOperation *op)
 551 {
 552   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 553   return op->priv->domain;
 554 }
 555
 556 /**
 557  * g_mount_operation_set_domain:
 558  * @op: a #GMountOperation.
 559  * @domain: the domain to set.
 560  *
 561  * Sets the mount operation's domain.
 562  **/
 563 void
 564 g_mount_operation_set_domain (GMountOperation *op,
 565                               const char      *domain)
 566 {
 567   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 568   g_free (op->priv->domain);
 569   op->priv->domain = g_strdup (domain);
 570   g_object_notify (G_OBJECT (op), "domain");
 571 }
 572
 573 /**
 574  * g_mount_operation_get_password_save:
 575  * @op: a #GMountOperation.
 576  *
 577  * Gets the state of saving passwords for the mount operation.
 578  *
 579  * Returns: a #GPasswordSave flag.
 580  **/
 581
 582 GPasswordSave
 583 g_mount_operation_get_password_save (GMountOperation *op)
 584 {
 585   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), G_PASSWORD_SAVE_NEVER);
 586   return op->priv->password_save;
 587 }
 588
 589 /**
 590  * g_mount_operation_set_password_save:
 591  * @op: a #GMountOperation.
 592  * @save: a set of #GPasswordSave flags.
 593  *
 594  * Sets the state of saving passwords for the mount operation.
 595  *
 596  **/
 597 void
 598 g_mount_operation_set_password_save (GMountOperation *op,
 599                                      GPasswordSave    save)
 600 {
 601   GMountOperationPrivate *priv;
 602   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 603   priv = op->priv;
 604
 605   if (priv->password_save != save)
 606     {
 607       priv->password_save = save;
 608       g_object_notify (G_OBJECT (op), "password-save");
 609     }
 610 }
 611
 612 /**
 613  * g_mount_operation_get_choice:
 614  * @op: a #GMountOperation.
 615  *
 616  * Gets a choice from the mount operation.
 617  *
 618  * Returns: an integer containing an index of the user's choice from
 619  * the choice's list, or %0.
 620  **/
 621 int
 622 g_mount_operation_get_choice (GMountOperation *op)
 623 {
 624   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), 0);
 625   return op->priv->choice;
 626 }
 627
 628 /**
 629  * g_mount_operation_set_choice:
 630  * @op: a #GMountOperation.
 631  * @choice: an integer.
 632  *
 633  * Sets a default choice for the mount operation.
 634  **/
 635 void
 636 g_mount_operation_set_choice (GMountOperation *op,
 637                               int              choice)
 638 {
 639   GMountOperationPrivate *priv;
 640   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 641   priv = op->priv;
 642   if (priv->choice != choice)
 643     {
 644       priv->choice = choice;
 645       g_object_notify (G_OBJECT (op), "choice");
 646     }
 647 }
 648
 649 /**
 650  * g_mount_operation_reply:
 651  * @op: a #GMountOperation
 652  * @result: a #GMountOperationResult
 653  *
 654  * Emits the #GMountOperation::reply signal.
 655  **/
 656 void
 657 g_mount_operation_reply (GMountOperation *op,
 658                          GMountOperationResult result)
 659 {
 660   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 661   g_signal_emit (op, signals[REPLY], 0, result);
 662 }
 663
 664 #define __G_MOUNT_OPERATION_C__
 665 #include "gioaliasdef.c"