GDBus: Hide instance structures for classes we don't want to be subclassed
[platform/upstream/glib.git] / gio / gdbusauthobserver.c
1 /* GDBus - GLib D-Bus Library
2  *
3  * Copyright (C) 2008-2010 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: David Zeuthen <davidz@redhat.com>
21  */
22
23 #include "config.h"
24
25 #include "gdbusauthobserver.h"
26 #include "gio-marshal.h"
27 #include "gcredentials.h"
28 #include "gioenumtypes.h"
29 #include "giostream.h"
30
31 #include "glibintl.h"
32 #include "gioalias.h"
33
34 /**
35  * SECTION:gdbusauthobserver
36  * @short_description: Object used for authenticating connections
37  * @include: gio/gio.h
38  *
39  * The #GDBusAuthObserver type provides a mechanism for participating
40  * in how a #GDBusServer (or a #GDBusConnection) authenticates remote
41  * peers. Simply instantiate a #GDBusAuthObserver and connect to the
42  * signals you are interested in. Note that new signals may be added
43  * in the future
44  *
45  * For example, if you only want to allow D-Bus connections from
46  * processes owned by the same uid as the server, you would do this:
47  * <example id="auth-observer"><title>Controlling Authentication</title><programlisting>
48  * static gboolean
49  * on_authorize_authenticated_peer (GDBusAuthObserver *observer,
50  *                                  GIOStream         *stream,
51  *                                  GCredentials      *credentials,
52  *                                  gpointer           user_data)
53  * {
54  *   GCredentials *me;
55  *   gboolean authorized;
56  *
57  *   authorized = FALSE;
58  *   me = g_credentials_new ();
59  *
60  *   if (credentials != NULL &&
61  *       !g_credentials_is_same_user (credentials, me))
62  *     authorized = TRUE;
63  *
64  *   g_object_unref (me);
65  *
66  *   return authorized;
67  * }
68  *
69  * static gboolean
70  * on_new_connection (GDBusServer     *server,
71  *                    GDBusConnection *connection,
72  *                    gpointer         user_data)
73  * {
74  *   /<!-- -->* Guaranteed here that @connection is from a process owned by the same user *<!-- -->/
75  * }
76  *
77  * [...]
78  *
79  * GDBusAuthObserver *observer;
80  * GDBusServer *server;
81  * GError *error;
82  *
83  * error = NULL;
84  * observer = g_dbus_auth_observer_new ();
85  * server = g_dbus_server_new_sync ("unix:tmpdir=/tmp/my-app-name",
86  *                                  G_DBUS_SERVER_FLAGS_NONE,
87  *                                  observer,
88  *                                  NULL, /<!-- -->* GCancellable *<!-- -->/
89  *                                  &error);
90  * g_signal_connect (observer,
91  *                   "authorize-authenticated-peer",
92  *                   G_CALLBACK (on_authorize_authenticated_peer),
93  *                   NULL);
94  * g_signal_connect (server,
95  *                   "new-connection",
96  *                   G_CALLBACK (on_new_connection),
97  *                   NULL);
98  * g_object_unref (observer);
99  * g_dbus_server_start (server);
100  * </programlisting></example>
101  */
102
103 typedef struct _GDBusAuthObserverClass GDBusAuthObserverClass;
104
105 /**
106  * GDBusAuthObserverClass:
107  * @authorize_authenticated_peer: Signal class handler for the #GDBusAuthObserver::authorize-authenticated-peer signal.
108  *
109  * Class structure for #GDBusAuthObserverClass.
110  *
111  * Since: 2.26
112  */
113 struct _GDBusAuthObserverClass
114 {
115   /*< private >*/
116   GObjectClass parent_class;
117
118   /*< public >*/
119
120   /* Signals */
121   gboolean (*authorize_authenticated_peer) (GDBusAuthObserver  *observer,
122                                             GIOStream          *stream,
123                                             GCredentials       *credentials);
124 };
125
126 /**
127  * GDBusAuthObserver:
128  *
129  * The #GDBusAuthObserver structure contains only private data and
130  * should only be accessed using the provided API.
131  *
132  * Since: 2.26
133  */
134 struct _GDBusAuthObserver
135 {
136   GObject parent_instance;
137 };
138
139 enum
140 {
141   AUTHORIZE_AUTHENTICATED_PEER_SIGNAL,
142   LAST_SIGNAL,
143 };
144
145 static guint signals[LAST_SIGNAL] = { 0 };
146
147 G_DEFINE_TYPE (GDBusAuthObserver, g_dbus_auth_observer, G_TYPE_OBJECT);
148
149 /* ---------------------------------------------------------------------------------------------------- */
150
151 static void
152 g_dbus_auth_observer_finalize (GObject *object)
153 {
154   G_OBJECT_CLASS (g_dbus_auth_observer_parent_class)->finalize (object);
155 }
156
157 static gboolean
158 g_dbus_auth_observer_authorize_authenticated_peer_real (GDBusAuthObserver  *observer,
159                                                         GIOStream          *stream,
160                                                         GCredentials       *credentials)
161 {
162   return TRUE;
163 }
164
165 gboolean
166 _g_signal_accumulator_false_handled (GSignalInvocationHint *ihint,
167                                      GValue                *return_accu,
168                                      const GValue          *handler_return,
169                                      gpointer               dummy)
170 {
171   gboolean continue_emission;
172   gboolean signal_handled;
173
174   signal_handled = g_value_get_boolean (handler_return);
175   g_value_set_boolean (return_accu, signal_handled);
176   continue_emission = signal_handled;
177
178   return continue_emission;
179 }
180
181 static void
182 g_dbus_auth_observer_class_init (GDBusAuthObserverClass *klass)
183 {
184   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
185
186   gobject_class->finalize = g_dbus_auth_observer_finalize;
187
188   klass->authorize_authenticated_peer = g_dbus_auth_observer_authorize_authenticated_peer_real;
189
190   /**
191    * GDBusAuthObserver::authorize-authenticated-peer:
192    * @observer: The #GDBusAuthObserver emitting the signal.
193    * @stream: A #GIOStream for the #GDBusConnection.
194    * @credentials: Credentials received from the peer or %NULL.
195    *
196    * Emitted to check if a peer that is successfully authenticated
197    * is authorized.
198    *
199    * Returns: %TRUE if the peer is authorized, %FALSE if not.
200    *
201    * Since: 2.26
202    */
203   signals[AUTHORIZE_AUTHENTICATED_PEER_SIGNAL] =
204     g_signal_new ("authorize-authenticated-peer",
205                   G_TYPE_DBUS_AUTH_OBSERVER,
206                   G_SIGNAL_RUN_LAST,
207                   G_STRUCT_OFFSET (GDBusAuthObserverClass, authorize_authenticated_peer),
208                   _g_signal_accumulator_false_handled,
209                   NULL, /* accu_data */
210                   _gio_marshal_BOOLEAN__OBJECT_OBJECT,
211                   G_TYPE_BOOLEAN,
212                   2,
213                   G_TYPE_IO_STREAM,
214                   G_TYPE_CREDENTIALS);
215 }
216
217 static void
218 g_dbus_auth_observer_init (GDBusAuthObserver *observer)
219 {
220 }
221
222 /**
223  * g_dbus_auth_observer_new:
224  *
225  * Creates a new #GDBusAuthObserver object.
226  *
227  * Returns: A #GDBusAuthObserver. Free with g_object_unref().
228  *
229  * Since: 2.26
230  */
231 GDBusAuthObserver *
232 g_dbus_auth_observer_new (void)
233 {
234   return g_object_new (G_TYPE_DBUS_AUTH_OBSERVER, NULL);
235 }
236
237 /* ---------------------------------------------------------------------------------------------------- */
238
239 /**
240  * g_dbus_auth_observer_authorize_authenticated_peer:
241  * @observer: A #GDBusAuthObserver.
242  * @stream: A #GIOStream for the #GDBusConnection.
243  * @credentials: Credentials received from the peer or %NULL.
244  *
245  * Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @observer.
246  *
247  * Returns: %TRUE if the peer should be denied, %FALSE otherwise.
248  *
249  * Since: 2.26
250  */
251 gboolean
252 g_dbus_auth_observer_authorize_authenticated_peer (GDBusAuthObserver  *observer,
253                                                    GIOStream          *stream,
254                                                    GCredentials       *credentials)
255 {
256   gboolean denied;
257
258   denied = FALSE;
259   g_signal_emit (observer,
260                  signals[AUTHORIZE_AUTHENTICATED_PEER_SIGNAL],
261                  0,
262                  stream,
263                  credentials,
264                  &denied);
265   return denied;
266 }
267
268
269
270 #define __G_DBUS_AUTH_OBSERVER_C__
271 #include "gioaliasdef.c"