gio/gdbusauth.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 "gdbusauth.h"
  26
  27 #include "gdbusauthmechanismanon.h"
  28 #include "gdbusauthmechanismexternal.h"
  29 #include "gdbusauthmechanismsha1.h"
  30 #include "gdbusauthobserver.h"
  31
  32 #include "gdbuserror.h"
  33 #include "gdbusutils.h"
  34 #include "gioenumtypes.h"
  35 #include "gcredentials.h"
  36 #include "gdbusprivate.h"
  37 #include "giostream.h"
  38 #include "gdatainputstream.h"
  39 #include "gdataoutputstream.h"
  40
  41 #ifdef G_OS_UNIX
  42 #include <sys/types.h>
  43 #include <sys/socket.h>
  44 #include "gunixconnection.h"
  45 #include "gunixcredentialsmessage.h"
  46 #endif
  47
  48 #include "glibintl.h"
  49 #include "gioalias.h"
  50
  51 #define DEBUG_ENABLED 0
  52
  53 static void
  54 debug_print (const gchar *message, ...)
  55 {
  56 #if DEBUG_ENABLED
  57   if (G_UNLIKELY (_g_dbus_debug_authentication ()))
  58     {
  59       gchar *s;
  60       GString *str;
  61       va_list var_args;
  62       guint n;
  63
  64       va_start (var_args, message);
  65       s = g_strdup_vprintf (message, var_args);
  66       va_end (var_args);
  67
  68       str = g_string_new (NULL);
  69       for (n = 0; s[n] != '\0'; n++)
  70         {
  71           if (G_UNLIKELY (s[n] == '\r'))
  72             g_string_append (str, "\\r");
  73           else if (G_UNLIKELY (s[n] == '\n'))
  74             g_string_append (str, "\\n");
  75           else
  76             g_string_append_c (str, s[n]);
  77         }
  78       g_print ("GDBus-debug:Auth: %s\n", str->str);
  79       g_string_free (str, TRUE);
  80       g_free (s);
  81     }
  82 #endif
  83 }
  84
  85 typedef struct
  86 {
  87   const gchar *name;
  88   gint priority;
  89   GType gtype;
  90 } Mechanism;
  91
  92 static void mechanism_free (Mechanism *m);
  93
  94 struct _GDBusAuthPrivate
  95 {
  96   GIOStream *stream;
  97
  98   /* A list of available Mechanism, sorted according to priority  */
  99   GList *available_mechanisms;
 100 };
 101
 102 enum
 103 {
 104   PROP_0,
 105   PROP_STREAM
 106 };
 107
 108 G_DEFINE_TYPE (GDBusAuth, _g_dbus_auth, G_TYPE_OBJECT);
 109
 110 /* ---------------------------------------------------------------------------------------------------- */
 111
 112 static void
 113 _g_dbus_auth_finalize (GObject *object)
 114 {
 115   GDBusAuth *auth = G_DBUS_AUTH (object);
 116
 117   if (auth->priv->stream != NULL)
 118     g_object_unref (auth->priv->stream);
 119   g_list_foreach (auth->priv->available_mechanisms, (GFunc) mechanism_free, NULL);
 120   g_list_free (auth->priv->available_mechanisms);
 121
 122   if (G_OBJECT_CLASS (_g_dbus_auth_parent_class)->finalize != NULL)
 123     G_OBJECT_CLASS (_g_dbus_auth_parent_class)->finalize (object);
 124 }
 125
 126 static void
 127 _g_dbus_auth_get_property (GObject    *object,
 128                            guint       prop_id,
 129                            GValue     *value,
 130                            GParamSpec *pspec)
 131 {
 132   GDBusAuth *auth = G_DBUS_AUTH (object);
 133
 134   switch (prop_id)
 135     {
 136     case PROP_STREAM:
 137       g_value_set_object (value, auth->priv->stream);
 138       break;
 139
 140     default:
 141       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 142       break;
 143     }
 144 }
 145
 146 static void
 147 _g_dbus_auth_set_property (GObject      *object,
 148                            guint         prop_id,
 149                            const GValue *value,
 150                            GParamSpec   *pspec)
 151 {
 152   GDBusAuth *auth = G_DBUS_AUTH (object);
 153
 154   switch (prop_id)
 155     {
 156     case PROP_STREAM:
 157       auth->priv->stream = g_value_dup_object (value);
 158       break;
 159
 160     default:
 161       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 162       break;
 163     }
 164 }
 165
 166 static void
 167 _g_dbus_auth_class_init (GDBusAuthClass *klass)
 168 {
 169   GObjectClass *gobject_class;
 170
 171   g_type_class_add_private (klass, sizeof (GDBusAuthPrivate));
 172
 173   gobject_class = G_OBJECT_CLASS (klass);
 174   gobject_class->get_property = _g_dbus_auth_get_property;
 175   gobject_class->set_property = _g_dbus_auth_set_property;
 176   gobject_class->finalize     = _g_dbus_auth_finalize;
 177
 178   g_object_class_install_property (gobject_class,
 179                                    PROP_STREAM,
 180                                    g_param_spec_object ("stream",
 181                                                         P_("IO Stream"),
 182                                                         P_("The underlying GIOStream used for I/O"),
 183                                                         G_TYPE_IO_STREAM,
 184                                                         G_PARAM_READABLE |
 185                                                         G_PARAM_WRITABLE |
 186                                                         G_PARAM_CONSTRUCT_ONLY |
 187                                                         G_PARAM_STATIC_NAME |
 188                                                         G_PARAM_STATIC_BLURB |
 189                                                         G_PARAM_STATIC_NICK));
 190 }
 191
 192 static void
 193 mechanism_free (Mechanism *m)
 194 {
 195   g_free (m);
 196 }
 197
 198 static void
 199 add_mechanism (GDBusAuth *auth,
 200                GType      mechanism_type)
 201 {
 202   Mechanism *m;
 203
 204   m = g_new0 (Mechanism, 1);
 205   m->name = _g_dbus_auth_mechanism_get_name (mechanism_type);
 206   m->priority = _g_dbus_auth_mechanism_get_priority (mechanism_type);
 207   m->gtype = mechanism_type;
 208
 209   auth->priv->available_mechanisms = g_list_prepend (auth->priv->available_mechanisms, m);
 210 }
 211
 212 static gint
 213 mech_compare_func (Mechanism *a, Mechanism *b)
 214 {
 215   gint ret;
 216   /* ensure deterministic order */
 217   ret = b->priority - a->priority;
 218   if (ret == 0)
 219     ret = g_strcmp0 (b->name, a->name);
 220   return ret;
 221 }
 222
 223 static void
 224 _g_dbus_auth_init (GDBusAuth *auth)
 225 {
 226   auth->priv = G_TYPE_INSTANCE_GET_PRIVATE (auth, G_TYPE_DBUS_AUTH, GDBusAuthPrivate);
 227
 228   /* TODO: trawl extension points */
 229   add_mechanism (auth, G_TYPE_DBUS_AUTH_MECHANISM_ANON);
 230   add_mechanism (auth, G_TYPE_DBUS_AUTH_MECHANISM_SHA1);
 231   add_mechanism (auth, G_TYPE_DBUS_AUTH_MECHANISM_EXTERNAL);
 232
 233   auth->priv->available_mechanisms = g_list_sort (auth->priv->available_mechanisms,
 234                                                   (GCompareFunc) mech_compare_func);
 235 }
 236
 237 static GType
 238 find_mech_by_name (GDBusAuth *auth,
 239                    const gchar *name)
 240 {
 241   GType ret;
 242   GList *l;
 243
 244   ret = (GType) 0;
 245
 246   for (l = auth->priv->available_mechanisms; l != NULL; l = l->next)
 247     {
 248       Mechanism *m = l->data;
 249       if (g_strcmp0 (name, m->name) == 0)
 250         {
 251           ret = m->gtype;
 252           goto out;
 253         }
 254     }
 255
 256  out:
 257   return ret;
 258 }
 259
 260 GDBusAuth  *
 261 _g_dbus_auth_new (GIOStream *stream)
 262 {
 263   return g_object_new (G_TYPE_DBUS_AUTH,
 264                        "stream", stream,
 265                        NULL);
 266 }
 267
 268 /* ---------------------------------------------------------------------------------------------------- */
 269 /* like g_data_input_stream_read_line() but sets error if there's no content to read */
 270 static gchar *
 271 _my_g_data_input_stream_read_line (GDataInputStream  *dis,
 272                                    gsize             *out_line_length,
 273                                    GCancellable      *cancellable,
 274                                    GError           **error)
 275 {
 276   gchar *ret;
 277
 278   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 279
 280   ret = g_data_input_stream_read_line (dis,
 281                                        out_line_length,
 282                                        cancellable,
 283                                        error);
 284   if (ret == NULL && error != NULL && *error == NULL)
 285     {
 286       g_set_error_literal (error,
 287                            G_IO_ERROR,
 288                            G_IO_ERROR_FAILED,
 289                            _("Unexpected lack of content trying to read a line"));
 290     }
 291
 292   return ret;
 293 }
 294
 295 /* This function is to avoid situations like this
 296  *
 297  * BEGIN\r\nl\0\0\1...
 298  *
 299  * e.g. where we read into the first D-Bus message while waiting for
 300  * the final line from the client (TODO: file bug against gio for
 301  * this)
 302  */
 303 static gchar *
 304 _my_g_input_stream_read_line_safe (GInputStream  *i,
 305                                    gsize         *out_line_length,
 306                                    GCancellable  *cancellable,
 307                                    GError       **error)
 308 {
 309   GString *str;
 310   gchar c;
 311   gssize num_read;
 312   gboolean last_was_cr;
 313
 314   str = g_string_new (NULL);
 315
 316   last_was_cr = FALSE;
 317   while (TRUE)
 318     {
 319       num_read = g_input_stream_read (i,
 320                                       &c,
 321                                       1,
 322                                       cancellable,
 323                                       error);
 324       if (num_read == -1)
 325         goto fail;
 326       if (num_read == 0)
 327         {
 328           if (error != NULL && *error == NULL)
 329             {
 330               g_set_error_literal (error,
 331                                    G_IO_ERROR,
 332                                    G_IO_ERROR_FAILED,
 333                                    _("Unexpected lack of content trying to (safely) read a line"));
 334             }
 335           goto fail;
 336         }
 337
 338       g_string_append_c (str, (gint) c);
 339       if (last_was_cr)
 340         {
 341           if (c == 0x0a)
 342             {
 343               g_assert (str->len >= 2);
 344               g_string_set_size (str, str->len - 2);
 345               goto out;
 346             }
 347         }
 348       last_was_cr = (c == 0x0d);
 349     }
 350
 351  out:
 352   if (out_line_length != NULL)
 353     *out_line_length = str->len;
 354   return g_string_free (str, FALSE);
 355
 356  fail:
 357   g_assert (error == NULL || *error != NULL);
 358   g_string_free (str, TRUE);
 359   return NULL;
 360 }
 361
 362 /* ---------------------------------------------------------------------------------------------------- */
 363
 364 static void
 365 append_nibble (GString *s, gint val)
 366 {
 367   g_string_append_c (s, val >= 10 ? ('a' + val - 10) : ('0' + val));
 368 }
 369
 370 static gchar *
 371 hexdecode (const gchar  *str,
 372            gsize        *out_len,
 373            GError      **error)
 374 {
 375   gchar *ret;
 376   GString *s;
 377   guint n;
 378
 379   ret = NULL;
 380   s = g_string_new (NULL);
 381
 382   for (n = 0; str[n] != '\0'; n += 2)
 383     {
 384       gint upper_nibble;
 385       gint lower_nibble;
 386       guint value;
 387
 388       upper_nibble = g_ascii_xdigit_value (str[n]);
 389       lower_nibble = g_ascii_xdigit_value (str[n + 1]);
 390       if (upper_nibble == -1 || lower_nibble == -1)
 391         {
 392           g_set_error (error,
 393                        G_IO_ERROR,
 394                        G_IO_ERROR_FAILED,
 395                        "Error hexdecoding string `%s' around position %d",
 396                        str, n);
 397           goto out;
 398         }
 399       value = (upper_nibble<<4) | lower_nibble;
 400       g_string_append_c (s, value);
 401     }
 402
 403   ret = g_string_free (s, FALSE);
 404   s = NULL;
 405
 406  out:
 407   if (s != NULL)
 408     g_string_free (s, TRUE);
 409   return ret;
 410 }
 411
 412 /* TODO: take len */
 413 static gchar *
 414 hexencode (const gchar *str)
 415 {
 416   guint n;
 417   GString *s;
 418
 419   s = g_string_new (NULL);
 420   for (n = 0; str[n] != '\0'; n++)
 421     {
 422       gint val;
 423       gint upper_nibble;
 424       gint lower_nibble;
 425
 426       val = ((const guchar *) str)[n];
 427       upper_nibble = val >> 4;
 428       lower_nibble = val & 0x0f;
 429
 430       append_nibble (s, upper_nibble);
 431       append_nibble (s, lower_nibble);
 432     }
 433
 434   return g_string_free (s, FALSE);
 435 }
 436
 437 /* ---------------------------------------------------------------------------------------------------- */
 438
 439 static GDBusAuthMechanism *
 440 client_choose_mech_and_send_initial_response (GDBusAuth           *auth,
 441                                               GCredentials        *credentials_that_were_sent,
 442                                               const gchar* const  *supported_auth_mechs,
 443                                               GPtrArray           *attempted_auth_mechs,
 444                                               GDataOutputStream   *dos,
 445                                               GCancellable        *cancellable,
 446                                               GError             **error)
 447 {
 448   GDBusAuthMechanism *mech;
 449   GType auth_mech_to_use_gtype;
 450   guint n;
 451   guint m;
 452   gchar *initial_response;
 453   gsize initial_response_len;
 454   gchar *encoded;
 455   gchar *s;
 456
 457  again:
 458   mech = NULL;
 459
 460   debug_print ("CLIENT: Trying to choose mechanism");
 461
 462   /* find an authentication mechanism to try, if any */
 463   auth_mech_to_use_gtype = (GType) 0;
 464   for (n = 0; supported_auth_mechs[n] != NULL; n++)
 465     {
 466       gboolean attempted_already;
 467       attempted_already = FALSE;
 468       for (m = 0; m < attempted_auth_mechs->len; m++)
 469         {
 470           if (g_strcmp0 (supported_auth_mechs[n], attempted_auth_mechs->pdata[m]) == 0)
 471             {
 472               attempted_already = TRUE;
 473               break;
 474             }
 475         }
 476       if (!attempted_already)
 477         {
 478           auth_mech_to_use_gtype = find_mech_by_name (auth, supported_auth_mechs[n]);
 479           if (auth_mech_to_use_gtype != (GType) 0)
 480             break;
 481         }
 482     }
 483
 484   if (auth_mech_to_use_gtype == (GType) 0)
 485     {
 486       guint n;
 487       gchar *available;
 488       GString *tried_str;
 489
 490       debug_print ("CLIENT: Exhausted all available mechanisms");
 491
 492       available = g_strjoinv (", ", (gchar **) supported_auth_mechs);
 493
 494       tried_str = g_string_new (NULL);
 495       for (n = 0; n < attempted_auth_mechs->len; n++)
 496         {
 497           if (n > 0)
 498             g_string_append (tried_str, ", ");
 499           g_string_append (tried_str, attempted_auth_mechs->pdata[n]);
 500         }
 501       g_set_error (error,
 502                    G_IO_ERROR,
 503                    G_IO_ERROR_FAILED,
 504                    _("Exhausted all available authentication mechanisms (tried: %s) (available: %s)"),
 505                    tried_str->str,
 506                    available);
 507       g_string_free (tried_str, TRUE);
 508       g_free (available);
 509       goto out;
 510     }
 511
 512   /* OK, decided on a mechanism - let's do this thing */
 513   mech = g_object_new (auth_mech_to_use_gtype,
 514                        "stream", auth->priv->stream,
 515                        "credentials", credentials_that_were_sent,
 516                        NULL);
 517   debug_print ("CLIENT: Trying mechanism `%s'", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
 518   g_ptr_array_add (attempted_auth_mechs, (gpointer) _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
 519
 520   /* the auth mechanism may not be supported
 521    * (for example, EXTERNAL only works if credentials were exchanged)
 522    */
 523   if (!_g_dbus_auth_mechanism_is_supported (mech))
 524     {
 525       debug_print ("CLIENT: Mechanism `%s' says it is not supported", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
 526       g_object_unref (mech);
 527       mech = NULL;
 528       goto again;
 529     }
 530
 531   initial_response_len = -1;
 532   initial_response = _g_dbus_auth_mechanism_client_initiate (mech,
 533                                                              &initial_response_len);
 534 #if 0
 535   g_printerr ("using auth mechanism with name `%s' of type `%s' with initial response `%s'\n",
 536               _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype),
 537               g_type_name (G_TYPE_FROM_INSTANCE (mech)),
 538               initial_response);
 539 #endif
 540   if (initial_response != NULL)
 541     {
 542       //g_printerr ("initial_response = `%s'\n", initial_response);
 543       encoded = hexencode (initial_response);
 544       s = g_strdup_printf ("AUTH %s %s\r\n",
 545                            _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype),
 546                            encoded);
 547       g_free (initial_response);
 548       g_free (encoded);
 549     }
 550   else
 551     {
 552       s = g_strdup_printf ("AUTH %s\r\n", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
 553     }
 554   debug_print ("CLIENT: writing `%s'", s);
 555   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 556     {
 557       g_object_unref (mech);
 558       mech = NULL;
 559       g_free (s);
 560       goto out;
 561     }
 562   g_free (s);
 563
 564  out:
 565   return mech;
 566 }
 567
 568
 569 /* ---------------------------------------------------------------------------------------------------- */
 570
 571 typedef enum
 572 {
 573   CLIENT_STATE_WAITING_FOR_DATA,
 574   CLIENT_STATE_WAITING_FOR_OK,
 575   CLIENT_STATE_WAITING_FOR_REJECT,
 576   CLIENT_STATE_WAITING_FOR_AGREE_UNIX_FD
 577 } ClientState;
 578
 579 gchar *
 580 _g_dbus_auth_run_client (GDBusAuth     *auth,
 581                          GDBusCapabilityFlags offered_capabilities,
 582                          GDBusCapabilityFlags *out_negotiated_capabilities,
 583                          GCancellable  *cancellable,
 584                          GError       **error)
 585 {
 586   gchar *s;
 587   GDataInputStream *dis;
 588   GDataOutputStream *dos;
 589   GCredentials *credentials;
 590   gchar *ret_guid;
 591   gchar *line;
 592   gsize line_length;
 593   gchar **supported_auth_mechs;
 594   GPtrArray *attempted_auth_mechs;
 595   GDBusAuthMechanism *mech;
 596   ClientState state;
 597   GDBusCapabilityFlags negotiated_capabilities;
 598
 599   debug_print ("CLIENT: initiating");
 600
 601   ret_guid = NULL;
 602   supported_auth_mechs = NULL;
 603   attempted_auth_mechs = g_ptr_array_new ();
 604   mech = NULL;
 605   negotiated_capabilities = 0;
 606   credentials = NULL;
 607
 608   dis = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (auth->priv->stream)));
 609   dos = G_DATA_OUTPUT_STREAM (g_data_output_stream_new (g_io_stream_get_output_stream (auth->priv->stream)));
 610   g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (dis), FALSE);
 611   g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (dos), FALSE);
 612
 613   g_data_input_stream_set_newline_type (dis, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
 614
 615 #ifdef G_OS_UNIX
 616   if (G_IS_UNIX_CONNECTION (auth->priv->stream) && g_unix_credentials_message_is_supported ())
 617     {
 618       credentials = g_credentials_new ();
 619       if (!g_unix_connection_send_credentials (G_UNIX_CONNECTION (auth->priv->stream),
 620                                                cancellable,
 621                                                error))
 622         goto out;
 623     }
 624   else
 625     {
 626       if (!g_data_output_stream_put_byte (dos, '\0', cancellable, error))
 627         goto out;
 628     }
 629 #else
 630   if (!g_data_output_stream_put_byte (dos, '\0', cancellable, error))
 631     goto out;
 632 #endif
 633
 634   if (credentials != NULL)
 635     {
 636       if (G_UNLIKELY (_g_dbus_debug_authentication ()))
 637         {
 638           s = g_credentials_to_string (credentials);
 639           debug_print ("CLIENT: sent credentials `%s'", s);
 640           g_free (s);
 641         }
 642     }
 643   else
 644     {
 645       debug_print ("CLIENT: didn't send any credentials");
 646     }
 647
 648   /* TODO: to reduce roundtrips, try to pick an auth mechanism to start with */
 649
 650   /* Get list of supported authentication mechanisms */
 651   s = "AUTH\r\n";
 652   debug_print ("CLIENT: writing `%s'", s);
 653   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 654     goto out;
 655   state = CLIENT_STATE_WAITING_FOR_REJECT;
 656
 657   while (TRUE)
 658     {
 659       switch (state)
 660         {
 661         case CLIENT_STATE_WAITING_FOR_REJECT:
 662           debug_print ("CLIENT: WaitingForReject");
 663           line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
 664           if (line == NULL)
 665             goto out;
 666           debug_print ("CLIENT: WaitingForReject, read '%s'", line);
 667         foobar:
 668           if (!g_str_has_prefix (line, "REJECTED "))
 669             {
 670               g_set_error (error,
 671                            G_IO_ERROR,
 672                            G_IO_ERROR_FAILED,
 673                            "In WaitingForReject: Expected `REJECTED am1 am2 ... amN', got `%s'",
 674                            line);
 675               g_free (line);
 676               goto out;
 677             }
 678           if (supported_auth_mechs == NULL)
 679             {
 680               supported_auth_mechs = g_strsplit (line + sizeof ("REJECTED ") - 1, " ", 0);
 681 #if 0
 682               for (n = 0; supported_auth_mechs != NULL && supported_auth_mechs[n] != NULL; n++)
 683                 g_printerr ("supported_auth_mechs[%d] = `%s'\n", n, supported_auth_mechs[n]);
 684 #endif
 685             }
 686           g_free (line);
 687           mech = client_choose_mech_and_send_initial_response (auth,
 688                                                                credentials,
 689                                                                (const gchar* const *) supported_auth_mechs,
 690                                                                attempted_auth_mechs,
 691                                                                dos,
 692                                                                cancellable,
 693                                                                error);
 694           if (mech == NULL)
 695             goto out;
 696           if (_g_dbus_auth_mechanism_client_get_state (mech) == G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA)
 697             state = CLIENT_STATE_WAITING_FOR_DATA;
 698           else
 699             state = CLIENT_STATE_WAITING_FOR_OK;
 700           break;
 701
 702         case CLIENT_STATE_WAITING_FOR_OK:
 703           debug_print ("CLIENT: WaitingForOK");
 704           line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
 705           if (line == NULL)
 706             goto out;
 707           debug_print ("CLIENT: WaitingForOK, read `%s'", line);
 708           if (g_str_has_prefix (line, "OK "))
 709             {
 710               if (!g_dbus_is_guid (line + 3))
 711                 {
 712                   g_set_error (error,
 713                                G_IO_ERROR,
 714                                G_IO_ERROR_FAILED,
 715                                "Invalid OK response `%s'",
 716                                line);
 717                   g_free (line);
 718                   goto out;
 719                 }
 720               ret_guid = g_strdup (line + 3);
 721               g_free (line);
 722
 723               if (offered_capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING)
 724                 {
 725                   s = "NEGOTIATE_UNIX_FD\r\n";
 726                   debug_print ("CLIENT: writing `%s'", s);
 727                   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 728                     goto out;
 729                   state = CLIENT_STATE_WAITING_FOR_AGREE_UNIX_FD;
 730                 }
 731               else
 732                 {
 733                   s = "BEGIN\r\n";
 734                   debug_print ("CLIENT: writing `%s'", s);
 735                   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 736                     goto out;
 737                   /* and we're done! */
 738                   goto out;
 739                 }
 740             }
 741           else if (g_str_has_prefix (line, "REJECTED "))
 742             {
 743               goto foobar;
 744             }
 745           else
 746             {
 747               /* TODO: handle other valid responses */
 748               g_set_error (error,
 749                            G_IO_ERROR,
 750                            G_IO_ERROR_FAILED,
 751                            "In WaitingForOk: unexpected response `%s'",
 752                            line);
 753               g_free (line);
 754               goto out;
 755             }
 756           break;
 757
 758         case CLIENT_STATE_WAITING_FOR_AGREE_UNIX_FD:
 759           debug_print ("CLIENT: WaitingForAgreeUnixFD");
 760           line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
 761           if (line == NULL)
 762             goto out;
 763           debug_print ("CLIENT: WaitingForAgreeUnixFD, read=`%s'", line);
 764           if (g_strcmp0 (line, "AGREE_UNIX_FD") == 0)
 765             {
 766               negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
 767               s = "BEGIN\r\n";
 768               debug_print ("CLIENT: writing `%s'", s);
 769               if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 770                 goto out;
 771               /* and we're done! */
 772               goto out;
 773             }
 774           else if (g_str_has_prefix (line, "ERROR") && (line[5] == 0 || g_ascii_isspace (line[5])))
 775             {
 776               //g_strstrip (line + 5); g_debug ("bah, no unix_fd: `%s'", line + 5);
 777               g_free (line);
 778               s = "BEGIN\r\n";
 779               debug_print ("CLIENT: writing `%s'", s);
 780               if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 781                 goto out;
 782               /* and we're done! */
 783               goto out;
 784             }
 785           else
 786             {
 787               /* TODO: handle other valid responses */
 788               g_set_error (error,
 789                            G_IO_ERROR,
 790                            G_IO_ERROR_FAILED,
 791                            "In WaitingForAgreeUnixFd: unexpected response `%s'",
 792                            line);
 793               g_free (line);
 794               goto out;
 795             }
 796           break;
 797
 798         case CLIENT_STATE_WAITING_FOR_DATA:
 799           debug_print ("CLIENT: WaitingForData");
 800           line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
 801           if (line == NULL)
 802             goto out;
 803           debug_print ("CLIENT: WaitingForData, read=`%s'", line);
 804           if (g_str_has_prefix (line, "DATA "))
 805             {
 806               gchar *encoded;
 807               gchar *decoded_data;
 808               gsize decoded_data_len;
 809
 810               encoded = g_strdup (line + 5);
 811               g_free (line);
 812               g_strstrip (encoded);
 813               decoded_data = hexdecode (encoded, &decoded_data_len, error);
 814               g_free (encoded);
 815               if (decoded_data == NULL)
 816                 {
 817                   g_prefix_error (error, "DATA response is malformed: ");
 818                   /* invalid encoding, disconnect! */
 819                   goto out;
 820                 }
 821               _g_dbus_auth_mechanism_client_data_receive (mech, decoded_data, decoded_data_len);
 822               g_free (decoded_data);
 823
 824               if (_g_dbus_auth_mechanism_client_get_state (mech) == G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND)
 825                 {
 826                   gchar *data;
 827                   gsize data_len;
 828                   gchar *encoded_data;
 829                   data = _g_dbus_auth_mechanism_client_data_send (mech, &data_len);
 830                   encoded_data = hexencode (data);
 831                   s = g_strdup_printf ("DATA %s\r\n", encoded_data);
 832                   g_free (encoded_data);
 833                   g_free (data);
 834                   debug_print ("CLIENT: writing `%s'", s);
 835                   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
 836                     {
 837                       g_free (s);
 838                       goto out;
 839                     }
 840                   g_free (s);
 841                 }
 842               state = CLIENT_STATE_WAITING_FOR_OK;
 843             }
 844           else
 845             {
 846               g_set_error (error,
 847                            G_IO_ERROR,
 848                            G_IO_ERROR_FAILED,
 849                            "In WaitingForData: unexpected response `%s'",
 850                            line);
 851               g_free (line);
 852               goto out;
 853             }
 854           break;
 855
 856         default:
 857           g_assert_not_reached ();
 858           break;
 859         }
 860
 861     }; /* main authentication client loop */
 862
 863  out:
 864   if (mech != NULL)
 865     g_object_unref (mech);
 866   g_ptr_array_unref (attempted_auth_mechs);
 867   g_strfreev (supported_auth_mechs);
 868   g_object_unref (dis);
 869   g_object_unref (dos);
 870
 871   /* ensure return value is NULL if error is set */
 872   if (error != NULL && *error != NULL)
 873     {
 874       g_free (ret_guid);
 875       ret_guid = NULL;
 876     }
 877
 878   if (ret_guid != NULL)
 879     {
 880       if (out_negotiated_capabilities != NULL)
 881         *out_negotiated_capabilities = negotiated_capabilities;
 882     }
 883
 884   if (credentials != NULL)
 885     g_object_unref (credentials);
 886
 887   debug_print ("CLIENT: Done, authenticated=%d", ret_guid != NULL);
 888
 889   return ret_guid;
 890 }
 891
 892 /* ---------------------------------------------------------------------------------------------------- */
 893
 894 static gchar *
 895 get_auth_mechanisms (GDBusAuth     *auth,
 896                      gboolean       allow_anonymous,
 897                      const gchar   *prefix,
 898                      const gchar   *suffix,
 899                      const gchar   *separator)
 900 {
 901   GList *l;
 902   GString *str;
 903   gboolean need_sep;
 904
 905   str = g_string_new (prefix);
 906   need_sep = FALSE;
 907   for (l = auth->priv->available_mechanisms; l != NULL; l = l->next)
 908     {
 909       Mechanism *m = l->data;
 910
 911       if (!allow_anonymous && g_strcmp0 (m->name, "ANONYMOUS") == 0)
 912         continue;
 913
 914       if (need_sep)
 915         g_string_append (str, separator);
 916       g_string_append (str, m->name);
 917       need_sep = TRUE;
 918     }
 919
 920   g_string_append (str, suffix);
 921   return g_string_free (str, FALSE);
 922 }
 923
 924
 925 typedef enum
 926 {
 927   SERVER_STATE_WAITING_FOR_AUTH,
 928   SERVER_STATE_WAITING_FOR_DATA,
 929   SERVER_STATE_WAITING_FOR_BEGIN
 930 } ServerState;
 931
 932 gboolean
 933 _g_dbus_auth_run_server (GDBusAuth              *auth,
 934                          GDBusAuthObserver      *observer,
 935                          const gchar            *guid,
 936                          gboolean                allow_anonymous,
 937                          GDBusCapabilityFlags    offered_capabilities,
 938                          GDBusCapabilityFlags   *out_negotiated_capabilities,
 939                          GCredentials          **out_received_credentials,
 940                          GCancellable           *cancellable,
 941                          GError                **error)
 942 {
 943   gboolean ret;
 944   ServerState state;
 945   GDataInputStream *dis;
 946   GDataOutputStream *dos;
 947   GError *local_error;
 948   guchar byte;
 949   gchar *line;
 950   gsize line_length;
 951   GDBusAuthMechanism *mech;
 952   gchar *s;
 953   GDBusCapabilityFlags negotiated_capabilities;
 954   GCredentials *credentials;
 955
 956   debug_print ("SERVER: initiating");
 957
 958   ret = FALSE;
 959   dis = NULL;
 960   dos = NULL;
 961   mech = NULL;
 962   negotiated_capabilities = 0;
 963   credentials = NULL;
 964
 965   if (!g_dbus_is_guid (guid))
 966     {
 967       g_set_error (error,
 968                    G_IO_ERROR,
 969                    G_IO_ERROR_FAILED,
 970                    "The given guid `%s' is not valid",
 971                    guid);
 972       goto out;
 973     }
 974
 975   dis = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (auth->priv->stream)));
 976   dos = G_DATA_OUTPUT_STREAM (g_data_output_stream_new (g_io_stream_get_output_stream (auth->priv->stream)));
 977   g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (dis), FALSE);
 978   g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (dos), FALSE);
 979
 980   g_data_input_stream_set_newline_type (dis, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
 981
 982   /* first read the NUL-byte (TODO: read credentials if using a unix domain socket) */
 983 #ifdef G_OS_UNIX
 984   if (G_IS_UNIX_CONNECTION (auth->priv->stream) && g_unix_credentials_message_is_supported ())
 985     {
 986       local_error = NULL;
 987       credentials = g_unix_connection_receive_credentials (G_UNIX_CONNECTION (auth->priv->stream),
 988                                                            cancellable,
 989                                                            &local_error);
 990       if (credentials == NULL)
 991         {
 992           g_propagate_error (error, local_error);
 993           goto out;
 994         }
 995     }
 996   else
 997     {
 998       local_error = NULL;
 999       byte = g_data_input_stream_read_byte (dis, cancellable, &local_error);
1000       if (local_error != NULL)
1001         {
1002           g_propagate_error (error, local_error);
1003           goto out;
1004         }
1005     }
1006 #else
1007   local_error = NULL;
1008   byte = g_data_input_stream_read_byte (dis, cancellable, &local_error);
1009   if (local_error != NULL)
1010     {
1011       g_propagate_error (error, local_error);
1012       goto out;
1013     }
1014 #endif
1015   if (credentials != NULL)
1016     {
1017       if (G_UNLIKELY (_g_dbus_debug_authentication ()))
1018         {
1019           s = g_credentials_to_string (credentials);
1020           debug_print ("SERVER: received credentials `%s'", s);
1021           g_free (s);
1022         }
1023     }
1024   else
1025     {
1026       debug_print ("SERVER: didn't receive any credentials");
1027     }
1028
1029   state = SERVER_STATE_WAITING_FOR_AUTH;
1030   while (TRUE)
1031     {
1032       switch (state)
1033         {
1034         case SERVER_STATE_WAITING_FOR_AUTH:
1035           debug_print ("SERVER: WaitingForAuth");
1036           line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
1037           debug_print ("SERVER: WaitingForAuth, read `%s'", line);
1038           if (line == NULL)
1039             goto out;
1040           if (g_strcmp0 (line, "AUTH") == 0)
1041             {
1042               s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
1043               debug_print ("SERVER: writing `%s'", s);
1044               if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1045                 {
1046                   g_free (s);
1047                   goto out;
1048                 }
1049               g_free (s);
1050               g_free (line);
1051             }
1052           else if (g_str_has_prefix (line, "AUTH "))
1053             {
1054               gchar **tokens;
1055               const gchar *encoded;
1056               const gchar *mech_name;
1057               GType auth_mech_to_use_gtype;
1058
1059               tokens = g_strsplit (line, " ", 0);
1060               g_free (line);
1061
1062               switch (g_strv_length (tokens))
1063                 {
1064                 case 2:
1065                   /* no initial response */
1066                   mech_name = tokens[1];
1067                   encoded = NULL;
1068                   break;
1069
1070                 case 3:
1071                   /* initial response */
1072                   mech_name = tokens[1];
1073                   encoded = tokens[2];
1074                   break;
1075
1076                 default:
1077                   g_set_error (error,
1078                                G_IO_ERROR,
1079                                G_IO_ERROR_FAILED,
1080                                "Unexpected line `%s' while in WaitingForAuth state",
1081                                line);
1082                   g_strfreev (tokens);
1083                   goto out;
1084                 }
1085
1086               /* TODO: record that the client has attempted to use this mechanism */
1087               //g_debug ("client is trying `%s'", mech_name);
1088
1089               auth_mech_to_use_gtype = find_mech_by_name (auth, mech_name);
1090               if ((auth_mech_to_use_gtype == (GType) 0) ||
1091                   (!allow_anonymous && g_strcmp0 (mech_name, "ANONYMOUS") == 0))
1092                 {
1093                   /* We don't support this auth mechanism */
1094                   g_strfreev (tokens);
1095                   s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
1096                   debug_print ("SERVER: writing `%s'", s);
1097                   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1098                     {
1099                       g_free (s);
1100                       goto out;
1101                     }
1102                   g_free (s);
1103
1104                   /* stay in WAITING FOR AUTH */
1105                   state = SERVER_STATE_WAITING_FOR_AUTH;
1106                 }
1107               else
1108                 {
1109                   gchar *initial_response;
1110                   gsize initial_response_len;
1111
1112                   mech = g_object_new (auth_mech_to_use_gtype,
1113                                        "stream", auth->priv->stream,
1114                                        "credentials", credentials,
1115                                        NULL);
1116
1117                   initial_response = NULL;
1118                   initial_response_len = 0;
1119                   if (encoded != NULL)
1120                     {
1121                       initial_response = hexdecode (encoded, &initial_response_len, error);
1122                       if (initial_response == NULL)
1123                         {
1124                           g_prefix_error (error, "Initial response is malformed: ");
1125                           /* invalid encoding, disconnect! */
1126                           g_strfreev (tokens);
1127                           goto out;
1128                         }
1129                     }
1130
1131                   _g_dbus_auth_mechanism_server_initiate (mech,
1132                                                           initial_response,
1133                                                           initial_response_len);
1134                   g_free (initial_response);
1135                   g_strfreev (tokens);
1136
1137                 change_state:
1138                   switch (_g_dbus_auth_mechanism_server_get_state (mech))
1139                     {
1140                     case G_DBUS_AUTH_MECHANISM_STATE_ACCEPTED:
1141                       if (observer != NULL &&
1142                           !g_dbus_auth_observer_authorize_authenticated_peer (observer,
1143                                                                               auth->priv->stream,
1144                                                                               credentials))
1145                         {
1146                           /* disconnect */
1147                           g_set_error_literal (error,
1148                                                G_IO_ERROR,
1149                                                G_IO_ERROR_FAILED,
1150                                                _("Cancelled via GDBusAuthObserver::authorize-authenticated-peer"));
1151                           goto out;
1152                         }
1153                       else
1154                         {
1155                           s = g_strdup_printf ("OK %s\r\n", guid);
1156                           debug_print ("SERVER: writing `%s'", s);
1157                           if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1158                             {
1159                               g_free (s);
1160                               goto out;
1161                             }
1162                           g_free (s);
1163                           state = SERVER_STATE_WAITING_FOR_BEGIN;
1164                         }
1165                       break;
1166
1167                     case G_DBUS_AUTH_MECHANISM_STATE_REJECTED:
1168                       s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
1169                       debug_print ("SERVER: writing `%s'", s);
1170                       if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1171                         {
1172                           g_free (s);
1173                           goto out;
1174                         }
1175                       g_free (s);
1176                       state = SERVER_STATE_WAITING_FOR_AUTH;
1177                       break;
1178
1179                     case G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA:
1180                       state = SERVER_STATE_WAITING_FOR_DATA;
1181                       break;
1182
1183                     case G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND:
1184                       {
1185                         gchar *data;
1186                         gsize data_len;
1187                         gchar *encoded_data;
1188                         data = _g_dbus_auth_mechanism_server_data_send (mech, &data_len);
1189                         encoded_data = hexencode (data);
1190                         s = g_strdup_printf ("DATA %s\r\n", encoded_data);
1191                         g_free (encoded_data);
1192                         g_free (data);
1193                         debug_print ("SERVER: writing `%s'", s);
1194                         if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1195                           {
1196                             g_free (s);
1197                             goto out;
1198                           }
1199                         g_free (s);
1200                       }
1201                       goto change_state;
1202                       break;
1203
1204                     default:
1205                       /* TODO */
1206                       g_assert_not_reached ();
1207                       break;
1208                     }
1209                 }
1210             }
1211           else
1212             {
1213               g_set_error (error,
1214                            G_IO_ERROR,
1215                            G_IO_ERROR_FAILED,
1216                            "Unexpected line `%s' while in WaitingForAuth state",
1217                            line);
1218               g_free (line);
1219               goto out;
1220             }
1221           break;
1222
1223         case SERVER_STATE_WAITING_FOR_DATA:
1224           debug_print ("SERVER: WaitingForData");
1225           line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
1226           debug_print ("SERVER: WaitingForData, read `%s'", line);
1227           if (line == NULL)
1228             goto out;
1229           if (g_str_has_prefix (line, "DATA "))
1230             {
1231               gchar *encoded;
1232               gchar *decoded_data;
1233               gsize decoded_data_len;
1234
1235               encoded = g_strdup (line + 5);
1236               g_free (line);
1237               g_strstrip (encoded);
1238               decoded_data = hexdecode (encoded, &decoded_data_len, error);
1239               g_free (encoded);
1240               if (decoded_data == NULL)
1241                 {
1242                   g_prefix_error (error, "DATA response is malformed: ");
1243                   /* invalid encoding, disconnect! */
1244                   goto out;
1245                 }
1246               _g_dbus_auth_mechanism_server_data_receive (mech, decoded_data, decoded_data_len);
1247               g_free (decoded_data);
1248               /* oh man, this goto-crap is so ugly.. really need to rewrite the state machine */
1249               goto change_state;
1250             }
1251           else
1252             {
1253               g_set_error (error,
1254                            G_IO_ERROR,
1255                            G_IO_ERROR_FAILED,
1256                            "Unexpected line `%s' while in WaitingForData state",
1257                            line);
1258               g_free (line);
1259             }
1260           goto out;
1261
1262         case SERVER_STATE_WAITING_FOR_BEGIN:
1263           debug_print ("SERVER: WaitingForBegin");
1264           /* Use extremely slow (but reliable) line reader - this basically
1265            * does a recvfrom() system call per character
1266            *
1267            * (the problem with using GDataInputStream's read_line is that because of
1268            * buffering it might start reading into the first D-Bus message that
1269            * appears after "BEGIN\r\n"....)
1270            */
1271           line = _my_g_input_stream_read_line_safe (g_io_stream_get_input_stream (auth->priv->stream),
1272                                                     &line_length,
1273                                                     cancellable,
1274                                                     error);
1275           debug_print ("SERVER: WaitingForBegin, read `%s'", line);
1276           if (line == NULL)
1277             goto out;
1278           if (g_strcmp0 (line, "BEGIN") == 0)
1279             {
1280               /* YAY, done! */
1281               ret = TRUE;
1282               g_free (line);
1283               goto out;
1284             }
1285           else if (g_strcmp0 (line, "NEGOTIATE_UNIX_FD") == 0)
1286             {
1287               g_free (line);
1288               if (offered_capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING)
1289                 {
1290                   negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
1291                   s = "AGREE_UNIX_FD\r\n";
1292                   debug_print ("SERVER: writing `%s'", s);
1293                   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1294                     goto out;
1295                 }
1296               else
1297                 {
1298                   s = "ERROR \"fd passing not offered\"\r\n";
1299                   debug_print ("SERVER: writing `%s'", s);
1300                   if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1301                     goto out;
1302                 }
1303             }
1304           else
1305             {
1306               g_debug ("Unexpected line `%s' while in WaitingForBegin state", line);
1307               g_free (line);
1308               s = "ERROR \"Unknown Command\"\r\n";
1309               debug_print ("SERVER: writing `%s'", s);
1310               if (!g_data_output_stream_put_string (dos, s, cancellable, error))
1311                 goto out;
1312             }
1313           break;
1314
1315         default:
1316           g_assert_not_reached ();
1317           break;
1318         }
1319     }
1320
1321
1322   g_set_error_literal (error,
1323                        G_IO_ERROR,
1324                        G_IO_ERROR_FAILED,
1325                        "Not implemented (server)");
1326
1327  out:
1328   if (mech != NULL)
1329     g_object_unref (mech);
1330   if (dis != NULL)
1331     g_object_unref (dis);
1332   if (dos != NULL)
1333     g_object_unref (dos);
1334
1335   /* ensure return value is FALSE if error is set */
1336   if (error != NULL && *error != NULL)
1337     {
1338       ret = FALSE;
1339     }
1340
1341   if (ret)
1342     {
1343       if (out_negotiated_capabilities != NULL)
1344         *out_negotiated_capabilities = negotiated_capabilities;
1345       if (out_received_credentials != NULL)
1346         *out_received_credentials = credentials != NULL ? g_object_ref (credentials) : NULL;
1347     }
1348
1349   if (credentials != NULL)
1350     g_object_unref (credentials);
1351
1352   debug_print ("SERVER: Done, authenticated=%d", ret);
1353
1354   return ret;
1355 }
1356
1357 /* ---------------------------------------------------------------------------------------------------- */
1358
1359 #define __G_DBUS_AUTH_C__
1360 #include "gioaliasdef.c"