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   signals[SHOW_UNMOUNT_PROGRESS] =
 413     g_signal_new (I_("show-unmount-progress"),
 414                   G_TYPE_FROM_CLASS (object_class),
 415                   G_SIGNAL_RUN_LAST,
 416                   G_STRUCT_OFFSET (GMountOperationClass, show_unmount_progress),
 417                   NULL, NULL, NULL,
 418                   G_TYPE_NONE, 3,
 419                   G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64);
 420
 421   /**
 422    * GMountOperation:username:
 423    *
 424    * The user name that is used for authentication when carrying out
 425    * the mount operation.
 426    */
 427   g_object_class_install_property (object_class,
 428                                    PROP_USERNAME,
 429                                    g_param_spec_string ("username",
 430                                                         P_("Username"),
 431                                                         P_("The user name"),
 432                                                         NULL,
 433                                                         G_PARAM_READWRITE|
 434                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 435
 436   /**
 437    * GMountOperation:password:
 438    *
 439    * The password that is used for authentication when carrying out
 440    * the mount operation.
 441    */
 442   g_object_class_install_property (object_class,
 443                                    PROP_PASSWORD,
 444                                    g_param_spec_string ("password",
 445                                                         P_("Password"),
 446                                                         P_("The password"),
 447                                                         NULL,
 448                                                         G_PARAM_READWRITE|
 449                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 450
 451   /**
 452    * GMountOperation:anonymous:
 453    *
 454    * Whether to use an anonymous user when authenticating.
 455    */
 456   g_object_class_install_property (object_class,
 457                                    PROP_ANONYMOUS,
 458                                    g_param_spec_boolean ("anonymous",
 459                                                          P_("Anonymous"),
 460                                                          P_("Whether to use an anonymous user"),
 461                                                          FALSE,
 462                                                          G_PARAM_READWRITE|
 463                                                          G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 464
 465   /**
 466    * GMountOperation:domain:
 467    *
 468    * The domain to use for the mount operation.
 469    */
 470   g_object_class_install_property (object_class,
 471                                    PROP_DOMAIN,
 472                                    g_param_spec_string ("domain",
 473                                                         P_("Domain"),
 474                                                         P_("The domain of the mount operation"),
 475                                                         NULL,
 476                                                         G_PARAM_READWRITE|
 477                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 478
 479   /**
 480    * GMountOperation:password-save:
 481    *
 482    * Determines if and how the password information should be saved.
 483    */
 484   g_object_class_install_property (object_class,
 485                                    PROP_PASSWORD_SAVE,
 486                                    g_param_spec_enum ("password-save",
 487                                                       P_("Password save"),
 488                                                       P_("How passwords should be saved"),
 489                                                       G_TYPE_PASSWORD_SAVE,
 490                                                       G_PASSWORD_SAVE_NEVER,
 491                                                       G_PARAM_READWRITE|
 492                                                       G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 493
 494   /**
 495    * GMountOperation:choice:
 496    *
 497    * The index of the user's choice when a question is asked during the
 498    * mount operation. See the #GMountOperation::ask-question signal.
 499    */
 500   g_object_class_install_property (object_class,
 501                                    PROP_CHOICE,
 502                                    g_param_spec_int ("choice",
 503                                                      P_("Choice"),
 504                                                      P_("The users choice"),
 505                                                      0, G_MAXINT, 0,
 506                                                      G_PARAM_READWRITE|
 507                                                      G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 508 }
 509
 510 static void
 511 g_mount_operation_init (GMountOperation *operation)
 512 {
 513   operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
 514                                                  G_TYPE_MOUNT_OPERATION,
 515                                                  GMountOperationPrivate);
 516 }
 517
 518 /**
 519  * g_mount_operation_new:
 520  *
 521  * Creates a new mount operation.
 522  *
 523  * Returns: a #GMountOperation.
 524  **/
 525 GMountOperation *
 526 g_mount_operation_new (void)
 527 {
 528   return g_object_new (G_TYPE_MOUNT_OPERATION, NULL);
 529 }
 530
 531 /**
 532  * g_mount_operation_get_username:
 533  * @op: a #GMountOperation.
 534  *
 535  * Get the user name from the mount operation.
 536  *
 537  * Returns: a string containing the user name.
 538  **/
 539 const char *
 540 g_mount_operation_get_username (GMountOperation *op)
 541 {
 542   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 543   return op->priv->user;
 544 }
 545
 546 /**
 547  * g_mount_operation_set_username:
 548  * @op: a #GMountOperation.
 549  * @username: input username.
 550  *
 551  * Sets the user name within @op to @username.
 552  **/
 553 void
 554 g_mount_operation_set_username (GMountOperation *op,
 555                                 const char      *username)
 556 {
 557   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 558   g_free (op->priv->user);
 559   op->priv->user = g_strdup (username);
 560   g_object_notify (G_OBJECT (op), "username");
 561 }
 562
 563 /**
 564  * g_mount_operation_get_password:
 565  * @op: a #GMountOperation.
 566  *
 567  * Gets a password from the mount operation.
 568  *
 569  * Returns: a string containing the password within @op.
 570  **/
 571 const char *
 572 g_mount_operation_get_password (GMountOperation *op)
 573 {
 574   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 575   return op->priv->password;
 576 }
 577
 578 /**
 579  * g_mount_operation_set_password:
 580  * @op: a #GMountOperation.
 581  * @password: password to set.
 582  *
 583  * Sets the mount operation's password to @password.
 584  *
 585  **/
 586 void
 587 g_mount_operation_set_password (GMountOperation *op,
 588                                 const char      *password)
 589 {
 590   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 591   g_free (op->priv->password);
 592   op->priv->password = g_strdup (password);
 593   g_object_notify (G_OBJECT (op), "password");
 594 }
 595
 596 /**
 597  * g_mount_operation_get_anonymous:
 598  * @op: a #GMountOperation.
 599  *
 600  * Check to see whether the mount operation is being used
 601  * for an anonymous user.
 602  *
 603  * Returns: %TRUE if mount operation is anonymous.
 604  **/
 605 gboolean
 606 g_mount_operation_get_anonymous (GMountOperation *op)
 607 {
 608   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), FALSE);
 609   return op->priv->anonymous;
 610 }
 611
 612 /**
 613  * g_mount_operation_set_anonymous:
 614  * @op: a #GMountOperation.
 615  * @anonymous: boolean value.
 616  *
 617  * Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
 618  **/
 619 void
 620 g_mount_operation_set_anonymous (GMountOperation *op,
 621                                  gboolean         anonymous)
 622 {
 623   GMountOperationPrivate *priv;
 624   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 625   priv = op->priv;
 626
 627   if (priv->anonymous != anonymous)
 628     {
 629       priv->anonymous = anonymous;
 630       g_object_notify (G_OBJECT (op), "anonymous");
 631     }
 632 }
 633
 634 /**
 635  * g_mount_operation_get_domain:
 636  * @op: a #GMountOperation.
 637  *
 638  * Gets the domain of the mount operation.
 639  *
 640  * Returns: a string set to the domain.
 641  **/
 642 const char *
 643 g_mount_operation_get_domain (GMountOperation *op)
 644 {
 645   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
 646   return op->priv->domain;
 647 }
 648
 649 /**
 650  * g_mount_operation_set_domain:
 651  * @op: a #GMountOperation.
 652  * @domain: the domain to set.
 653  *
 654  * Sets the mount operation's domain.
 655  **/
 656 void
 657 g_mount_operation_set_domain (GMountOperation *op,
 658                               const char      *domain)
 659 {
 660   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 661   g_free (op->priv->domain);
 662   op->priv->domain = g_strdup (domain);
 663   g_object_notify (G_OBJECT (op), "domain");
 664 }
 665
 666 /**
 667  * g_mount_operation_get_password_save:
 668  * @op: a #GMountOperation.
 669  *
 670  * Gets the state of saving passwords for the mount operation.
 671  *
 672  * Returns: a #GPasswordSave flag.
 673  **/
 674
 675 GPasswordSave
 676 g_mount_operation_get_password_save (GMountOperation *op)
 677 {
 678   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), G_PASSWORD_SAVE_NEVER);
 679   return op->priv->password_save;
 680 }
 681
 682 /**
 683  * g_mount_operation_set_password_save:
 684  * @op: a #GMountOperation.
 685  * @save: a set of #GPasswordSave flags.
 686  *
 687  * Sets the state of saving passwords for the mount operation.
 688  *
 689  **/
 690 void
 691 g_mount_operation_set_password_save (GMountOperation *op,
 692                                      GPasswordSave    save)
 693 {
 694   GMountOperationPrivate *priv;
 695   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 696   priv = op->priv;
 697
 698   if (priv->password_save != save)
 699     {
 700       priv->password_save = save;
 701       g_object_notify (G_OBJECT (op), "password-save");
 702     }
 703 }
 704
 705 /**
 706  * g_mount_operation_get_choice:
 707  * @op: a #GMountOperation.
 708  *
 709  * Gets a choice from the mount operation.
 710  *
 711  * Returns: an integer containing an index of the user's choice from
 712  * the choice's list, or %0.
 713  **/
 714 int
 715 g_mount_operation_get_choice (GMountOperation *op)
 716 {
 717   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), 0);
 718   return op->priv->choice;
 719 }
 720
 721 /**
 722  * g_mount_operation_set_choice:
 723  * @op: a #GMountOperation.
 724  * @choice: an integer.
 725  *
 726  * Sets a default choice for the mount operation.
 727  **/
 728 void
 729 g_mount_operation_set_choice (GMountOperation *op,
 730                               int              choice)
 731 {
 732   GMountOperationPrivate *priv;
 733   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 734   priv = op->priv;
 735   if (priv->choice != choice)
 736     {
 737       priv->choice = choice;
 738       g_object_notify (G_OBJECT (op), "choice");
 739     }
 740 }
 741
 742 /**
 743  * g_mount_operation_reply:
 744  * @op: a #GMountOperation
 745  * @result: a #GMountOperationResult
 746  *
 747  * Emits the #GMountOperation::reply signal.
 748  **/
 749 void
 750 g_mount_operation_reply (GMountOperation *op,
 751                          GMountOperationResult result)
 752 {
 753   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
 754   g_signal_emit (op, signals[REPLY], 0, result);
 755 }