Merge remote branch 'gvdb/master'
[platform/upstream/glib.git] / 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
33 /**
34  * SECTION:gmountoperation
35  * @short_description: Object used for authentication and user interaction
36  * @include: gio/gio.h
37  *
38  * #GMountOperation provides a mechanism for interacting with the user.
39  * It can be used for authenticating mountable operations, such as loop
40  * mounting files, hard drive partitions or server locations. It can
41  * also be used to ask the user questions or show a list of applications
42  * preventing unmount or eject operations from completing.
43  *
44  * Note that #GMountOperation is used for more than just #GMount
45  * objects – for example it is also used in g_drive_start() and
46  * g_drive_stop().
47  *
48  * Users should instantiate a subclass of this that implements all the
49  * various callbacks to show the required dialogs, such as
50  * #GtkMountOperation. If no user interaction is desired (for example
51  * when automounting filesystems at login time), usually %NULL can be
52  * passed, see each method taking a #GMountOperation for details.
53  */
54
55 G_DEFINE_TYPE (GMountOperation, g_mount_operation, G_TYPE_OBJECT);
56
57 enum {
58   ASK_PASSWORD,
59   ASK_QUESTION,
60   REPLY,
61   ABORTED,
62   SHOW_PROCESSES,
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 FALSE;
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 g_mount_operation_class_init (GMountOperationClass *klass)
245 {
246   GObjectClass *object_class;
247   
248   g_type_class_add_private (klass, sizeof (GMountOperationPrivate));
249  
250   object_class = G_OBJECT_CLASS (klass);
251   object_class->finalize = g_mount_operation_finalize;
252   object_class->get_property = g_mount_operation_get_property;
253   object_class->set_property = g_mount_operation_set_property;
254   
255   klass->ask_password = ask_password;
256   klass->ask_question = ask_question;
257   klass->show_processes = show_processes;
258   
259   /**
260    * GMountOperation::ask-password:
261    * @op: a #GMountOperation requesting a password.
262    * @message: string containing a message to display to the user.
263    * @default_user: string containing the default user name.
264    * @default_domain: string containing the default domain.
265    * @flags: a set of #GAskPasswordFlags.
266    *
267    * Emitted when a mount operation asks the user for a password.
268    *
269    * If the message contains a line break, the first line should be
270    * presented as a heading. For example, it may be used as the
271    * primary text in a #GtkMessageDialog.
272    */
273   signals[ASK_PASSWORD] =
274     g_signal_new (I_("ask-password"),
275                   G_TYPE_FROM_CLASS (object_class),
276                   G_SIGNAL_RUN_LAST,
277                   G_STRUCT_OFFSET (GMountOperationClass, ask_password),
278                   NULL, NULL,
279                   _gio_marshal_VOID__STRING_STRING_STRING_FLAGS,
280                   G_TYPE_NONE, 4,
281                   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_ASK_PASSWORD_FLAGS);
282                   
283   /**
284    * GMountOperation::ask-question:
285    * @op: a #GMountOperation asking a question.
286    * @message: string containing a message to display to the user.
287    * @choices: an array of strings for each possible choice.
288    *
289    * Emitted when asking the user a question and gives a list of
290    * choices for the user to choose from.
291    *
292    * If the message contains a line break, the first line should be
293    * presented as a heading. For example, it may be used as the
294    * primary text in a #GtkMessageDialog.
295    */
296   signals[ASK_QUESTION] =
297     g_signal_new (I_("ask-question"),
298                   G_TYPE_FROM_CLASS (object_class),
299                   G_SIGNAL_RUN_LAST,
300                   G_STRUCT_OFFSET (GMountOperationClass, ask_question),
301                   NULL, NULL,
302                   _gio_marshal_VOID__STRING_BOXED,
303                   G_TYPE_NONE, 2,
304                   G_TYPE_STRING, G_TYPE_STRV);
305                   
306   /**
307    * GMountOperation::reply:
308    * @op: a #GMountOperation.
309    * @result: a #GMountOperationResult indicating how the request was handled
310    *
311    * Emitted when the user has replied to the mount operation.
312    */
313   signals[REPLY] =
314     g_signal_new (I_("reply"),
315                   G_TYPE_FROM_CLASS (object_class),
316                   G_SIGNAL_RUN_LAST,
317                   G_STRUCT_OFFSET (GMountOperationClass, reply),
318                   NULL, NULL,
319                   g_cclosure_marshal_VOID__ENUM,
320                   G_TYPE_NONE, 1,
321                   G_TYPE_MOUNT_OPERATION_RESULT);
322
323   /**
324    * GMountOperation::aborted:
325    *
326    * Emitted by the backend when e.g. a device becomes unavailable
327    * while a mount operation is in progress.
328    *
329    * Implementations of GMountOperation should handle this signal
330    * by dismissing open password dialogs.
331    *
332    * Since: 2.20
333    */
334   signals[ABORTED] =
335     g_signal_new (I_("aborted"),
336                   G_TYPE_FROM_CLASS (object_class),
337                   G_SIGNAL_RUN_LAST,
338                   G_STRUCT_OFFSET (GMountOperationClass, aborted),
339                   NULL, NULL,
340                   g_cclosure_marshal_VOID__VOID,
341                   G_TYPE_NONE, 0);
342
343   /**
344    * GMountOperation::show-processes:
345    * @op: a #GMountOperation.
346    * @message: string containing a message to display to the user.
347    * @processes: an array of #GPid for processes blocking the operation.
348    * @choices: an array of strings for each possible choice.
349    *
350    * Emitted when one or more processes are blocking an operation
351    * e.g. unmounting/ejecting a #GMount or stopping a #GDrive.
352    *
353    * Note that this signal may be emitted several times to update the
354    * list of blocking processes as processes close files. The
355    * application should only respond with g_mount_operation_reply() to
356    * the latest signal (setting #GMountOperation:choice to the choice
357    * the user made).
358    *
359    * If the message contains a line break, the first line should be
360    * presented as a heading. For example, it may be used as the
361    * primary text in a #GtkMessageDialog.
362    *
363    * Since: 2.22
364    */
365   signals[SHOW_PROCESSES] =
366     g_signal_new (I_("show-processes"),
367                   G_TYPE_FROM_CLASS (object_class),
368                   G_SIGNAL_RUN_LAST,
369                   G_STRUCT_OFFSET (GMountOperationClass, show_processes),
370                   NULL, NULL,
371                   _gio_marshal_VOID__STRING_BOXED_BOXED,
372                   G_TYPE_NONE, 3,
373                   G_TYPE_STRING, G_TYPE_ARRAY, G_TYPE_STRV);
374
375   /**
376    * GMountOperation:username:
377    *
378    * The user name that is used for authentication when carrying out
379    * the mount operation.
380    */ 
381   g_object_class_install_property (object_class,
382                                    PROP_USERNAME,
383                                    g_param_spec_string ("username",
384                                                         P_("Username"),
385                                                         P_("The user name"),
386                                                         NULL,
387                                                         G_PARAM_READWRITE|
388                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
389
390   /**
391    * GMountOperation:password:
392    *
393    * The password that is used for authentication when carrying out
394    * the mount operation.
395    */ 
396   g_object_class_install_property (object_class,
397                                    PROP_PASSWORD,
398                                    g_param_spec_string ("password",
399                                                         P_("Password"),
400                                                         P_("The password"),
401                                                         NULL,
402                                                         G_PARAM_READWRITE|
403                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
404
405   /**
406    * GMountOperation:anonymous:
407    * 
408    * Whether to use an anonymous user when authenticating.
409    */
410   g_object_class_install_property (object_class,
411                                    PROP_ANONYMOUS,
412                                    g_param_spec_boolean ("anonymous",
413                                                          P_("Anonymous"),
414                                                          P_("Whether to use an anonymous user"),
415                                                          FALSE,
416                                                          G_PARAM_READWRITE|
417                                                          G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
418
419   /**
420    * GMountOperation:domain:
421    *
422    * The domain to use for the mount operation.
423    */ 
424   g_object_class_install_property (object_class,
425                                    PROP_DOMAIN,
426                                    g_param_spec_string ("domain",
427                                                         P_("Domain"),
428                                                         P_("The domain of the mount operation"),
429                                                         NULL,
430                                                         G_PARAM_READWRITE|
431                                                         G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
432
433   /**
434    * GMountOperation:password-save:
435    *
436    * Determines if and how the password information should be saved. 
437    */ 
438   g_object_class_install_property (object_class,
439                                    PROP_PASSWORD_SAVE,
440                                    g_param_spec_enum ("password-save",
441                                                       P_("Password save"),
442                                                       P_("How passwords should be saved"),
443                                                       G_TYPE_PASSWORD_SAVE,
444                                                       G_PASSWORD_SAVE_NEVER,
445                                                       G_PARAM_READWRITE|
446                                                       G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
447
448   /**
449    * GMountOperation:choice:
450    *
451    * The index of the user's choice when a question is asked during the 
452    * mount operation. See the #GMountOperation::ask-question signal.
453    */ 
454   g_object_class_install_property (object_class,
455                                    PROP_CHOICE,
456                                    g_param_spec_int ("choice",
457                                                      P_("Choice"),
458                                                      P_("The users choice"),
459                                                      0, G_MAXINT, 0,
460                                                      G_PARAM_READWRITE|
461                                                      G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
462 }
463
464 static void
465 g_mount_operation_init (GMountOperation *operation)
466 {
467   operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
468                                                  G_TYPE_MOUNT_OPERATION,
469                                                  GMountOperationPrivate);
470 }
471
472 /**
473  * g_mount_operation_new:
474  * 
475  * Creates a new mount operation.
476  * 
477  * Returns: a #GMountOperation.
478  **/
479 GMountOperation *
480 g_mount_operation_new (void)
481 {
482   return g_object_new (G_TYPE_MOUNT_OPERATION, NULL);
483 }
484
485 /**
486  * g_mount_operation_get_username
487  * @op: a #GMountOperation.
488  * 
489  * Get the user name from the mount operation.
490  *
491  * Returns: a string containing the user name.
492  **/
493 const char *
494 g_mount_operation_get_username (GMountOperation *op)
495 {
496   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
497   return op->priv->user;
498 }
499
500 /**
501  * g_mount_operation_set_username:
502  * @op: a #GMountOperation.
503  * @username: input username.
504  *
505  * Sets the user name within @op to @username.
506  **/
507 void
508 g_mount_operation_set_username (GMountOperation *op,
509                                 const char      *username)
510 {
511   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
512   g_free (op->priv->user);
513   op->priv->user = g_strdup (username);
514   g_object_notify (G_OBJECT (op), "username");
515 }
516
517 /**
518  * g_mount_operation_get_password:
519  * @op: a #GMountOperation.
520  *
521  * Gets a password from the mount operation. 
522  *
523  * Returns: a string containing the password within @op.
524  **/
525 const char *
526 g_mount_operation_get_password (GMountOperation *op)
527 {
528   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
529   return op->priv->password;
530 }
531
532 /**
533  * g_mount_operation_set_password:
534  * @op: a #GMountOperation.
535  * @password: password to set.
536  * 
537  * Sets the mount operation's password to @password.  
538  *
539  **/
540 void
541 g_mount_operation_set_password (GMountOperation *op,
542                                 const char      *password)
543 {
544   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
545   g_free (op->priv->password);
546   op->priv->password = g_strdup (password);
547   g_object_notify (G_OBJECT (op), "password");
548 }
549
550 /**
551  * g_mount_operation_get_anonymous:
552  * @op: a #GMountOperation.
553  * 
554  * Check to see whether the mount operation is being used 
555  * for an anonymous user.
556  * 
557  * Returns: %TRUE if mount operation is anonymous. 
558  **/
559 gboolean
560 g_mount_operation_get_anonymous (GMountOperation *op)
561 {
562   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), FALSE);
563   return op->priv->anonymous;
564 }
565
566 /**
567  * g_mount_operation_set_anonymous:
568  * @op: a #GMountOperation.
569  * @anonymous: boolean value.
570  * 
571  * Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
572  **/  
573 void
574 g_mount_operation_set_anonymous (GMountOperation *op,
575                                  gboolean         anonymous)
576 {
577   GMountOperationPrivate *priv;
578   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
579   priv = op->priv;
580
581   if (priv->anonymous != anonymous)
582     {
583       priv->anonymous = anonymous;
584       g_object_notify (G_OBJECT (op), "anonymous");
585     }
586 }
587
588 /**
589  * g_mount_operation_get_domain:
590  * @op: a #GMountOperation.
591  * 
592  * Gets the domain of the mount operation.
593  * 
594  * Returns: a string set to the domain. 
595  **/
596 const char *
597 g_mount_operation_get_domain (GMountOperation *op)
598 {
599   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), NULL);
600   return op->priv->domain;
601 }
602
603 /**
604  * g_mount_operation_set_domain:
605  * @op: a #GMountOperation.
606  * @domain: the domain to set.
607  * 
608  * Sets the mount operation's domain. 
609  **/  
610 void
611 g_mount_operation_set_domain (GMountOperation *op,
612                               const char      *domain)
613 {
614   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
615   g_free (op->priv->domain);
616   op->priv->domain = g_strdup (domain);
617   g_object_notify (G_OBJECT (op), "domain");
618 }
619
620 /**
621  * g_mount_operation_get_password_save:
622  * @op: a #GMountOperation.
623  * 
624  * Gets the state of saving passwords for the mount operation.
625  *
626  * Returns: a #GPasswordSave flag. 
627  **/  
628
629 GPasswordSave
630 g_mount_operation_get_password_save (GMountOperation *op)
631 {
632   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), G_PASSWORD_SAVE_NEVER);
633   return op->priv->password_save;
634 }
635
636 /**
637  * g_mount_operation_set_password_save:
638  * @op: a #GMountOperation.
639  * @save: a set of #GPasswordSave flags.
640  * 
641  * Sets the state of saving passwords for the mount operation.
642  * 
643  **/   
644 void
645 g_mount_operation_set_password_save (GMountOperation *op,
646                                      GPasswordSave    save)
647 {
648   GMountOperationPrivate *priv;
649   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
650   priv = op->priv;
651  
652   if (priv->password_save != save)
653     {
654       priv->password_save = save;
655       g_object_notify (G_OBJECT (op), "password-save");
656     }
657 }
658
659 /**
660  * g_mount_operation_get_choice:
661  * @op: a #GMountOperation.
662  * 
663  * Gets a choice from the mount operation.
664  *
665  * Returns: an integer containing an index of the user's choice from 
666  * the choice's list, or %0.
667  **/
668 int
669 g_mount_operation_get_choice (GMountOperation *op)
670 {
671   g_return_val_if_fail (G_IS_MOUNT_OPERATION (op), 0);
672   return op->priv->choice;
673 }
674
675 /**
676  * g_mount_operation_set_choice:
677  * @op: a #GMountOperation.
678  * @choice: an integer.
679  *
680  * Sets a default choice for the mount operation.
681  **/
682 void
683 g_mount_operation_set_choice (GMountOperation *op,
684                               int              choice)
685 {
686   GMountOperationPrivate *priv;
687   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
688   priv = op->priv;
689   if (priv->choice != choice)
690     {
691       priv->choice = choice;
692       g_object_notify (G_OBJECT (op), "choice");
693     }
694 }
695
696 /**
697  * g_mount_operation_reply:
698  * @op: a #GMountOperation
699  * @result: a #GMountOperationResult
700  * 
701  * Emits the #GMountOperation::reply signal.
702  **/
703 void
704 g_mount_operation_reply (GMountOperation *op,
705                          GMountOperationResult result)
706 {
707   g_return_if_fail (G_IS_MOUNT_OPERATION (op));
708   g_signal_emit (op, signals[REPLY], 0, result);
709 }