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 struct _GDBusAuthObserverPrivate
 104 {
 105   gint foo;
 106 };
 107
 108 enum
 109 {
 110   AUTHORIZE_AUTHENTICATED_PEER_SIGNAL,
 111   LAST_SIGNAL,
 112 };
 113
 114 static guint signals[LAST_SIGNAL] = { 0 };
 115
 116 G_DEFINE_TYPE (GDBusAuthObserver, g_dbus_auth_observer, G_TYPE_OBJECT);
 117
 118 /* ---------------------------------------------------------------------------------------------------- */
 119
 120 static void
 121 g_dbus_auth_observer_finalize (GObject *object)
 122 {
 123   G_OBJECT_CLASS (g_dbus_auth_observer_parent_class)->finalize (object);
 124 }
 125
 126 static gboolean
 127 g_dbus_auth_observer_authorize_authenticated_peer_real (GDBusAuthObserver  *observer,
 128                                                         GIOStream          *stream,
 129                                                         GCredentials       *credentials)
 130 {
 131   return TRUE;
 132 }
 133
 134 gboolean
 135 _g_signal_accumulator_false_handled (GSignalInvocationHint *ihint,
 136                                      GValue                *return_accu,
 137                                      const GValue          *handler_return,
 138                                      gpointer               dummy)
 139 {
 140   gboolean continue_emission;
 141   gboolean signal_handled;
 142
 143   signal_handled = g_value_get_boolean (handler_return);
 144   g_value_set_boolean (return_accu, signal_handled);
 145   continue_emission = signal_handled;
 146
 147   return continue_emission;
 148 }
 149
 150 static void
 151 g_dbus_auth_observer_class_init (GDBusAuthObserverClass *klass)
 152 {
 153   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 154
 155   gobject_class->finalize = g_dbus_auth_observer_finalize;
 156
 157   klass->authorize_authenticated_peer = g_dbus_auth_observer_authorize_authenticated_peer_real;
 158
 159   /**
 160    * GDBusAuthObserver::authorize-authenticated-peer:
 161    * @observer: The #GDBusAuthObserver emitting the signal.
 162    * @stream: A #GIOStream for the #GDBusConnection.
 163    * @credentials: Credentials received from the peer or %NULL.
 164    *
 165    * Emitted to check if a peer that is successfully authenticated
 166    * is authorized.
 167    *
 168    * Returns: %TRUE if the peer is authorized, %FALSE if not.
 169    *
 170    * Since: 2.26
 171    */
 172   signals[AUTHORIZE_AUTHENTICATED_PEER_SIGNAL] =
 173     g_signal_new ("authorize-authenticated-peer",
 174                   G_TYPE_DBUS_AUTH_OBSERVER,
 175                   G_SIGNAL_RUN_LAST,
 176                   G_STRUCT_OFFSET (GDBusAuthObserverClass, authorize_authenticated_peer),
 177                   _g_signal_accumulator_false_handled,
 178                   NULL, /* accu_data */
 179                   _gio_marshal_BOOLEAN__OBJECT_OBJECT,
 180                   G_TYPE_BOOLEAN,
 181                   2,
 182                   G_TYPE_IO_STREAM,
 183                   G_TYPE_CREDENTIALS);
 184
 185
 186   g_type_class_add_private (klass, sizeof (GDBusAuthObserverPrivate));
 187 }
 188
 189 static void
 190 g_dbus_auth_observer_init (GDBusAuthObserver *observer)
 191 {
 192   /* not used for now */
 193   observer->priv = G_TYPE_INSTANCE_GET_PRIVATE (observer,
 194                                                 G_TYPE_DBUS_AUTH_OBSERVER,
 195                                                 GDBusAuthObserverPrivate);;
 196 }
 197
 198 /**
 199  * g_dbus_auth_observer_new:
 200  *
 201  * Creates a new #GDBusAuthObserver object.
 202  *
 203  * Returns: A #GDBusAuthObserver. Free with g_object_unref().
 204  *
 205  * Since: 2.26
 206  */
 207 GDBusAuthObserver *
 208 g_dbus_auth_observer_new (void)
 209 {
 210   return g_object_new (G_TYPE_DBUS_AUTH_OBSERVER, NULL);
 211 }
 212
 213 /* ---------------------------------------------------------------------------------------------------- */
 214
 215 /**
 216  * g_dbus_auth_observer_authorize_authenticated_peer:
 217  * @observer: A #GDBusAuthObserver.
 218  * @stream: A #GIOStream for the #GDBusConnection.
 219  * @credentials: Credentials received from the peer or %NULL.
 220  *
 221  * Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @observer.
 222  *
 223  * Returns: %TRUE if the peer should be denied, %FALSE otherwise.
 224  *
 225  * Since: 2.26
 226  */
 227 gboolean
 228 g_dbus_auth_observer_authorize_authenticated_peer (GDBusAuthObserver  *observer,
 229                                                    GIOStream          *stream,
 230                                                    GCredentials       *credentials)
 231 {
 232   gboolean denied;
 233
 234   denied = FALSE;
 235   g_signal_emit (observer,
 236                  signals[AUTHORIZE_AUTHENTICATED_PEER_SIGNAL],
 237                  0,
 238                  stream,
 239                  credentials,
 240                  &denied);
 241   return denied;
 242 }
 243
 244
 245
 246 #define __G_DBUS_AUTH_OBSERVER_C__
 247 #include "gioaliasdef.c"