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 "glibintl.h"
  30
  31
  32 /**
  33  * SECTION:gmountoperation
  34  * @short_description: Object used for authentication and user interaction
  35  * @include: gio/gio.h
  36  *
  37  * #GMountOperation provides a mechanism for interacting with the user.
  38  * It can be used for authenticating mountable operations, such as loop
  39  * mounting files, hard drive partitions or server locations. It can
  40  * also be used to ask the user questions or show a list of applications
  41  * preventing unmount or eject operations from completing.
  42  *
  43  * Note that #GMountOperation is used for more than just #GMount
  44  * objects – for example it is also used in g_drive_start() and
  45  * g_drive_stop().
  46  *
  47  * Users should instantiate a subclass of this that implements all the
  48  * various callbacks to show the required dialogs, such as
  49  * #GtkMountOperation. If no user interaction is desired (for example
  50  * when automounting filesystems at login time), usually %NULL can be
  51  * passed, see each method taking a #GMountOperation for details.
  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   SHOW_PROCESSES,
  62   SHOW_UNMOUNT_PROGRESS,
  63   LAST_SIGNAL
  64 };
  65
  66 static guint signals[LAST_SIGNAL] = { 0 };
  67
  68 struct _GMountOperationPrivate {
  69   char *password;
  70   char *user;
  71   char *domain;
  72   gboolean anonymous;
  73   GPasswordSave password_save;
  74   int choice;
  75 };
  76
  77 enum {
  78   PROP_0,
  79   PROP_USERNAME,
  80   PROP_PASSWORD,
  81   PROP_ANONYMOUS,
  82   PROP_DOMAIN,
  83   PROP_PASSWORD_SAVE,
  84   PROP_CHOICE
  85 };
  86
  87 static void
  88 g_mount_operation_set_property (GObject      *object,
  89                                 guint         prop_id,
  90                                 const GValue *value,
  91                                 GParamSpec   *pspec)
  92 {
  93   GMountOperation *operation;
  94
  95   operation = G_MOUNT_OPERATION (object);
  96
  97   switch (prop_id)
  98     {
  99     case PROP_USERNAME:
 100       g_mount_operation_set_username (operation,
 101                                       g_value_get_string (value));
 102       break;
 103
 104     case PROP_PASSWORD:
 105       g_mount_operation_set_password (operation,
 106                                       g_value_get_string (value));
 107       break;
 108
 109     case PROP_ANONYMOUS:
 110       g_mount_operation_set_anonymous (operation,
 111                                        g_value_get_boolean (value));
 112       break;
 113
 114     case PROP_DOMAIN:
 115       g_mount_operation_set_domain (operation,
 116                                     g_value_get_string (value));
 117       break;
 118
 119     case PROP_PASSWORD_SAVE:
 120       g_mount_operation_set_password_save (operation,
 121                                            g_value_get_enum (value));
 122       break;
 123
 124     case PROP_CHOICE:
 125       g_mount_operation_set_choice (operation,
 126                                     g_value_get_int (value));
 127       break;
 128
 129     default:
 130       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 131       break;
 132     }
 133 }
 134
 135
 136 static void
 137 g_mount_operation_get_property (GObject    *object,
 138                                 guint       prop_id,
 139                                 GValue     *value,
 140                                 GParamSpec *pspec)
 141 {
 142   GMountOperation *operation;
 143   GMountOperationPrivate *priv;
 144
 145   operation = G_MOUNT_OPERATION (object);
 146   priv = operation->priv;
 147
 148   switch (prop_id)
 149     {
 150     case PROP_USERNAME:
 151       g_value_set_string (value, priv->user);
 152       break;
 153
 154     case PROP_PASSWORD:
 155       g_value_set_string (value, priv->password);
 156       break;
 157
 158     case PROP_ANONYMOUS:
 159       g_value_set_boolean (value, priv->anonymous);
 160       break;
 161
 162     case PROP_DOMAIN:
 163       g_value_set_string (value, priv->domain);
 164       break;
 165
 166     case PROP_PASSWORD_SAVE:
 167       g_value_set_enum (value, priv->password_save);
 168       break;
 169
 170     case PROP_CHOICE:
 171       g_value_set_int (value, priv->choice);
 172       break;
 173
 174     default:
 175       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 176       break;
 177     }
 178 }
 179
 180
 181 static void
 182 g_mount_operation_finalize (GObject *object)
 183 {
 184   GMountOperation *operation;
 185   GMountOperationPrivate *priv;
 186
 187   operation = G_MOUNT_OPERATION (object);
 188
 189   priv = operation->priv;
 190
 191   g_free (priv->password);
 192   g_free (priv->user);
 193   g_free (priv->domain);
 194
 195   G_OBJECT_CLASS (g_mount_operation_parent_class)->finalize (object);
 196 }
 197
 198 static gboolean
 199 reply_non_handled_in_idle (gpointer data)
 200 {
 201   GMountOperation *op = data;
 202
 203   g_mount_operation_reply (op, G_MOUNT_OPERATION_UNHANDLED);
 204   return G_SOURCE_REMOVE;
 205 }
 206
 207 static void
 208 ask_password (GMountOperation *op,
 209               const char      *message,
 210               const char      *default_user,
 211               const char      *default_domain,
 212               GAskPasswordFlags flags)
 213 {
 214   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 215                    reply_non_handled_in_idle,
 216                    g_object_ref (op),
 217                    g_object_unref);
 218 }
 219
 220 static void
 221 ask_question (GMountOperation *op,
 222               const char      *message,
 223               const char      *choices[])
 224 {
 225   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 226                    reply_non_handled_in_idle,
 227                    g_object_ref (op),
 228                    g_object_unref);
 229 }
 230
 231 static void
 232 show_processes (GMountOperation      *op,
 233                 const gchar          *message,
 234                 GArray               *processes,
 235                 const gchar          *choices[])
 236 {
 237   g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 238                    reply_non_handled_in_idle,
 239                    g_object_ref (op),
 240                    g_object_unref);
 241 }
 242
 243 static void
 244 show_unmount_progress (GMountOperation *op,
 245                        const gchar     *message,
 246                        guint64          time_left,
 247                        guint64          bytes_left)
 248 {
 249   /* nothing to do */
 250 }
 251
 252 static void
 253 g_mount_operation_class_init (GMountOperationClass *klass)
 254 {
 255   GObjectClass *object_class;
 256
 257   g_type_class_add_private (klass, sizeof (GMountOperationPrivate));
 258
 259   object_class = G_OBJECT_CLASS (klass);
 260   object_class->finalize = g_mount_operation_finalize;
 261   object_class->get_property = g_mount_operation_get_property;
 262   object_class->set_property = g_mount_operation_set_property;
 263
 264   klass->ask_password = ask_password;
 265   klass->ask_question = ask_question;
 266   klass->show_processes = show_processes;
 267   klass->show_unmount_progress = show_unmount_progress;
 268
 269   /**
 270    * GMountOperation::ask-password:
 271    * @op: a #GMountOperation requesting a password.
 272    * @message: string containing a message to display to the user.
 273    * @default_user: string containing the default user name.
 274    * @default_domain: string containing the default domain.
 275    * @flags: a set of #GAskPasswordFlags.
 276    *
 277    * Emitted when a mount operation asks the user for a password.
 278    *
 279    * If the message contains a line break, the first line should be
 280    * presented as a heading. For example, it may be used as the
 281    * primary text in a #GtkMessageDialog.
 282    */
 283   signals[ASK_PASSWORD] =
 284     g_signal_new (I_("ask-password"),
 285                   G_TYPE_FROM_CLASS (object_class),
 286                   G_SIGNAL_RUN_LAST,
 287                   G_STRUCT_OFFSET (GMountOperationClass, ask_password),
 288                   NULL, NULL,
 289                   NULL,
 290                   G_TYPE_NONE, 4,
 291                   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_ASK_PASSWORD_FLAGS);
 292
 293   /**
 294    * GMountOperation::ask-question:
 295    * @op: a #GMountOperation asking a question.
 296    * @message: string containing a message to display to the user.
 297    * @choices: an array of strings for each possible choice.
 298    *
 299    * Emitted when asking the user a question and gives a list of
 300    * choices for the user to choose from.
 301    *
 302    * If the message contains a line break, the first line should be
 303    * presented as a heading. For example, it may be used as the
 304    * primary text in a #GtkMessageDialog.
 305    */
 306   signals[ASK_QUESTION] =
 307     g_signal_new (I_("ask-question"),
 308                   G_TYPE_FROM_CLASS (object_class),
 309                   G_SIGNAL_RUN_LAST,
 310                   G_STRUCT_OFFSET (GMountOperationClass, ask_question),
 311                   NULL, NULL,
 312                   NULL,
 313                   G_TYPE_NONE, 2,
 314                   G_TYPE_STRING, G_TYPE_STRV);
 315
 316   /**
 317    * GMountOperation::reply:
 318    * @op: a #GMountOperation.
 319    * @result: a #GMountOperationResult indicating how the request was handled
 320    *
 321    * Emitted when the user has replied to the mount operation.
 322    */
 323   signals[REPLY] =
 324     g_signal_new (I_("reply"),
 325                   G_TYPE_FROM_CLASS (object_class),
 326                   G_SIGNAL_RUN_LAST,
 327                   G_STRUCT_OFFSET (GMountOperationClass, reply),
 328                   NULL, NULL,
 329                   g_cclosure_marshal_VOID__ENUM,
 330                   G_TYPE_NONE, 1,
 331                   G_TYPE_MOUNT_OPERATION_RESULT);
 332
 333   /**
 334    * GMountOperation::aborted:
 335    *
 336    * Emitted by the backend when e.g. a device becomes unavailable
 337    * while a mount operation is in progress.
 338    *
 339    * Implementations of GMountOperation should handle this signal
 340    * by dismissing open password dialogs.
 341    *
 342    * Since: 2.20
 343    */
 344   signals[ABORTED] =
 345     g_signal_new (I_("aborted"),
 346                   G_TYPE_FROM_CLASS (object_class),
 347                   G_SIGNAL_RUN_LAST,
 348                   G_STRUCT_OFFSET (GMountOperationClass, aborted),
 349                   NULL, NULL,
 350                   g_cclosure_marshal_VOID__VOID,
 351                   G_TYPE_NONE, 0);
 352
 353   /**
 354    * GMountOperation::show-processes:
 355    * @op: a #GMountOperation.
 356    * @message: string containing a message to display to the user.
 357    * @processes: (element-type GPid): an array of #GPid for processes
 358    *   blocking the operation.
 359    * @choices: an array of strings for each possible choice.
 360    *
 361    * Emitted when one or more processes are blocking an operation
 362    * e.g. unmounting/ejecting a #GMount or stopping a #GDrive.
 363    *
 364    * Note that this signal may be emitted several times to update the
 365    * list of blocking processes as processes close files. The
 366    * application should only respond with g_mount_operation_reply() to
 367    * the latest signal (setting #GMountOperation:choice to the choice
 368    * the user made).
 369    *
 370    * If the message contains a line break, the first line should be
 371    * presented as a heading. For example, it may be used as the
 372    * primary text in a #GtkMessageDialog.
 373    *
 374    * Since: 2.22
 375    */
 376   signals[SHOW_PROCESSES] =
 377     g_signal_new (I_("show-processes"),
 378                   G_TYPE_FROM_CLASS (object_class),
 379                   G_SIGNAL_RUN_LAST,
 380                   G_STRUCT_OFFSET (GMountOperationClass, show_processes),
 381                   NULL, NULL,
 382                   NULL,
 383                   G_TYPE_NONE, 3,
 384                   G_TYPE_STRING, G_TYPE_ARRAY, G_TYPE_STRV);
 385
 386   /**
 387    * GMountOperation::show-unmount-progress:
 388    * @op: a #GMountOperation:
 389    * @message: string containing a mesage to display to the user
 390    * @time_left: the estimated time left before the operation completes, or -1
 391    * @bytes_left: the amount of bytes to be written before the operation
 392    *     completes (or -1 if such amount is not known), or zero if the operation
 393    *     is completed
 394    *
 395    * Emitted when an unmount operation has been busy for more than some time
 396    * (typically 1.5 seconds).
 397    *
 398    * When unmounting or ejecting a volume, the kernel might need to flush
 399    * pending data in its buffers to the volume stable storage, and this operation
 400    * can take a considerable amount of time. This signal may be emitted several
 401    * times as long as the unmount operation is outstanding, and then one
 402    * last time when the operation is completed, with @bytes_left set to zero.
 403    *
 404    * Implementations of GMountOperation should handle this signal by
 405    * showing an UI notification, and then dismiss it, or show another notification
 406    * of completion, when @bytes_left reaches zero.
 407    *
 408    * If the message contains a line break, the first line should be
 409    * presented as a heading. For example, it may be used as the
 410    * primary text in a #GtkMessageDialog.
 411    *
 412    * Since: 2.34
 413    */
 414   signals[SHOW_UNMOUNT_PROGRESS] =
 415     g_signal_new (I_("show-unmount-progress"),
 416                   G_TYPE_FROM_CLASS (object_class),
 417                   G_SIGNAL_RUN_LAST,
 418                   G_STRUCT_OFFSET (GMountOperationClass, show_unmount_progress),
 419                   NULL, NULL, NULL,
 420                   G_TYPE_NONE, 3,
 421                   G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64);
 422
 423   /**
 424    * GMountOperation:username:
 425    *
 426    * The user name that is used for authentication when carrying out
 427    * the mount operation.
 428    */
 429   g_object_class_install_property (object_class,
 430                                    PROP_USERNAME,
 431                                    g_param_spec_string ("username",
 432                                                         P_("Username"),
 433                                                         P_("The user name"),
 434                                                         NULL,
 435                                                         G_PARAM_READWRITE|
 436                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 437
 438   /**
 439    * GMountOperation:password:
 440    *
 441    * The password that is used for authentication when carrying out
 442    * the mount operation.
 443    */
 444   g_object_class_install_property (object_class,
 445                                    PROP_PASSWORD,
 446                                    g_param_spec_string ("password",
 447                                                         P_("Password"),
 448                                                         P_("The password"),
 449                                                         NULL,
 450                                                         G_PARAM_READWRITE|
 451                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 452
 453   /**
 454    * GMountOperation:anonymous:
 455    *
 456    * Whether to use an anonymous user when authenticating.
 457    */
 458   g_object_class_install_property (object_class,
 459                                    PROP_ANONYMOUS,
 460                                    g_param_spec_boolean ("anonymous",
 461                                                          P_("Anonymous"),
 462                                                          P_("Whether to use an anonymous user"),
 463                                                          FALSE,
 464                                                          G_PARAM_READWRITE|
 465                                                          G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 466
 467   /**
 468    * GMountOperation:domain:
 469    *
 470    * The domain to use for the mount operation.
 471    */
 472   g_object_class_install_property (object_class,
 473                                    PROP_DOMAIN,
 474                                    g_param_spec_string ("domain",
 475                                                         P_("Domain"),
 476                                                         P_("The domain of the mount operation"),
 477                                                         NULL,
 478                                                         G_PARAM_READWRITE|
 479                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 480
 481   /**
 482    * GMountOperation:password-save:
 483    *
 484    * Determines if and how the password information should be saved.
 485    */
 486   g_object_class_install_property (object_class,
 487                                    PROP_PASSWORD_SAVE,
 488                                    g_param_spec_enum ("password-save",
 489                                                       P_("Password save"),
 490                                                       P_("How passwords should be saved"),
 491                                                       G_TYPE_PASSWORD_SAVE,
 492                                                       G_PASSWORD_SAVE_NEVER,
 493                                                       G_PARAM_READWRITE|
 494                                                       G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 495
 496   /**
 497    * GMountOperation:choice:
 498    *
 499    * The index of the user's choice when a question is asked during the
 500    * mount operation. See the #GMountOperation::ask-question signal.
 501    */
 502   g_object_class_install_property (object_class,
 503                                    PROP_CHOICE,
 504                                    g_param_spec_int ("choice",
 505                                                      P_("Choice"),
 506                                                      P_("The users choice"),
 507                                                      0, G_MAXINT, 0,
 508                                                      G_PARAM_READWRITE|
 509                                                      G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 510 }
 511
 512 static void
 513 g_mount_operation_init (GMountOperation *operation)
 514 {
 515   operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
 516                                                  G_TYPE_MOUNT_OPERATION,
 517                                                  GMountOperationPrivate);
 518 }
 519
 520 /**
 521  * g_mount_operation_new:
 522  *
 523  * Creates a new mount operation.
 524  *
 525  * Returns: a #GMountOperation.
 526  **/
 527 GMountOperation *
 528 g_mount_operation_new (void)
 529 {
 530   return g_object_new (G_TYPE_MOUNT_OPERATION, NULL);
 531 }
 532
 533 /**
 534  * g_mount_operation_get_username:
 535  * @op: a #GMountOperation.
 536  *
 537  * Get the user name from the mount operation.
 538  *
 539  * Returns: a string containing the user name.
 540  **/
 541 const char *
 542 g_mount_operation_get_username (GMountOperation *op)
 543 {
 544   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 545   return op->priv->user;
 546 }
 547
 548 /**
 549  * g_mount_operation_set_username:
 550  * @op: a #GMountOperation.
 551  * @username: input username.
 552  *
 553  * Sets the user name within @op to @username.
 554  **/
 555 void
 556 g_mount_operation_set_username (GMountOperation *op,
 557                                 const char      *username)
 558 {
 559   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 560   g_free (op->priv->user);
 561   op->priv->user = g_strdup (username);
 562   g_object_notify (G_OBJECT (op), "username");
 563 }
 564
 565 /**
 566  * g_mount_operation_get_password:
 567  * @op: a #GMountOperation.
 568  *
 569  * Gets a password from the mount operation.
 570  *
 571  * Returns: a string containing the password within @op.
 572  **/
 573 const char *
 574 g_mount_operation_get_password (GMountOperation *op)
 575 {
 576   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 577   return op->priv->password;
 578 }
 579
 580 /**
 581  * g_mount_operation_set_password:
 582  * @op: a #GMountOperation.
 583  * @password: password to set.
 584  *
 585  * Sets the mount operation's password to @password.
 586  *
 587  **/
 588 void
 589 g_mount_operation_set_password (GMountOperation *op,
 590                                 const char      *password)
 591 {
 592   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 593   g_free (op->priv->password);
 594   op->priv->password = g_strdup (password);
 595   g_object_notify (G_OBJECT (op), "password");
 596 }
 597
 598 /**
 599  * g_mount_operation_get_anonymous:
 600  * @op: a #GMountOperation.
 601  *
 602  * Check to see whether the mount operation is being used
 603  * for an anonymous user.
 604  *
 605  * Returns: %TRUE if mount operation is anonymous.
 606  **/
 607 gboolean
 608 g_mount_operation_get_anonymous (GMountOperation *op)
 609 {
 610   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), FALSE);
 611   return op->priv->anonymous;
 612 }
 613
 614 /**
 615  * g_mount_operation_set_anonymous:
 616  * @op: a #GMountOperation.
 617  * @anonymous: boolean value.
 618  *
 619  * Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
 620  **/
 621 void
 622 g_mount_operation_set_anonymous (GMountOperation *op,
 623                                  gboolean         anonymous)
 624 {
 625   GMountOperationPrivate *priv;
 626   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 627   priv = op->priv;
 628
 629   if (priv->anonymous != anonymous)
 630     {
 631       priv->anonymous = anonymous;
 632       g_object_notify (G_OBJECT (op), "anonymous");
 633     }
 634 }
 635
 636 /**
 637  * g_mount_operation_get_domain:
 638  * @op: a #GMountOperation.
 639  *
 640  * Gets the domain of the mount operation.
 641  *
 642  * Returns: a string set to the domain.
 643  **/
 644 const char *
 645 g_mount_operation_get_domain (GMountOperation *op)
 646 {
 647   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 648   return op->priv->domain;
 649 }
 650
 651 /**
 652  * g_mount_operation_set_domain:
 653  * @op: a #GMountOperation.
 654  * @domain: the domain to set.
 655  *
 656  * Sets the mount operation's domain.
 657  **/
 658 void
 659 g_mount_operation_set_domain (GMountOperation *op,
 660                               const char      *domain)
 661 {
 662   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 663   g_free (op->priv->domain);
 664   op->priv->domain = g_strdup (domain);
 665   g_object_notify (G_OBJECT (op), "domain");
 666 }
 667
 668 /**
 669  * g_mount_operation_get_password_save:
 670  * @op: a #GMountOperation.
 671  *
 672  * Gets the state of saving passwords for the mount operation.
 673  *
 674  * Returns: a #GPasswordSave flag.
 675  **/
 676
 677 GPasswordSave
 678 g_mount_operation_get_password_save (GMountOperation *op)
 679 {
 680   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), G_PASSWORD_SAVE_NEVER);
 681   return op->priv->password_save;
 682 }
 683
 684 /**
 685  * g_mount_operation_set_password_save:
 686  * @op: a #GMountOperation.
 687  * @save: a set of #GPasswordSave flags.
 688  *
 689  * Sets the state of saving passwords for the mount operation.
 690  *
 691  **/
 692 void
 693 g_mount_operation_set_password_save (GMountOperation *op,
 694                                      GPasswordSave    save)
 695 {
 696   GMountOperationPrivate *priv;
 697   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 698   priv = op->priv;
 699
 700   if (priv->password_save != save)
 701     {
 702       priv->password_save = save;
 703       g_object_notify (G_OBJECT (op), "password-save");
 704     }
 705 }
 706
 707 /**
 708  * g_mount_operation_get_choice:
 709  * @op: a #GMountOperation.
 710  *
 711  * Gets a choice from the mount operation.
 712  *
 713  * Returns: an integer containing an index of the user's choice from
 714  * the choice's list, or %0.
 715  **/
 716 int
 717 g_mount_operation_get_choice (GMountOperation *op)
 718 {
 719   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), 0);
 720   return op->priv->choice;
 721 }
 722
 723 /**
 724  * g_mount_operation_set_choice:
 725  * @op: a #GMountOperation.
 726  * @choice: an integer.
 727  *
 728  * Sets a default choice for the mount operation.
 729  **/
 730 void
 731 g_mount_operation_set_choice (GMountOperation *op,
 732                               int              choice)
 733 {
 734   GMountOperationPrivate *priv;
 735   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 736   priv = op->priv;
 737   if (priv->choice != choice)
 738     {
 739       priv->choice = choice;
 740       g_object_notify (G_OBJECT (op), "choice");
 741     }
 742 }
 743
 744 /**
 745  * g_mount_operation_reply:
 746  * @op: a #GMountOperation
 747  * @result: a #GMountOperationResult
 748  *
 749  * Emits the #GMountOperation::reply signal.
 750  **/
 751 void
 752 g_mount_operation_reply (GMountOperation *op,
 753                          GMountOperationResult result)
 754 {
 755   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 756   g_signal_emit (op, signals[REPLY], 0, result);
 757 }