dbus/dbus-auth.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-auth.c Authentication
   3  *
   4  * Copyright (C) 2002, 2003, 2004 Red Hat Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23 #include "dbus-auth.h"
  24 #include "dbus-string.h"
  25 #include "dbus-list.h"
  26 #include "dbus-internals.h"
  27 #include "dbus-keyring.h"
  28 #include "dbus-sha.h"
  29 #include "dbus-protocol.h"
  30 #include "dbus-userdb.h"
  31
  32 /**
  33  * @defgroup DBusAuth Authentication
  34  * @ingroup  DBusInternals
  35  * @brief DBusAuth object
  36  *
  37  * DBusAuth manages the authentication negotiation when a connection
  38  * is first established, and also manage any encryption used over a
  39  * connection.
  40  *
  41  * @todo some SASL profiles require sending the empty string as a
  42  * challenge/response, but we don't currently allow that in our
  43  * protocol.
  44  *
  45  * @todo right now sometimes both ends will block waiting for input
  46  * from the other end, e.g. if there's an error during
  47  * DBUS_COOKIE_SHA1.
  48  *
  49  * @todo the cookie keyring needs to be cached globally not just
  50  * per-auth (which raises threadsafety issues too)
  51  *
  52  * @todo grep FIXME in dbus-auth.c
  53  */
  54
  55 /**
  56  * @defgroup DBusAuthInternals Authentication implementation details
  57  * @ingroup  DBusInternals
  58  * @brief DBusAuth implementation details
  59  *
  60  * Private details of authentication code.
  61  *
  62  * @{
  63  */
  64
  65 /**
  66  * This function appends an initial client response to the given string
  67  */
  68 typedef dbus_bool_t (* DBusInitialResponseFunction)  (DBusAuth         *auth,
  69                                                       DBusString       *response);
  70
  71 /**
  72  * This function processes a block of data received from the peer.
  73  * i.e. handles a DATA command.
  74  */
  75 typedef dbus_bool_t (* DBusAuthDataFunction)     (DBusAuth         *auth,
  76                                                   const DBusString *data);
  77
  78 /**
  79  * This function encodes a block of data from the peer.
  80  */
  81 typedef dbus_bool_t (* DBusAuthEncodeFunction)   (DBusAuth         *auth,
  82                                                   const DBusString *data,
  83                                                   DBusString       *encoded);
  84
  85 /**
  86  * This function decodes a block of data from the peer.
  87  */
  88 typedef dbus_bool_t (* DBusAuthDecodeFunction)   (DBusAuth         *auth,
  89                                                   const DBusString *data,
  90                                                   DBusString       *decoded);
  91
  92 /**
  93  * This function is called when the mechanism is abandoned.
  94  */
  95 typedef void        (* DBusAuthShutdownFunction) (DBusAuth       *auth);
  96
  97 /**
  98  * Virtual table representing a particular auth mechanism.
  99  */
 100 typedef struct
 101 {
 102   const char *mechanism; /**< Name of the mechanism */
 103   DBusAuthDataFunction server_data_func; /**< Function on server side for DATA */
 104   DBusAuthEncodeFunction server_encode_func; /**< Function on server side to encode */
 105   DBusAuthDecodeFunction server_decode_func; /**< Function on server side to decode */
 106   DBusAuthShutdownFunction server_shutdown_func; /**< Function on server side to shut down */
 107   DBusInitialResponseFunction client_initial_response_func; /**< Function on client side to handle initial response */
 108   DBusAuthDataFunction client_data_func; /**< Function on client side for DATA */
 109   DBusAuthEncodeFunction client_encode_func; /**< Function on client side for encode */
 110   DBusAuthDecodeFunction client_decode_func; /**< Function on client side for decode */
 111   DBusAuthShutdownFunction client_shutdown_func; /**< Function on client side for shutdown */
 112 } DBusAuthMechanismHandler;
 113
 114 /**
 115  * Enumeration for the known authentication commands.
 116  */
 117 typedef enum {
 118   DBUS_AUTH_COMMAND_AUTH,
 119   DBUS_AUTH_COMMAND_CANCEL,
 120   DBUS_AUTH_COMMAND_DATA,
 121   DBUS_AUTH_COMMAND_BEGIN,
 122   DBUS_AUTH_COMMAND_REJECTED,
 123   DBUS_AUTH_COMMAND_OK,
 124   DBUS_AUTH_COMMAND_ERROR,
 125   DBUS_AUTH_COMMAND_UNKNOWN
 126 } DBusAuthCommand;
 127
 128 /**
 129  * Auth state function, determines the reaction to incoming events for
 130  * a particular state. Returns whether we had enough memory to
 131  * complete the operation.
 132  */
 133 typedef dbus_bool_t (* DBusAuthStateFunction) (DBusAuth         *auth,
 134                                                DBusAuthCommand   command,
 135                                                const DBusString *args);
 136
 137 /**
 138  * Information about a auth state.
 139  */
 140 typedef struct
 141 {
 142   const char *name;               /**< Name of the state */
 143   DBusAuthStateFunction handler;  /**< State function for this state */
 144 } DBusAuthStateData;
 145
 146 /**
 147  * Internal members of DBusAuth.
 148  */
 149 struct DBusAuth
 150 {
 151   int refcount;           /**< reference count */
 152   const char *side;       /**< Client or server */
 153
 154   DBusString incoming;    /**< Incoming data buffer */
 155   DBusString outgoing;    /**< Outgoing data buffer */
 156
 157   const DBusAuthStateData *state;         /**< Current protocol state */
 158
 159   const DBusAuthMechanismHandler *mech;   /**< Current auth mechanism */
 160
 161   DBusString identity;                   /**< Current identity we're authorizing
 162                                           *   as.
 163                                           */
 164
 165   DBusCredentials credentials;      /**< Credentials read from socket,
 166                                      * fields may be -1
 167                                      */
 168
 169   DBusCredentials authorized_identity; /**< Credentials that are authorized */
 170
 171   DBusCredentials desired_identity;    /**< Identity client has requested */
 172
 173   DBusString context;               /**< Cookie scope */
 174   DBusKeyring *keyring;             /**< Keyring for cookie mechanism. */
 175   int cookie_id;                    /**< ID of cookie to use */
 176   DBusString challenge;             /**< Challenge sent to client */
 177
 178   char **allowed_mechs;             /**< Mechanisms we're allowed to use,
 179                                      * or #NULL if we can use any
 180                                      */
 181
 182   unsigned int needed_memory : 1;   /**< We needed memory to continue since last
 183                                      * successful getting something done
 184                                      */
 185   unsigned int already_got_mechanisms : 1;       /**< Client already got mech list */
 186   unsigned int already_asked_for_initial_response : 1; /**< Already sent a blank challenge to get an initial response */
 187   unsigned int buffer_outstanding : 1; /**< Buffer is "checked out" for reading data into */
 188 };
 189
 190 /**
 191  * "Subclass" of DBusAuth for client side
 192  */
 193 typedef struct
 194 {
 195   DBusAuth base;    /**< Parent class */
 196
 197   DBusList *mechs_to_try; /**< Mechanisms we got from the server that we're going to try using */
 198
 199   DBusString guid_from_server; /**< GUID received from server */
 200
 201 } DBusAuthClient;
 202
 203 /**
 204  * "Subclass" of DBusAuth for server side.
 205  */
 206 typedef struct
 207 {
 208   DBusAuth base;    /**< Parent class */
 209
 210   int failures;     /**< Number of times client has been rejected */
 211   int max_failures; /**< Number of times we reject before disconnect */
 212
 213   DBusString guid;  /**< Our globally unique ID in hex encoding */
 214
 215 } DBusAuthServer;
 216
 217 static void        goto_state                (DBusAuth                       *auth,
 218                                               const DBusAuthStateData        *new_state);
 219 static dbus_bool_t send_auth                 (DBusAuth *auth,
 220                                               const DBusAuthMechanismHandler *mech);
 221 static dbus_bool_t send_data                 (DBusAuth *auth,
 222                                               DBusString *data);
 223 static dbus_bool_t send_rejected             (DBusAuth *auth);
 224 static dbus_bool_t send_error                (DBusAuth *auth,
 225                                               const char *message);
 226 static dbus_bool_t send_ok                   (DBusAuth *auth);
 227 static dbus_bool_t send_begin                (DBusAuth *auth,
 228                                               const DBusString *args_from_ok);
 229 static dbus_bool_t send_cancel               (DBusAuth *auth);
 230
 231 /**
 232  * Client states
 233  */
 234
 235 static dbus_bool_t handle_server_state_waiting_for_auth  (DBusAuth         *auth,
 236                                                           DBusAuthCommand   command,
 237                                                           const DBusString *args);
 238 static dbus_bool_t handle_server_state_waiting_for_data  (DBusAuth         *auth,
 239                                                           DBusAuthCommand   command,
 240                                                           const DBusString *args);
 241 static dbus_bool_t handle_server_state_waiting_for_begin (DBusAuth         *auth,
 242                                                           DBusAuthCommand   command,
 243                                                           const DBusString *args);
 244
 245 static const DBusAuthStateData server_state_waiting_for_auth = {
 246   "WaitingForAuth", handle_server_state_waiting_for_auth
 247 };
 248 static const DBusAuthStateData server_state_waiting_for_data = {
 249   "WaitingForData", handle_server_state_waiting_for_data
 250 };
 251 static const DBusAuthStateData server_state_waiting_for_begin = {
 252   "WaitingForBegin", handle_server_state_waiting_for_begin
 253 };
 254
 255 /**
 256  * Client states
 257  */
 258
 259 static dbus_bool_t handle_client_state_waiting_for_data   (DBusAuth         *auth,
 260                                                            DBusAuthCommand   command,
 261                                                            const DBusString *args);
 262 static dbus_bool_t handle_client_state_waiting_for_ok     (DBusAuth         *auth,
 263                                                            DBusAuthCommand   command,
 264                                                            const DBusString *args);
 265 static dbus_bool_t handle_client_state_waiting_for_reject (DBusAuth         *auth,
 266                                                            DBusAuthCommand   command,
 267                                                            const DBusString *args);
 268
 269 static const DBusAuthStateData client_state_need_send_auth = {
 270   "NeedSendAuth", NULL
 271 };
 272 static const DBusAuthStateData client_state_waiting_for_data = {
 273   "WaitingForData", handle_client_state_waiting_for_data
 274 };
 275 static const DBusAuthStateData client_state_waiting_for_ok = {
 276   "WaitingForOK", handle_client_state_waiting_for_ok
 277 };
 278 static const DBusAuthStateData client_state_waiting_for_reject = {
 279   "WaitingForReject", handle_client_state_waiting_for_reject
 280 };
 281
 282 /**
 283  * Common terminal states.  Terminal states have handler == NULL.
 284  */
 285
 286 static const DBusAuthStateData common_state_authenticated = {
 287   "Authenticated",  NULL
 288 };
 289
 290 static const DBusAuthStateData common_state_need_disconnect = {
 291   "NeedDisconnect",  NULL
 292 };
 293
 294 static const char auth_side_client[] = "client";
 295 static const char auth_side_server[] = "server";
 296 /**
 297  * @param auth the auth conversation
 298  * @returns #TRUE if the conversation is the server side
 299  */
 300 #define DBUS_AUTH_IS_SERVER(auth) ((auth)->side == auth_side_server)
 301 /**
 302  * @param auth the auth conversation
 303  * @returns #TRUE if the conversation is the client side
 304  */
 305 #define DBUS_AUTH_IS_CLIENT(auth) ((auth)->side == auth_side_client)
 306 /**
 307  * @param auth the auth conversation
 308  * @returns auth cast to DBusAuthClient
 309  */
 310 #define DBUS_AUTH_CLIENT(auth)    ((DBusAuthClient*)(auth))
 311 /**
 312  * @param auth the auth conversation
 313  * @returns auth cast to DBusAuthServer
 314  */
 315 #define DBUS_AUTH_SERVER(auth)    ((DBusAuthServer*)(auth))
 316
 317 /**
 318  * The name of the auth ("client" or "server")
 319  * @param auth the auth conversation
 320  * @returns a string
 321  */
 322 #define DBUS_AUTH_NAME(auth)      ((auth)->side)
 323
 324 static DBusAuth*
 325 _dbus_auth_new (int size)
 326 {
 327   DBusAuth *auth;
 328
 329   auth = dbus_malloc0 (size);
 330   if (auth == NULL)
 331     return NULL;
 332
 333   auth->refcount = 1;
 334
 335   _dbus_credentials_clear (&auth->credentials);
 336   _dbus_credentials_clear (&auth->authorized_identity);
 337   _dbus_credentials_clear (&auth->desired_identity);
 338
 339   auth->keyring = NULL;
 340   auth->cookie_id = -1;
 341
 342   /* note that we don't use the max string length feature,
 343    * because you can't use that feature if you're going to
 344    * try to recover from out-of-memory (it creates
 345    * what looks like unrecoverable inability to alloc
 346    * more space in the string). But we do handle
 347    * overlong buffers in _dbus_auth_do_work().
 348    */
 349
 350   if (!_dbus_string_init (&auth->incoming))
 351     goto enomem_0;
 352
 353   if (!_dbus_string_init (&auth->outgoing))
 354     goto enomem_1;
 355
 356   if (!_dbus_string_init (&auth->identity))
 357     goto enomem_2;
 358
 359   if (!_dbus_string_init (&auth->context))
 360     goto enomem_3;
 361
 362   if (!_dbus_string_init (&auth->challenge))
 363     goto enomem_4;
 364
 365   /* default context if none is specified */
 366   if (!_dbus_string_append (&auth->context, "org_freedesktop_general"))
 367     goto enomem_5;
 368
 369   return auth;
 370
 371  enomem_5:
 372   _dbus_string_free (&auth->challenge);
 373  enomem_4:
 374   _dbus_string_free (&auth->context);
 375  enomem_3:
 376   _dbus_string_free (&auth->identity);
 377  enomem_2:
 378   _dbus_string_free (&auth->outgoing);
 379  enomem_1:
 380   _dbus_string_free (&auth->incoming);
 381  enomem_0:
 382   dbus_free (auth);
 383   return NULL;
 384 }
 385
 386 static void
 387 shutdown_mech (DBusAuth *auth)
 388 {
 389   /* Cancel any auth */
 390   auth->already_asked_for_initial_response = FALSE;
 391   _dbus_string_set_length (&auth->identity, 0);
 392
 393   _dbus_credentials_clear (&auth->authorized_identity);
 394   _dbus_credentials_clear (&auth->desired_identity);
 395
 396   if (auth->mech != NULL)
 397     {
 398       _dbus_verbose ("%s: Shutting down mechanism %s\n",
 399                      DBUS_AUTH_NAME (auth), auth->mech->mechanism);
 400
 401       if (DBUS_AUTH_IS_CLIENT (auth))
 402         (* auth->mech->client_shutdown_func) (auth);
 403       else
 404         (* auth->mech->server_shutdown_func) (auth);
 405
 406       auth->mech = NULL;
 407     }
 408 }
 409
 410 /* Returns TRUE but with an empty string hash if the
 411  * cookie_id isn't known. As with all this code
 412  * TRUE just means we had enough memory.
 413  */
 414 static dbus_bool_t
 415 sha1_compute_hash (DBusAuth         *auth,
 416                    int               cookie_id,
 417                    const DBusString *server_challenge,
 418                    const DBusString *client_challenge,
 419                    DBusString       *hash)
 420 {
 421   DBusString cookie;
 422   DBusString to_hash;
 423   dbus_bool_t retval;
 424
 425   _dbus_assert (auth->keyring != NULL);
 426
 427   retval = FALSE;
 428
 429   if (!_dbus_string_init (&cookie))
 430     return FALSE;
 431
 432   if (!_dbus_keyring_get_hex_key (auth->keyring, cookie_id,
 433                                   &cookie))
 434     goto out_0;
 435
 436   if (_dbus_string_get_length (&cookie) == 0)
 437     {
 438       retval = TRUE;
 439       goto out_0;
 440     }
 441
 442   if (!_dbus_string_init (&to_hash))
 443     goto out_0;
 444
 445   if (!_dbus_string_copy (server_challenge, 0,
 446                           &to_hash, _dbus_string_get_length (&to_hash)))
 447     goto out_1;
 448
 449   if (!_dbus_string_append (&to_hash, ":"))
 450     goto out_1;
 451
 452   if (!_dbus_string_copy (client_challenge, 0,
 453                           &to_hash, _dbus_string_get_length (&to_hash)))
 454     goto out_1;
 455
 456   if (!_dbus_string_append (&to_hash, ":"))
 457     goto out_1;
 458
 459   if (!_dbus_string_copy (&cookie, 0,
 460                           &to_hash, _dbus_string_get_length (&to_hash)))
 461     goto out_1;
 462
 463   if (!_dbus_sha_compute (&to_hash, hash))
 464     goto out_1;
 465
 466   retval = TRUE;
 467
 468  out_1:
 469   _dbus_string_zero (&to_hash);
 470   _dbus_string_free (&to_hash);
 471  out_0:
 472   _dbus_string_zero (&cookie);
 473   _dbus_string_free (&cookie);
 474   return retval;
 475 }
 476
 477 /** http://www.ietf.org/rfc/rfc2831.txt suggests at least 64 bits of
 478  * entropy, we use 128. This is the number of bytes in the random
 479  * challenge.
 480  */
 481 #define N_CHALLENGE_BYTES (128/8)
 482
 483 static dbus_bool_t
 484 sha1_handle_first_client_response (DBusAuth         *auth,
 485                                    const DBusString *data)
 486 {
 487   /* We haven't sent a challenge yet, we're expecting a desired
 488    * username from the client.
 489    */
 490   DBusString tmp;
 491   DBusString tmp2;
 492   dbus_bool_t retval;
 493   DBusError error;
 494
 495   retval = FALSE;
 496
 497   _dbus_string_set_length (&auth->challenge, 0);
 498
 499   if (_dbus_string_get_length (data) > 0)
 500     {
 501       if (_dbus_string_get_length (&auth->identity) > 0)
 502         {
 503           /* Tried to send two auth identities, wtf */
 504           _dbus_verbose ("%s: client tried to send auth identity, but we already have one\n",
 505                          DBUS_AUTH_NAME (auth));
 506           return send_rejected (auth);
 507         }
 508       else
 509         {
 510           /* this is our auth identity */
 511           if (!_dbus_string_copy (data, 0, &auth->identity, 0))
 512             return FALSE;
 513         }
 514     }
 515
 516   if (!_dbus_credentials_from_username (data, &auth->desired_identity))
 517     {
 518       _dbus_verbose ("%s: Did not get a valid username from client\n",
 519                      DBUS_AUTH_NAME (auth));
 520       return send_rejected (auth);
 521     }
 522
 523   if (!_dbus_string_init (&tmp))
 524     return FALSE;
 525
 526   if (!_dbus_string_init (&tmp2))
 527     {
 528       _dbus_string_free (&tmp);
 529       return FALSE;
 530     }
 531
 532   /* we cache the keyring for speed, so here we drop it if it's the
 533    * wrong one. FIXME caching the keyring here is useless since we use
 534    * a different DBusAuth for every connection.
 535    */
 536   if (auth->keyring &&
 537       !_dbus_keyring_is_for_user (auth->keyring,
 538                                   data))
 539     {
 540       _dbus_keyring_unref (auth->keyring);
 541       auth->keyring = NULL;
 542     }
 543
 544   if (auth->keyring == NULL)
 545     {
 546       DBusError error;
 547
 548       dbus_error_init (&error);
 549       auth->keyring = _dbus_keyring_new_homedir (data,
 550                                                  &auth->context,
 551                                                  &error);
 552
 553       if (auth->keyring == NULL)
 554         {
 555           if (dbus_error_has_name (&error,
 556                                    DBUS_ERROR_NO_MEMORY))
 557             {
 558               dbus_error_free (&error);
 559               goto out;
 560             }
 561           else
 562             {
 563               _DBUS_ASSERT_ERROR_IS_SET (&error);
 564               _dbus_verbose ("%s: Error loading keyring: %s\n",
 565                              DBUS_AUTH_NAME (auth), error.message);
 566               if (send_rejected (auth))
 567                 retval = TRUE; /* retval is only about mem */
 568               dbus_error_free (&error);
 569               goto out;
 570             }
 571         }
 572       else
 573         {
 574           _dbus_assert (!dbus_error_is_set (&error));
 575         }
 576     }
 577
 578   _dbus_assert (auth->keyring != NULL);
 579
 580   dbus_error_init (&error);
 581   auth->cookie_id = _dbus_keyring_get_best_key (auth->keyring, &error);
 582   if (auth->cookie_id < 0)
 583     {
 584       _DBUS_ASSERT_ERROR_IS_SET (&error);
 585       _dbus_verbose ("%s: Could not get a cookie ID to send to client: %s\n",
 586                      DBUS_AUTH_NAME (auth), error.message);
 587       if (send_rejected (auth))
 588         retval = TRUE;
 589       dbus_error_free (&error);
 590       goto out;
 591     }
 592   else
 593     {
 594       _dbus_assert (!dbus_error_is_set (&error));
 595     }
 596
 597   if (!_dbus_string_copy (&auth->context, 0,
 598                           &tmp2, _dbus_string_get_length (&tmp2)))
 599     goto out;
 600
 601   if (!_dbus_string_append (&tmp2, " "))
 602     goto out;
 603
 604   if (!_dbus_string_append_int (&tmp2, auth->cookie_id))
 605     goto out;
 606
 607   if (!_dbus_string_append (&tmp2, " "))
 608     goto out;
 609
 610   if (!_dbus_generate_random_bytes (&tmp, N_CHALLENGE_BYTES))
 611     goto out;
 612
 613   _dbus_string_set_length (&auth->challenge, 0);
 614   if (!_dbus_string_hex_encode (&tmp, 0, &auth->challenge, 0))
 615     goto out;
 616
 617   if (!_dbus_string_hex_encode (&tmp, 0, &tmp2,
 618                                 _dbus_string_get_length (&tmp2)))
 619     goto out;
 620
 621   if (!send_data (auth, &tmp2))
 622     goto out;
 623
 624   goto_state (auth, &server_state_waiting_for_data);
 625   retval = TRUE;
 626
 627  out:
 628   _dbus_string_zero (&tmp);
 629   _dbus_string_free (&tmp);
 630   _dbus_string_zero (&tmp2);
 631   _dbus_string_free (&tmp2);
 632
 633   return retval;
 634 }
 635
 636 static dbus_bool_t
 637 sha1_handle_second_client_response (DBusAuth         *auth,
 638                                     const DBusString *data)
 639 {
 640   /* We are expecting a response which is the hex-encoded client
 641    * challenge, space, then SHA-1 hash of the concatenation of our
 642    * challenge, ":", client challenge, ":", secret key, all
 643    * hex-encoded.
 644    */
 645   int i;
 646   DBusString client_challenge;
 647   DBusString client_hash;
 648   dbus_bool_t retval;
 649   DBusString correct_hash;
 650
 651   retval = FALSE;
 652
 653   if (!_dbus_string_find_blank (data, 0, &i))
 654     {
 655       _dbus_verbose ("%s: no space separator in client response\n",
 656                      DBUS_AUTH_NAME (auth));
 657       return send_rejected (auth);
 658     }
 659
 660   if (!_dbus_string_init (&client_challenge))
 661     goto out_0;
 662
 663   if (!_dbus_string_init (&client_hash))
 664     goto out_1;
 665
 666   if (!_dbus_string_copy_len (data, 0, i, &client_challenge,
 667                               0))
 668     goto out_2;
 669
 670   _dbus_string_skip_blank (data, i, &i);
 671
 672   if (!_dbus_string_copy_len (data, i,
 673                               _dbus_string_get_length (data) - i,
 674                               &client_hash,
 675                               0))
 676     goto out_2;
 677
 678   if (_dbus_string_get_length (&client_challenge) == 0 ||
 679       _dbus_string_get_length (&client_hash) == 0)
 680     {
 681       _dbus_verbose ("%s: zero-length client challenge or hash\n",
 682                      DBUS_AUTH_NAME (auth));
 683       if (send_rejected (auth))
 684         retval = TRUE;
 685       goto out_2;
 686     }
 687
 688   if (!_dbus_string_init (&correct_hash))
 689     goto out_2;
 690
 691   if (!sha1_compute_hash (auth, auth->cookie_id,
 692                           &auth->challenge,
 693                           &client_challenge,
 694                           &correct_hash))
 695     goto out_3;
 696
 697   /* if cookie_id was invalid, then we get an empty hash */
 698   if (_dbus_string_get_length (&correct_hash) == 0)
 699     {
 700       if (send_rejected (auth))
 701         retval = TRUE;
 702       goto out_3;
 703     }
 704
 705   if (!_dbus_string_equal (&client_hash, &correct_hash))
 706     {
 707       if (send_rejected (auth))
 708         retval = TRUE;
 709       goto out_3;
 710     }
 711
 712   if (!send_ok (auth))
 713     goto out_3;
 714
 715   _dbus_verbose ("%s: authenticated client with UID "DBUS_UID_FORMAT" using DBUS_COOKIE_SHA1\n",
 716                  DBUS_AUTH_NAME (auth), auth->desired_identity.uid);
 717
 718   auth->authorized_identity = auth->desired_identity;
 719   retval = TRUE;
 720
 721  out_3:
 722   _dbus_string_zero (&correct_hash);
 723   _dbus_string_free (&correct_hash);
 724  out_2:
 725   _dbus_string_zero (&client_hash);
 726   _dbus_string_free (&client_hash);
 727  out_1:
 728   _dbus_string_free (&client_challenge);
 729  out_0:
 730   return retval;
 731 }
 732
 733 static dbus_bool_t
 734 handle_server_data_cookie_sha1_mech (DBusAuth         *auth,
 735                                      const DBusString *data)
 736 {
 737   if (auth->cookie_id < 0)
 738     return sha1_handle_first_client_response (auth, data);
 739   else
 740     return sha1_handle_second_client_response (auth, data);
 741 }
 742
 743 static void
 744 handle_server_shutdown_cookie_sha1_mech (DBusAuth *auth)
 745 {
 746   auth->cookie_id = -1;
 747   _dbus_string_set_length (&auth->challenge, 0);
 748 }
 749
 750 static dbus_bool_t
 751 handle_client_initial_response_cookie_sha1_mech (DBusAuth   *auth,
 752                                                  DBusString *response)
 753 {
 754   const DBusString *username;
 755   dbus_bool_t retval;
 756
 757   retval = FALSE;
 758
 759   if (!_dbus_username_from_current_process (&username))
 760     goto out_0;
 761
 762   if (!_dbus_string_hex_encode (username, 0,
 763                                 response,
 764                                 _dbus_string_get_length (response)))
 765     goto out_0;
 766
 767   retval = TRUE;
 768
 769  out_0:
 770   return retval;
 771 }
 772
 773 static dbus_bool_t
 774 handle_client_data_cookie_sha1_mech (DBusAuth         *auth,
 775                                      const DBusString *data)
 776 {
 777   /* The data we get from the server should be the cookie context
 778    * name, the cookie ID, and the server challenge, separated by
 779    * spaces. We send back our challenge string and the correct hash.
 780    */
 781   dbus_bool_t retval;
 782   DBusString context;
 783   DBusString cookie_id_str;
 784   DBusString server_challenge;
 785   DBusString client_challenge;
 786   DBusString correct_hash;
 787   DBusString tmp;
 788   int i, j;
 789   long val;
 790
 791   retval = FALSE;
 792
 793   if (!_dbus_string_find_blank (data, 0, &i))
 794     {
 795       if (send_error (auth,
 796                       "Server did not send context/ID/challenge properly"))
 797         retval = TRUE;
 798       goto out_0;
 799     }
 800
 801   if (!_dbus_string_init (&context))
 802     goto out_0;
 803
 804   if (!_dbus_string_copy_len (data, 0, i,
 805                               &context, 0))
 806     goto out_1;
 807
 808   _dbus_string_skip_blank (data, i, &i);
 809   if (!_dbus_string_find_blank (data, i, &j))
 810     {
 811       if (send_error (auth,
 812                       "Server did not send context/ID/challenge properly"))
 813         retval = TRUE;
 814       goto out_1;
 815     }
 816
 817   if (!_dbus_string_init (&cookie_id_str))
 818     goto out_1;
 819
 820   if (!_dbus_string_copy_len (data, i, j - i,
 821                               &cookie_id_str, 0))
 822     goto out_2;
 823
 824   if (!_dbus_string_init (&server_challenge))
 825     goto out_2;
 826
 827   i = j;
 828   _dbus_string_skip_blank (data, i, &i);
 829   j = _dbus_string_get_length (data);
 830
 831   if (!_dbus_string_copy_len (data, i, j - i,
 832                               &server_challenge, 0))
 833     goto out_3;
 834
 835   if (!_dbus_keyring_validate_context (&context))
 836     {
 837       if (send_error (auth, "Server sent invalid cookie context"))
 838         retval = TRUE;
 839       goto out_3;
 840     }
 841
 842   if (!_dbus_string_parse_int (&cookie_id_str, 0, &val, NULL))
 843     {
 844       if (send_error (auth, "Could not parse cookie ID as an integer"))
 845         retval = TRUE;
 846       goto out_3;
 847     }
 848
 849   if (_dbus_string_get_length (&server_challenge) == 0)
 850     {
 851       if (send_error (auth, "Empty server challenge string"))
 852         retval = TRUE;
 853       goto out_3;
 854     }
 855
 856   if (auth->keyring == NULL)
 857     {
 858       DBusError error;
 859
 860       dbus_error_init (&error);
 861       auth->keyring = _dbus_keyring_new_homedir (NULL,
 862                                                  &context,
 863                                                  &error);
 864
 865       if (auth->keyring == NULL)
 866         {
 867           if (dbus_error_has_name (&error,
 868                                    DBUS_ERROR_NO_MEMORY))
 869             {
 870               dbus_error_free (&error);
 871               goto out_3;
 872             }
 873           else
 874             {
 875               _DBUS_ASSERT_ERROR_IS_SET (&error);
 876
 877               _dbus_verbose ("%s: Error loading keyring: %s\n",
 878                              DBUS_AUTH_NAME (auth), error.message);
 879
 880               if (send_error (auth, "Could not load cookie file"))
 881                 retval = TRUE; /* retval is only about mem */
 882
 883               dbus_error_free (&error);
 884               goto out_3;
 885             }
 886         }
 887       else
 888         {
 889           _dbus_assert (!dbus_error_is_set (&error));
 890         }
 891     }
 892
 893   _dbus_assert (auth->keyring != NULL);
 894
 895   if (!_dbus_string_init (&tmp))
 896     goto out_3;
 897
 898   if (!_dbus_generate_random_bytes (&tmp, N_CHALLENGE_BYTES))
 899     goto out_4;
 900
 901   if (!_dbus_string_init (&client_challenge))
 902     goto out_4;
 903
 904   if (!_dbus_string_hex_encode (&tmp, 0, &client_challenge, 0))
 905     goto out_5;
 906
 907   if (!_dbus_string_init (&correct_hash))
 908     goto out_5;
 909
 910   if (!sha1_compute_hash (auth, val,
 911                           &server_challenge,
 912                           &client_challenge,
 913                           &correct_hash))
 914     goto out_6;
 915
 916   if (_dbus_string_get_length (&correct_hash) == 0)
 917     {
 918       /* couldn't find the cookie ID or something */
 919       if (send_error (auth, "Don't have the requested cookie ID"))
 920         retval = TRUE;
 921       goto out_6;
 922     }
 923
 924   _dbus_string_set_length (&tmp, 0);
 925
 926   if (!_dbus_string_copy (&client_challenge, 0, &tmp,
 927                           _dbus_string_get_length (&tmp)))
 928     goto out_6;
 929
 930   if (!_dbus_string_append (&tmp, " "))
 931     goto out_6;
 932
 933   if (!_dbus_string_copy (&correct_hash, 0, &tmp,
 934                           _dbus_string_get_length (&tmp)))
 935     goto out_6;
 936
 937   if (!send_data (auth, &tmp))
 938     goto out_6;
 939
 940   retval = TRUE;
 941
 942  out_6:
 943   _dbus_string_zero (&correct_hash);
 944   _dbus_string_free (&correct_hash);
 945  out_5:
 946   _dbus_string_free (&client_challenge);
 947  out_4:
 948   _dbus_string_zero (&tmp);
 949   _dbus_string_free (&tmp);
 950  out_3:
 951   _dbus_string_free (&server_challenge);
 952  out_2:
 953   _dbus_string_free (&cookie_id_str);
 954  out_1:
 955   _dbus_string_free (&context);
 956  out_0:
 957   return retval;
 958 }
 959
 960 static void
 961 handle_client_shutdown_cookie_sha1_mech (DBusAuth *auth)
 962 {
 963   auth->cookie_id = -1;
 964   _dbus_string_set_length (&auth->challenge, 0);
 965 }
 966
 967 static dbus_bool_t
 968 handle_server_data_external_mech (DBusAuth         *auth,
 969                                   const DBusString *data)
 970 {
 971   if (auth->credentials.uid == DBUS_UID_UNSET)
 972     {
 973       _dbus_verbose ("%s: no credentials, mechanism EXTERNAL can't authenticate\n",
 974                      DBUS_AUTH_NAME (auth));
 975       return send_rejected (auth);
 976     }
 977
 978   if (_dbus_string_get_length (data) > 0)
 979     {
 980       if (_dbus_string_get_length (&auth->identity) > 0)
 981         {
 982           /* Tried to send two auth identities, wtf */
 983           _dbus_verbose ("%s: client tried to send auth identity, but we already have one\n",
 984                          DBUS_AUTH_NAME (auth));
 985           return send_rejected (auth);
 986         }
 987       else
 988         {
 989           /* this is our auth identity */
 990           if (!_dbus_string_copy (data, 0, &auth->identity, 0))
 991             return FALSE;
 992         }
 993     }
 994
 995   /* Poke client for an auth identity, if none given */
 996   if (_dbus_string_get_length (&auth->identity) == 0 &&
 997       !auth->already_asked_for_initial_response)
 998     {
 999       if (send_data (auth, NULL))
1000         {
1001           _dbus_verbose ("%s: sending empty challenge asking client for auth identity\n",
1002                          DBUS_AUTH_NAME (auth));
1003           auth->already_asked_for_initial_response = TRUE;
1004           return TRUE;
1005         }
1006       else
1007         return FALSE;
1008     }
1009
1010   _dbus_credentials_clear (&auth->desired_identity);
1011
1012   /* If auth->identity is still empty here, then client
1013    * responded with an empty string after we poked it for
1014    * an initial response. This means to try to auth the
1015    * identity provided in the credentials.
1016    */
1017   if (_dbus_string_get_length (&auth->identity) == 0)
1018     {
1019       auth->desired_identity.uid = auth->credentials.uid;
1020     }
1021   else
1022     {
1023       if (!_dbus_parse_uid (&auth->identity,
1024                             &auth->desired_identity.uid))
1025         {
1026           _dbus_verbose ("%s: could not get credentials from uid string\n",
1027                          DBUS_AUTH_NAME (auth));
1028           return send_rejected (auth);
1029         }
1030     }
1031
1032   if (auth->desired_identity.uid == DBUS_UID_UNSET)
1033     {
1034       _dbus_verbose ("%s: desired user %s is no good\n",
1035                      DBUS_AUTH_NAME (auth),
1036                      _dbus_string_get_const_data (&auth->identity));
1037       return send_rejected (auth);
1038     }
1039
1040   if (_dbus_credentials_match (&auth->desired_identity,
1041                                &auth->credentials))
1042     {
1043       /* client has authenticated */
1044       if (!send_ok (auth))
1045         return FALSE;
1046
1047       _dbus_verbose ("%s: authenticated client with UID "DBUS_UID_FORMAT
1048                      " matching socket credentials UID "DBUS_UID_FORMAT"\n",
1049                      DBUS_AUTH_NAME (auth),
1050                      auth->desired_identity.uid,
1051                      auth->credentials.uid);
1052
1053       auth->authorized_identity.pid = auth->credentials.pid;
1054       auth->authorized_identity.uid = auth->desired_identity.uid;
1055       return TRUE;
1056     }
1057   else
1058     {
1059       _dbus_verbose ("%s: credentials uid="DBUS_UID_FORMAT
1060                      " gid="DBUS_GID_FORMAT
1061                      " do not allow uid="DBUS_UID_FORMAT
1062                      " gid="DBUS_GID_FORMAT"\n",
1063                      DBUS_AUTH_NAME (auth),
1064                      auth->credentials.uid, auth->credentials.gid,
1065                      auth->desired_identity.uid, auth->desired_identity.gid);
1066       return send_rejected (auth);
1067     }
1068 }
1069
1070 static void
1071 handle_server_shutdown_external_mech (DBusAuth *auth)
1072 {
1073
1074 }
1075
1076 static dbus_bool_t
1077 handle_client_initial_response_external_mech (DBusAuth         *auth,
1078                                               DBusString       *response)
1079 {
1080   /* We always append our UID as an initial response, so the server
1081    * doesn't have to send back an empty challenge to check whether we
1082    * want to specify an identity. i.e. this avoids a round trip that
1083    * the spec for the EXTERNAL mechanism otherwise requires.
1084    */
1085   DBusString plaintext;
1086
1087   if (!_dbus_string_init (&plaintext))
1088     return FALSE;
1089
1090   if (!_dbus_string_append_uint (&plaintext,
1091                                  _dbus_getuid ()))
1092     goto failed;
1093
1094   if (!_dbus_string_hex_encode (&plaintext, 0,
1095                                 response,
1096                                 _dbus_string_get_length (response)))
1097     goto failed;
1098
1099   _dbus_string_free (&plaintext);
1100
1101   return TRUE;
1102
1103  failed:
1104   _dbus_string_free (&plaintext);
1105   return FALSE;
1106 }
1107
1108 static dbus_bool_t
1109 handle_client_data_external_mech (DBusAuth         *auth,
1110                                   const DBusString *data)
1111 {
1112
1113   return TRUE;
1114 }
1115
1116 static void
1117 handle_client_shutdown_external_mech (DBusAuth *auth)
1118 {
1119
1120 }
1121
1122 /* Put mechanisms here in order of preference.
1123  * What I eventually want to have is:
1124  *
1125  *  - a mechanism that checks UNIX domain socket credentials
1126  *  - a simple magic cookie mechanism like X11 or ICE
1127  *  - mechanisms that chain to Cyrus SASL, so we can use anything it
1128  *    offers such as Kerberos, X509, whatever.
1129  *
1130  */
1131 static const DBusAuthMechanismHandler
1132 all_mechanisms[] = {
1133   { "EXTERNAL",
1134     handle_server_data_external_mech,
1135     NULL, NULL,
1136     handle_server_shutdown_external_mech,
1137     handle_client_initial_response_external_mech,
1138     handle_client_data_external_mech,
1139     NULL, NULL,
1140     handle_client_shutdown_external_mech },
1141   { "DBUS_COOKIE_SHA1",
1142     handle_server_data_cookie_sha1_mech,
1143     NULL, NULL,
1144     handle_server_shutdown_cookie_sha1_mech,
1145     handle_client_initial_response_cookie_sha1_mech,
1146     handle_client_data_cookie_sha1_mech,
1147     NULL, NULL,
1148     handle_client_shutdown_cookie_sha1_mech },
1149   { NULL, NULL }
1150 };
1151
1152 static const DBusAuthMechanismHandler*
1153 find_mech (const DBusString  *name,
1154            char             **allowed_mechs)
1155 {
1156   int i;
1157
1158   if (allowed_mechs != NULL &&
1159       !_dbus_string_array_contains ((const char**) allowed_mechs,
1160                                     _dbus_string_get_const_data (name)))
1161     return NULL;
1162
1163   i = 0;
1164   while (all_mechanisms[i].mechanism != NULL)
1165     {
1166       if (_dbus_string_equal_c_str (name,
1167                                     all_mechanisms[i].mechanism))
1168
1169         return &all_mechanisms[i];
1170
1171       ++i;
1172     }
1173
1174   return NULL;
1175 }
1176
1177 static dbus_bool_t
1178 send_auth (DBusAuth *auth, const DBusAuthMechanismHandler *mech)
1179 {
1180   DBusString auth_command;
1181
1182   if (!_dbus_string_init (&auth_command))
1183     return FALSE;
1184
1185   if (!_dbus_string_append (&auth_command,
1186                             "AUTH "))
1187     {
1188       _dbus_string_free (&auth_command);
1189       return FALSE;
1190     }
1191
1192   if (!_dbus_string_append (&auth_command,
1193                             mech->mechanism))
1194     {
1195       _dbus_string_free (&auth_command);
1196       return FALSE;
1197     }
1198
1199   if (mech->client_initial_response_func != NULL)
1200     {
1201       if (!_dbus_string_append (&auth_command, " "))
1202         {
1203           _dbus_string_free (&auth_command);
1204           return FALSE;
1205         }
1206
1207       if (!(* mech->client_initial_response_func) (auth, &auth_command))
1208         {
1209           _dbus_string_free (&auth_command);
1210           return FALSE;
1211         }
1212     }
1213
1214   if (!_dbus_string_append (&auth_command,
1215                             "\r\n"))
1216     {
1217       _dbus_string_free (&auth_command);
1218       return FALSE;
1219     }
1220
1221   if (!_dbus_string_copy (&auth_command, 0,
1222                           &auth->outgoing,
1223                           _dbus_string_get_length (&auth->outgoing)))
1224     {
1225       _dbus_string_free (&auth_command);
1226       return FALSE;
1227     }
1228
1229   _dbus_string_free (&auth_command);
1230   shutdown_mech (auth);
1231   auth->mech = mech;
1232   goto_state (auth, &client_state_waiting_for_data);
1233
1234   return TRUE;
1235 }
1236
1237 static dbus_bool_t
1238 send_data (DBusAuth *auth, DBusString *data)
1239 {
1240   int old_len;
1241
1242   if (data == NULL || _dbus_string_get_length (data) == 0)
1243     return _dbus_string_append (&auth->outgoing, "DATA\r\n");
1244   else
1245     {
1246       old_len = _dbus_string_get_length (&auth->outgoing);
1247       if (!_dbus_string_append (&auth->outgoing, "DATA "))
1248         goto out;
1249
1250       if (!_dbus_string_hex_encode (data, 0, &auth->outgoing,
1251                                     _dbus_string_get_length (&auth->outgoing)))
1252         goto out;
1253
1254       if (!_dbus_string_append (&auth->outgoing, "\r\n"))
1255         goto out;
1256
1257       return TRUE;
1258
1259     out:
1260       _dbus_string_set_length (&auth->outgoing, old_len);
1261
1262       return FALSE;
1263     }
1264 }
1265
1266 static dbus_bool_t
1267 send_rejected (DBusAuth *auth)
1268 {
1269   DBusString command;
1270   DBusAuthServer *server_auth;
1271   int i;
1272
1273   if (!_dbus_string_init (&command))
1274     return FALSE;
1275
1276   if (!_dbus_string_append (&command,
1277                             "REJECTED"))
1278     goto nomem;
1279
1280   i = 0;
1281   while (all_mechanisms[i].mechanism != NULL)
1282     {
1283       if (!_dbus_string_append (&command,
1284                                 " "))
1285         goto nomem;
1286
1287       if (!_dbus_string_append (&command,
1288                                 all_mechanisms[i].mechanism))
1289         goto nomem;
1290
1291       ++i;
1292     }
1293
1294   if (!_dbus_string_append (&command, "\r\n"))
1295     goto nomem;
1296
1297   if (!_dbus_string_copy (&command, 0, &auth->outgoing,
1298                           _dbus_string_get_length (&auth->outgoing)))
1299     goto nomem;
1300
1301   shutdown_mech (auth);
1302
1303   _dbus_assert (DBUS_AUTH_IS_SERVER (auth));
1304   server_auth = DBUS_AUTH_SERVER (auth);
1305   server_auth->failures += 1;
1306
1307   if (server_auth->failures >= server_auth->max_failures)
1308     goto_state (auth, &common_state_need_disconnect);
1309   else
1310     goto_state (auth, &server_state_waiting_for_auth);
1311
1312   _dbus_string_free (&command);
1313
1314   return TRUE;
1315
1316  nomem:
1317   _dbus_string_free (&command);
1318   return FALSE;
1319 }
1320
1321 static dbus_bool_t
1322 send_error (DBusAuth *auth, const char *message)
1323 {
1324   return _dbus_string_append_printf (&auth->outgoing,
1325                                      "ERROR \"%s\"\r\n", message);
1326 }
1327
1328 static dbus_bool_t
1329 send_ok (DBusAuth *auth)
1330 {
1331   int orig_len;
1332
1333   orig_len = _dbus_string_get_length (&auth->outgoing);
1334
1335   if (_dbus_string_append (&auth->outgoing, "OK ") &&
1336       _dbus_string_copy (& DBUS_AUTH_SERVER (auth)->guid,
1337                          0,
1338                          &auth->outgoing,
1339                          _dbus_string_get_length (&auth->outgoing)) &&
1340       _dbus_string_append (&auth->outgoing, "\r\n"))
1341     {
1342       goto_state (auth, &server_state_waiting_for_begin);
1343       return TRUE;
1344     }
1345   else
1346     {
1347       _dbus_string_set_length (&auth->outgoing, orig_len);
1348       return FALSE;
1349     }
1350 }
1351
1352 static dbus_bool_t
1353 send_begin (DBusAuth         *auth,
1354             const DBusString *args_from_ok)
1355 {
1356   int end_of_hex;
1357
1358   /* "args_from_ok" should be the GUID, whitespace already pulled off the front */
1359   _dbus_assert (_dbus_string_get_length (& DBUS_AUTH_CLIENT (auth)->guid_from_server) == 0);
1360
1361   /* We decode the hex string to binary, using guid_from_server as scratch... */
1362
1363   end_of_hex = 0;
1364   if (!_dbus_string_hex_decode (args_from_ok, 0, &end_of_hex,
1365                                 & DBUS_AUTH_CLIENT (auth)->guid_from_server, 0))
1366     return FALSE;
1367
1368   /* now clear out the scratch */
1369   _dbus_string_set_length (& DBUS_AUTH_CLIENT (auth)->guid_from_server, 0);
1370
1371   if (end_of_hex != _dbus_string_get_length (args_from_ok) ||
1372       end_of_hex == 0)
1373     {
1374       _dbus_verbose ("Bad GUID from server, parsed %d bytes and had %d bytes from server\n",
1375                      end_of_hex, _dbus_string_get_length (args_from_ok));
1376       goto_state (auth, &common_state_need_disconnect);
1377       return TRUE;
1378     }
1379
1380   if (_dbus_string_copy (args_from_ok, 0, &DBUS_AUTH_CLIENT (auth)->guid_from_server, 0) &&
1381       _dbus_string_append (&auth->outgoing, "BEGIN\r\n"))
1382     {
1383       _dbus_verbose ("Got GUID '%s' from the server\n",
1384                      _dbus_string_get_const_data (& DBUS_AUTH_CLIENT (auth)->guid_from_server));
1385
1386       goto_state (auth, &common_state_authenticated);
1387       return TRUE;
1388     }
1389   else
1390     {
1391       _dbus_string_set_length (& DBUS_AUTH_CLIENT (auth)->guid_from_server, 0);
1392       return FALSE;
1393     }
1394 }
1395
1396 static dbus_bool_t
1397 send_cancel (DBusAuth *auth)
1398 {
1399   if (_dbus_string_append (&auth->outgoing, "CANCEL\r\n"))
1400     {
1401       goto_state (auth, &client_state_waiting_for_reject);
1402       return TRUE;
1403     }
1404   else
1405     return FALSE;
1406 }
1407
1408 static dbus_bool_t
1409 process_data (DBusAuth             *auth,
1410               const DBusString     *args,
1411               DBusAuthDataFunction  data_func)
1412 {
1413   int end;
1414   DBusString decoded;
1415
1416   if (!_dbus_string_init (&decoded))
1417     return FALSE;
1418
1419   if (!_dbus_string_hex_decode (args, 0, &end, &decoded, 0))
1420     {
1421       _dbus_string_free (&decoded);
1422       return FALSE;
1423     }
1424
1425   if (_dbus_string_get_length (args) != end)
1426     {
1427       _dbus_string_free (&decoded);
1428       if (!send_error (auth, "Invalid hex encoding"))
1429         return FALSE;
1430
1431       return TRUE;
1432     }
1433
1434 #ifdef DBUS_ENABLE_VERBOSE_MODE
1435   if (_dbus_string_validate_ascii (&decoded, 0,
1436                                    _dbus_string_get_length (&decoded)))
1437     _dbus_verbose ("%s: data: '%s'\n",
1438                    DBUS_AUTH_NAME (auth),
1439                    _dbus_string_get_const_data (&decoded));
1440 #endif
1441
1442   if (!(* data_func) (auth, &decoded))
1443     {
1444       _dbus_string_free (&decoded);
1445       return FALSE;
1446     }
1447
1448   _dbus_string_free (&decoded);
1449   return TRUE;
1450 }
1451
1452 static dbus_bool_t
1453 handle_auth (DBusAuth *auth, const DBusString *args)
1454 {
1455   if (_dbus_string_get_length (args) == 0)
1456     {
1457       /* No args to the auth, send mechanisms */
1458       if (!send_rejected (auth))
1459         return FALSE;
1460
1461       return TRUE;
1462     }
1463   else
1464     {
1465       int i;
1466       DBusString mech;
1467       DBusString hex_response;
1468
1469       _dbus_string_find_blank (args, 0, &i);
1470
1471       if (!_dbus_string_init (&mech))
1472         return FALSE;
1473
1474       if (!_dbus_string_init (&hex_response))
1475         {
1476           _dbus_string_free (&mech);
1477           return FALSE;
1478         }
1479
1480       if (!_dbus_string_copy_len (args, 0, i, &mech, 0))
1481         goto failed;
1482
1483       _dbus_string_skip_blank (args, i, &i);
1484       if (!_dbus_string_copy (args, i, &hex_response, 0))
1485         goto failed;
1486
1487       auth->mech = find_mech (&mech, auth->allowed_mechs);
1488       if (auth->mech != NULL)
1489         {
1490           _dbus_verbose ("%s: Trying mechanism %s\n",
1491                          DBUS_AUTH_NAME (auth),
1492                          auth->mech->mechanism);
1493
1494           if (!process_data (auth, &hex_response,
1495                              auth->mech->server_data_func))
1496             goto failed;
1497         }
1498       else
1499         {
1500           /* Unsupported mechanism */
1501           _dbus_verbose ("%s: Unsupported mechanism %s\n",
1502                          DBUS_AUTH_NAME (auth),
1503                          _dbus_string_get_const_data (&mech));
1504
1505           if (!send_rejected (auth))
1506             goto failed;
1507         }
1508
1509       _dbus_string_free (&mech);
1510       _dbus_string_free (&hex_response);
1511
1512       return TRUE;
1513
1514     failed:
1515       auth->mech = NULL;
1516       _dbus_string_free (&mech);
1517       _dbus_string_free (&hex_response);
1518       return FALSE;
1519     }
1520 }
1521
1522 static dbus_bool_t
1523 handle_server_state_waiting_for_auth  (DBusAuth         *auth,
1524                                        DBusAuthCommand   command,
1525                                        const DBusString *args)
1526 {
1527   switch (command)
1528     {
1529     case DBUS_AUTH_COMMAND_AUTH:
1530       return handle_auth (auth, args);
1531
1532     case DBUS_AUTH_COMMAND_CANCEL:
1533     case DBUS_AUTH_COMMAND_DATA:
1534       return send_error (auth, "Not currently in an auth conversation");
1535
1536     case DBUS_AUTH_COMMAND_BEGIN:
1537       goto_state (auth, &common_state_need_disconnect);
1538       return TRUE;
1539
1540     case DBUS_AUTH_COMMAND_ERROR:
1541       return send_rejected (auth);
1542
1543     case DBUS_AUTH_COMMAND_REJECTED:
1544     case DBUS_AUTH_COMMAND_OK:
1545     case DBUS_AUTH_COMMAND_UNKNOWN:
1546     default:
1547       return send_error (auth, "Unknown command");
1548     }
1549 }
1550
1551 static dbus_bool_t
1552 handle_server_state_waiting_for_data  (DBusAuth         *auth,
1553                                        DBusAuthCommand   command,
1554                                        const DBusString *args)
1555 {
1556   switch (command)
1557     {
1558     case DBUS_AUTH_COMMAND_AUTH:
1559       return send_error (auth, "Sent AUTH while another AUTH in progress");
1560
1561     case DBUS_AUTH_COMMAND_CANCEL:
1562     case DBUS_AUTH_COMMAND_ERROR:
1563       return send_rejected (auth);
1564
1565     case DBUS_AUTH_COMMAND_DATA:
1566       return process_data (auth, args, auth->mech->server_data_func);
1567
1568     case DBUS_AUTH_COMMAND_BEGIN:
1569       goto_state (auth, &common_state_need_disconnect);
1570       return TRUE;
1571
1572     case DBUS_AUTH_COMMAND_REJECTED:
1573     case DBUS_AUTH_COMMAND_OK:
1574     case DBUS_AUTH_COMMAND_UNKNOWN:
1575     default:
1576       return send_error (auth, "Unknown command");
1577     }
1578 }
1579
1580 static dbus_bool_t
1581 handle_server_state_waiting_for_begin (DBusAuth         *auth,
1582                                        DBusAuthCommand   command,
1583                                        const DBusString *args)
1584 {
1585   switch (command)
1586     {
1587     case DBUS_AUTH_COMMAND_AUTH:
1588       return send_error (auth, "Sent AUTH while expecting BEGIN");
1589
1590     case DBUS_AUTH_COMMAND_DATA:
1591       return send_error (auth, "Sent DATA while expecting BEGIN");
1592
1593     case DBUS_AUTH_COMMAND_BEGIN:
1594       goto_state (auth, &common_state_authenticated);
1595       return TRUE;
1596
1597     case DBUS_AUTH_COMMAND_REJECTED:
1598     case DBUS_AUTH_COMMAND_OK:
1599     case DBUS_AUTH_COMMAND_UNKNOWN:
1600     default:
1601       return send_error (auth, "Unknown command");
1602
1603     case DBUS_AUTH_COMMAND_CANCEL:
1604     case DBUS_AUTH_COMMAND_ERROR:
1605       return send_rejected (auth);
1606     }
1607 }
1608
1609 /* return FALSE if no memory, TRUE if all OK */
1610 static dbus_bool_t
1611 get_word (const DBusString *str,
1612           int              *start,
1613           DBusString       *word)
1614 {
1615   int i;
1616
1617   _dbus_string_skip_blank (str, *start, start);
1618   _dbus_string_find_blank (str, *start, &i);
1619
1620   if (i > *start)
1621     {
1622       if (!_dbus_string_copy_len (str, *start, i - *start, word, 0))
1623         return FALSE;
1624
1625       *start = i;
1626     }
1627
1628   return TRUE;
1629 }
1630
1631 static dbus_bool_t
1632 record_mechanisms (DBusAuth         *auth,
1633                    const DBusString *args)
1634 {
1635   int next;
1636   int len;
1637
1638   if (auth->already_got_mechanisms)
1639     return TRUE;
1640
1641   len = _dbus_string_get_length (args);
1642
1643   next = 0;
1644   while (next < len)
1645     {
1646       DBusString m;
1647       const DBusAuthMechanismHandler *mech;
1648
1649       if (!_dbus_string_init (&m))
1650         goto nomem;
1651
1652       if (!get_word (args, &next, &m))
1653         {
1654           _dbus_string_free (&m);
1655           goto nomem;
1656         }
1657
1658       mech = find_mech (&m, auth->allowed_mechs);
1659
1660       if (mech != NULL)
1661         {
1662           /* FIXME right now we try mechanisms in the order
1663            * the server lists them; should we do them in
1664            * some more deterministic order?
1665            *
1666            * Probably in all_mechanisms order, our order of
1667            * preference. Of course when the server is us,
1668            * it lists things in that order anyhow.
1669            */
1670
1671           if (mech != &all_mechanisms[0])
1672             {
1673               _dbus_verbose ("%s: Adding mechanism %s to list we will try\n",
1674                              DBUS_AUTH_NAME (auth), mech->mechanism);
1675
1676               if (!_dbus_list_append (& DBUS_AUTH_CLIENT (auth)->mechs_to_try,
1677                                       (void*) mech))
1678                 {
1679                   _dbus_string_free (&m);
1680                   goto nomem;
1681                 }
1682             }
1683           else
1684             {
1685               _dbus_verbose ("%s: Already tried mechanism %s; not adding to list we will try\n",
1686                              DBUS_AUTH_NAME (auth), mech->mechanism);
1687             }
1688         }
1689       else
1690         {
1691           _dbus_verbose ("%s: Server offered mechanism \"%s\" that we don't know how to use\n",
1692                          DBUS_AUTH_NAME (auth),
1693                          _dbus_string_get_const_data (&m));
1694         }
1695
1696       _dbus_string_free (&m);
1697     }
1698
1699   auth->already_got_mechanisms = TRUE;
1700
1701   return TRUE;
1702
1703  nomem:
1704   _dbus_list_clear (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
1705
1706   return FALSE;
1707 }
1708
1709 static dbus_bool_t
1710 process_rejected (DBusAuth *auth, const DBusString *args)
1711 {
1712   const DBusAuthMechanismHandler *mech;
1713   DBusAuthClient *client;
1714
1715   client = DBUS_AUTH_CLIENT (auth);
1716
1717   if (!auth->already_got_mechanisms)
1718     {
1719       if (!record_mechanisms (auth, args))
1720         return FALSE;
1721     }
1722
1723   if (DBUS_AUTH_CLIENT (auth)->mechs_to_try != NULL)
1724     {
1725       mech = client->mechs_to_try->data;
1726
1727       if (!send_auth (auth, mech))
1728         return FALSE;
1729
1730       _dbus_list_pop_first (&client->mechs_to_try);
1731
1732       _dbus_verbose ("%s: Trying mechanism %s\n",
1733                      DBUS_AUTH_NAME (auth),
1734                      mech->mechanism);
1735     }
1736   else
1737     {
1738       /* Give up */
1739       _dbus_verbose ("%s: Disconnecting because we are out of mechanisms to try using\n",
1740                      DBUS_AUTH_NAME (auth));
1741       goto_state (auth, &common_state_need_disconnect);
1742     }
1743
1744   return TRUE;
1745 }
1746
1747
1748 static dbus_bool_t
1749 handle_client_state_waiting_for_data (DBusAuth         *auth,
1750                                       DBusAuthCommand   command,
1751                                       const DBusString *args)
1752 {
1753   _dbus_assert (auth->mech != NULL);
1754
1755   switch (command)
1756     {
1757     case DBUS_AUTH_COMMAND_DATA:
1758       return process_data (auth, args, auth->mech->client_data_func);
1759
1760     case DBUS_AUTH_COMMAND_REJECTED:
1761       return process_rejected (auth, args);
1762
1763     case DBUS_AUTH_COMMAND_OK:
1764       return send_begin (auth, args);
1765
1766     case DBUS_AUTH_COMMAND_ERROR:
1767       return send_cancel (auth);
1768
1769     case DBUS_AUTH_COMMAND_AUTH:
1770     case DBUS_AUTH_COMMAND_CANCEL:
1771     case DBUS_AUTH_COMMAND_BEGIN:
1772     case DBUS_AUTH_COMMAND_UNKNOWN:
1773     default:
1774       return send_error (auth, "Unknown command");
1775     }
1776 }
1777
1778 static dbus_bool_t
1779 handle_client_state_waiting_for_ok (DBusAuth         *auth,
1780                                     DBusAuthCommand   command,
1781                                     const DBusString *args)
1782 {
1783   switch (command)
1784     {
1785     case DBUS_AUTH_COMMAND_REJECTED:
1786       return process_rejected (auth, args);
1787
1788     case DBUS_AUTH_COMMAND_OK:
1789       return send_begin (auth, args);
1790
1791     case DBUS_AUTH_COMMAND_DATA:
1792     case DBUS_AUTH_COMMAND_ERROR:
1793       return send_cancel (auth);
1794
1795     case DBUS_AUTH_COMMAND_AUTH:
1796     case DBUS_AUTH_COMMAND_CANCEL:
1797     case DBUS_AUTH_COMMAND_BEGIN:
1798     case DBUS_AUTH_COMMAND_UNKNOWN:
1799     default:
1800       return send_error (auth, "Unknown command");
1801     }
1802 }
1803
1804 static dbus_bool_t
1805 handle_client_state_waiting_for_reject (DBusAuth         *auth,
1806                                         DBusAuthCommand   command,
1807                                         const DBusString *args)
1808 {
1809   switch (command)
1810     {
1811     case DBUS_AUTH_COMMAND_REJECTED:
1812       return process_rejected (auth, args);
1813
1814     case DBUS_AUTH_COMMAND_AUTH:
1815     case DBUS_AUTH_COMMAND_CANCEL:
1816     case DBUS_AUTH_COMMAND_DATA:
1817     case DBUS_AUTH_COMMAND_BEGIN:
1818     case DBUS_AUTH_COMMAND_OK:
1819     case DBUS_AUTH_COMMAND_ERROR:
1820     case DBUS_AUTH_COMMAND_UNKNOWN:
1821     default:
1822       goto_state (auth, &common_state_need_disconnect);
1823       return TRUE;
1824     }
1825 }
1826
1827 /**
1828  * Mapping from command name to enum
1829  */
1830 typedef struct {
1831   const char *name;        /**< Name of the command */
1832   DBusAuthCommand command; /**< Corresponding enum */
1833 } DBusAuthCommandName;
1834
1835 static DBusAuthCommandName auth_command_names[] = {
1836   { "AUTH",     DBUS_AUTH_COMMAND_AUTH },
1837   { "CANCEL",   DBUS_AUTH_COMMAND_CANCEL },
1838   { "DATA",     DBUS_AUTH_COMMAND_DATA },
1839   { "BEGIN",    DBUS_AUTH_COMMAND_BEGIN },
1840   { "REJECTED", DBUS_AUTH_COMMAND_REJECTED },
1841   { "OK",       DBUS_AUTH_COMMAND_OK },
1842   { "ERROR",    DBUS_AUTH_COMMAND_ERROR }
1843 };
1844
1845 static DBusAuthCommand
1846 lookup_command_from_name (DBusString *command)
1847 {
1848   int i;
1849
1850   for (i = 0; i < _DBUS_N_ELEMENTS (auth_command_names); i++)
1851     {
1852       if (_dbus_string_equal_c_str (command,
1853                                     auth_command_names[i].name))
1854         return auth_command_names[i].command;
1855     }
1856
1857   return DBUS_AUTH_COMMAND_UNKNOWN;
1858 }
1859
1860 static void
1861 goto_state (DBusAuth *auth, const DBusAuthStateData *state)
1862 {
1863   _dbus_verbose ("%s: going from state %s to state %s\n",
1864                  DBUS_AUTH_NAME (auth),
1865                  auth->state->name,
1866                  state->name);
1867
1868   auth->state = state;
1869 }
1870
1871 /* returns whether to call it again right away */
1872 static dbus_bool_t
1873 process_command (DBusAuth *auth)
1874 {
1875   DBusAuthCommand command;
1876   DBusString line;
1877   DBusString args;
1878   int eol;
1879   int i, j;
1880   dbus_bool_t retval;
1881
1882   /* _dbus_verbose ("%s:   trying process_command()\n"); */
1883
1884   retval = FALSE;
1885
1886   eol = 0;
1887   if (!_dbus_string_find (&auth->incoming, 0, "\r\n", &eol))
1888     return FALSE;
1889
1890   if (!_dbus_string_init (&line))
1891     {
1892       auth->needed_memory = TRUE;
1893       return FALSE;
1894     }
1895
1896   if (!_dbus_string_init (&args))
1897     {
1898       _dbus_string_free (&line);
1899       auth->needed_memory = TRUE;
1900       return FALSE;
1901     }
1902
1903   if (!_dbus_string_copy_len (&auth->incoming, 0, eol, &line, 0))
1904     goto out;
1905
1906   if (!_dbus_string_validate_ascii (&line, 0,
1907                                     _dbus_string_get_length (&line)))
1908     {
1909       _dbus_verbose ("%s: Command contained non-ASCII chars or embedded nul\n",
1910                      DBUS_AUTH_NAME (auth));
1911       if (!send_error (auth, "Command contained non-ASCII"))
1912         goto out;
1913       else
1914         goto next_command;
1915     }
1916
1917   _dbus_verbose ("%s: got command \"%s\"\n",
1918                  DBUS_AUTH_NAME (auth),
1919                  _dbus_string_get_const_data (&line));
1920
1921   _dbus_string_find_blank (&line, 0, &i);
1922   _dbus_string_skip_blank (&line, i, &j);
1923
1924   if (j > i)
1925     _dbus_string_delete (&line, i, j - i);
1926
1927   if (!_dbus_string_move (&line, i, &args, 0))
1928     goto out;
1929
1930   /* FIXME we should probably validate that only the allowed
1931    * chars are in the command name
1932    */
1933
1934   command = lookup_command_from_name (&line);
1935   if (!(* auth->state->handler) (auth, command, &args))
1936     goto out;
1937
1938  next_command:
1939
1940   /* We've succeeded in processing the whole command so drop it out
1941    * of the incoming buffer and return TRUE to try another command.
1942    */
1943
1944   _dbus_string_delete (&auth->incoming, 0, eol);
1945
1946   /* kill the \r\n */
1947   _dbus_string_delete (&auth->incoming, 0, 2);
1948
1949   retval = TRUE;
1950
1951  out:
1952   _dbus_string_free (&args);
1953   _dbus_string_free (&line);
1954
1955   if (!retval)
1956     auth->needed_memory = TRUE;
1957   else
1958     auth->needed_memory = FALSE;
1959
1960   return retval;
1961 }
1962
1963
1964 /** @} */
1965
1966 /**
1967  * @addtogroup DBusAuth
1968  * @{
1969  */
1970
1971 /**
1972  * Creates a new auth conversation object for the server side.
1973  * See doc/dbus-sasl-profile.txt for full details on what
1974  * this object does.
1975  *
1976  * @returns the new object or #NULL if no memory
1977  */
1978 DBusAuth*
1979 _dbus_auth_server_new (const DBusString *guid)
1980 {
1981   DBusAuth *auth;
1982   DBusAuthServer *server_auth;
1983   DBusString guid_copy;
1984
1985   if (!_dbus_string_init (&guid_copy))
1986     return NULL;
1987
1988   if (!_dbus_string_copy (guid, 0, &guid_copy, 0))
1989     {
1990       _dbus_string_free (&guid_copy);
1991       return NULL;
1992     }
1993
1994   auth = _dbus_auth_new (sizeof (DBusAuthServer));
1995   if (auth == NULL)
1996     {
1997       _dbus_string_free (&guid_copy);
1998       return NULL;
1999     }
2000
2001   auth->side = auth_side_server;
2002   auth->state = &server_state_waiting_for_auth;
2003
2004   server_auth = DBUS_AUTH_SERVER (auth);
2005
2006   server_auth->guid = guid_copy;
2007
2008   /* perhaps this should be per-mechanism with a lower
2009    * max
2010    */
2011   server_auth->failures = 0;
2012   server_auth->max_failures = 6;
2013
2014   return auth;
2015 }
2016
2017 /**
2018  * Creates a new auth conversation object for the client side.
2019  * See doc/dbus-sasl-profile.txt for full details on what
2020  * this object does.
2021  *
2022  * @returns the new object or #NULL if no memory
2023  */
2024 DBusAuth*
2025 _dbus_auth_client_new (void)
2026 {
2027   DBusAuth *auth;
2028   DBusString guid_str;
2029
2030   if (!_dbus_string_init (&guid_str))
2031     return NULL;
2032
2033   auth = _dbus_auth_new (sizeof (DBusAuthClient));
2034   if (auth == NULL)
2035     {
2036       _dbus_string_free (&guid_str);
2037       return NULL;
2038     }
2039
2040   DBUS_AUTH_CLIENT (auth)->guid_from_server = guid_str;
2041
2042   auth->side = auth_side_client;
2043   auth->state = &client_state_need_send_auth;
2044
2045   /* Start the auth conversation by sending AUTH for our default
2046    * mechanism */
2047   if (!send_auth (auth, &all_mechanisms[0]))
2048     {
2049       _dbus_auth_unref (auth);
2050       return NULL;
2051     }
2052
2053   return auth;
2054 }
2055
2056 /**
2057  * Increments the refcount of an auth object.
2058  *
2059  * @param auth the auth conversation
2060  * @returns the auth conversation
2061  */
2062 DBusAuth *
2063 _dbus_auth_ref (DBusAuth *auth)
2064 {
2065   _dbus_assert (auth != NULL);
2066
2067   auth->refcount += 1;
2068
2069   return auth;
2070 }
2071
2072 /**
2073  * Decrements the refcount of an auth object.
2074  *
2075  * @param auth the auth conversation
2076  */
2077 void
2078 _dbus_auth_unref (DBusAuth *auth)
2079 {
2080   _dbus_assert (auth != NULL);
2081   _dbus_assert (auth->refcount > 0);
2082
2083   auth->refcount -= 1;
2084   if (auth->refcount == 0)
2085     {
2086       shutdown_mech (auth);
2087
2088       if (DBUS_AUTH_IS_CLIENT (auth))
2089         {
2090           _dbus_string_free (& DBUS_AUTH_CLIENT (auth)->guid_from_server);
2091           _dbus_list_clear (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
2092         }
2093       else
2094         {
2095           _dbus_assert (DBUS_AUTH_IS_SERVER (auth));
2096
2097           _dbus_string_free (& DBUS_AUTH_SERVER (auth)->guid);
2098         }
2099
2100       if (auth->keyring)
2101         _dbus_keyring_unref (auth->keyring);
2102
2103       _dbus_string_free (&auth->context);
2104       _dbus_string_free (&auth->challenge);
2105       _dbus_string_free (&auth->identity);
2106       _dbus_string_free (&auth->incoming);
2107       _dbus_string_free (&auth->outgoing);
2108
2109       dbus_free_string_array (auth->allowed_mechs);
2110
2111       dbus_free (auth);
2112     }
2113 }
2114
2115 /**
2116  * Sets an array of authentication mechanism names
2117  * that we are willing to use.
2118  *
2119  * @param auth the auth conversation
2120  * @param mechanisms #NULL-terminated array of mechanism names
2121  * @returns #FALSE if no memory
2122  */
2123 dbus_bool_t
2124 _dbus_auth_set_mechanisms (DBusAuth    *auth,
2125                            const char **mechanisms)
2126 {
2127   char **copy;
2128
2129   if (mechanisms != NULL)
2130     {
2131       copy = _dbus_dup_string_array (mechanisms);
2132       if (copy == NULL)
2133         return FALSE;
2134     }
2135   else
2136     copy = NULL;
2137
2138   dbus_free_string_array (auth->allowed_mechs);
2139
2140   auth->allowed_mechs = copy;
2141
2142   return TRUE;
2143 }
2144
2145 /**
2146  * @param auth the auth conversation object
2147  * @returns #TRUE if we're in a final state
2148  */
2149 #define DBUS_AUTH_IN_END_STATE(auth) ((auth)->state->handler == NULL)
2150
2151 /**
2152  * Analyzes buffered input and moves the auth conversation forward,
2153  * returning the new state of the auth conversation.
2154  *
2155  * @param auth the auth conversation
2156  * @returns the new state
2157  */
2158 DBusAuthState
2159 _dbus_auth_do_work (DBusAuth *auth)
2160 {
2161   auth->needed_memory = FALSE;
2162
2163   /* Max amount we'll buffer up before deciding someone's on crack */
2164 #define MAX_BUFFER (16 * _DBUS_ONE_KILOBYTE)
2165
2166   do
2167     {
2168       if (DBUS_AUTH_IN_END_STATE (auth))
2169         break;
2170
2171       if (_dbus_string_get_length (&auth->incoming) > MAX_BUFFER ||
2172           _dbus_string_get_length (&auth->outgoing) > MAX_BUFFER)
2173         {
2174           goto_state (auth, &common_state_need_disconnect);
2175           _dbus_verbose ("%s: Disconnecting due to excessive data buffered in auth phase\n",
2176                          DBUS_AUTH_NAME (auth));
2177           break;
2178         }
2179     }
2180   while (process_command (auth));
2181
2182   if (auth->needed_memory)
2183     return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
2184   else if (_dbus_string_get_length (&auth->outgoing) > 0)
2185     return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
2186   else if (auth->state == &common_state_need_disconnect)
2187     return DBUS_AUTH_STATE_NEED_DISCONNECT;
2188   else if (auth->state == &common_state_authenticated)
2189     return DBUS_AUTH_STATE_AUTHENTICATED;
2190   else return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
2191 }
2192
2193 /**
2194  * Gets bytes that need to be sent to the peer we're conversing with.
2195  * After writing some bytes, _dbus_auth_bytes_sent() must be called
2196  * to notify the auth object that they were written.
2197  *
2198  * @param auth the auth conversation
2199  * @param str return location for a ref to the buffer to send
2200  * @returns #FALSE if nothing to send
2201  */
2202 dbus_bool_t
2203 _dbus_auth_get_bytes_to_send (DBusAuth          *auth,
2204                               const DBusString **str)
2205 {
2206   _dbus_assert (auth != NULL);
2207   _dbus_assert (str != NULL);
2208
2209   *str = NULL;
2210
2211   if (_dbus_string_get_length (&auth->outgoing) == 0)
2212     return FALSE;
2213
2214   *str = &auth->outgoing;
2215
2216   return TRUE;
2217 }
2218
2219 /**
2220  * Notifies the auth conversation object that
2221  * the given number of bytes of the outgoing buffer
2222  * have been written out.
2223  *
2224  * @param auth the auth conversation
2225  * @param bytes_sent number of bytes written out
2226  */
2227 void
2228 _dbus_auth_bytes_sent (DBusAuth *auth,
2229                        int       bytes_sent)
2230 {
2231   _dbus_verbose ("%s: Sent %d bytes of: %s\n",
2232                  DBUS_AUTH_NAME (auth),
2233                  bytes_sent,
2234                  _dbus_string_get_const_data (&auth->outgoing));
2235
2236   _dbus_string_delete (&auth->outgoing,
2237                        0, bytes_sent);
2238 }
2239
2240 /**
2241  * Get a buffer to be used for reading bytes from the peer we're conversing
2242  * with. Bytes should be appended to this buffer.
2243  *
2244  * @param auth the auth conversation
2245  * @param buffer return location for buffer to append bytes to
2246  */
2247 void
2248 _dbus_auth_get_buffer (DBusAuth     *auth,
2249                        DBusString **buffer)
2250 {
2251   _dbus_assert (auth != NULL);
2252   _dbus_assert (!auth->buffer_outstanding);
2253
2254   *buffer = &auth->incoming;
2255
2256   auth->buffer_outstanding = TRUE;
2257 }
2258
2259 /**
2260  * Returns a buffer with new data read into it.
2261  *
2262  * @param auth the auth conversation
2263  * @param buffer the buffer being returned
2264  * @param bytes_read number of new bytes added
2265  */
2266 void
2267 _dbus_auth_return_buffer (DBusAuth               *auth,
2268                           DBusString             *buffer,
2269                           int                     bytes_read)
2270 {
2271   _dbus_assert (buffer == &auth->incoming);
2272   _dbus_assert (auth->buffer_outstanding);
2273
2274   auth->buffer_outstanding = FALSE;
2275 }
2276
2277 /**
2278  * Returns leftover bytes that were not used as part of the auth
2279  * conversation.  These bytes will be part of the message stream
2280  * instead. This function may not be called until authentication has
2281  * succeeded.
2282  *
2283  * @param auth the auth conversation
2284  * @param str return location for pointer to string of unused bytes
2285  */
2286 void
2287 _dbus_auth_get_unused_bytes (DBusAuth           *auth,
2288                              const DBusString **str)
2289 {
2290   if (!DBUS_AUTH_IN_END_STATE (auth))
2291     return;
2292
2293   *str = &auth->incoming;
2294 }
2295
2296
2297 /**
2298  * Gets rid of unused bytes returned by _dbus_auth_get_unused_bytes()
2299  * after we've gotten them and successfully moved them elsewhere.
2300  *
2301  * @param auth the auth conversation
2302  */
2303 void
2304 _dbus_auth_delete_unused_bytes (DBusAuth *auth)
2305 {
2306   if (!DBUS_AUTH_IN_END_STATE (auth))
2307     return;
2308
2309   _dbus_string_set_length (&auth->incoming, 0);
2310 }
2311
2312 /**
2313  * Called post-authentication, indicates whether we need to encode
2314  * the message stream with _dbus_auth_encode_data() prior to
2315  * sending it to the peer.
2316  *
2317  * @param auth the auth conversation
2318  * @returns #TRUE if we need to encode the stream
2319  */
2320 dbus_bool_t
2321 _dbus_auth_needs_encoding (DBusAuth *auth)
2322 {
2323   if (auth->state != &common_state_authenticated)
2324     return FALSE;
2325
2326   if (auth->mech != NULL)
2327     {
2328       if (DBUS_AUTH_IS_CLIENT (auth))
2329         return auth->mech->client_encode_func != NULL;
2330       else
2331         return auth->mech->server_encode_func != NULL;
2332     }
2333   else
2334     return FALSE;
2335 }
2336
2337 /**
2338  * Called post-authentication, encodes a block of bytes for sending to
2339  * the peer. If no encoding was negotiated, just copies the bytes
2340  * (you can avoid this by checking _dbus_auth_needs_encoding()).
2341  *
2342  * @param auth the auth conversation
2343  * @param plaintext the plain text data
2344  * @param encoded initialized string to where encoded data is appended
2345  * @returns #TRUE if we had enough memory and successfully encoded
2346  */
2347 dbus_bool_t
2348 _dbus_auth_encode_data (DBusAuth         *auth,
2349                         const DBusString *plaintext,
2350                         DBusString       *encoded)
2351 {
2352   _dbus_assert (plaintext != encoded);
2353
2354   if (auth->state != &common_state_authenticated)
2355     return FALSE;
2356
2357   if (_dbus_auth_needs_encoding (auth))
2358     {
2359       if (DBUS_AUTH_IS_CLIENT (auth))
2360         return (* auth->mech->client_encode_func) (auth, plaintext, encoded);
2361       else
2362         return (* auth->mech->server_encode_func) (auth, plaintext, encoded);
2363     }
2364   else
2365     {
2366       return _dbus_string_copy (plaintext, 0, encoded,
2367                                 _dbus_string_get_length (encoded));
2368     }
2369 }
2370
2371 /**
2372  * Called post-authentication, indicates whether we need to decode
2373  * the message stream with _dbus_auth_decode_data() after
2374  * receiving it from the peer.
2375  *
2376  * @param auth the auth conversation
2377  * @returns #TRUE if we need to encode the stream
2378  */
2379 dbus_bool_t
2380 _dbus_auth_needs_decoding (DBusAuth *auth)
2381 {
2382   if (auth->state != &common_state_authenticated)
2383     return FALSE;
2384
2385   if (auth->mech != NULL)
2386     {
2387       if (DBUS_AUTH_IS_CLIENT (auth))
2388         return auth->mech->client_decode_func != NULL;
2389       else
2390         return auth->mech->server_decode_func != NULL;
2391     }
2392   else
2393     return FALSE;
2394 }
2395
2396
2397 /**
2398  * Called post-authentication, decodes a block of bytes received from
2399  * the peer. If no encoding was negotiated, just copies the bytes (you
2400  * can avoid this by checking _dbus_auth_needs_decoding()).
2401  *
2402  * @todo We need to be able to distinguish "out of memory" error
2403  * from "the data is hosed" error.
2404  *
2405  * @param auth the auth conversation
2406  * @param encoded the encoded data
2407  * @param plaintext initialized string where decoded data is appended
2408  * @returns #TRUE if we had enough memory and successfully decoded
2409  */
2410 dbus_bool_t
2411 _dbus_auth_decode_data (DBusAuth         *auth,
2412                         const DBusString *encoded,
2413                         DBusString       *plaintext)
2414 {
2415   _dbus_assert (plaintext != encoded);
2416
2417   if (auth->state != &common_state_authenticated)
2418     return FALSE;
2419
2420   if (_dbus_auth_needs_decoding (auth))
2421     {
2422       if (DBUS_AUTH_IS_CLIENT (auth))
2423         return (* auth->mech->client_decode_func) (auth, encoded, plaintext);
2424       else
2425         return (* auth->mech->server_decode_func) (auth, encoded, plaintext);
2426     }
2427   else
2428     {
2429       return _dbus_string_copy (encoded, 0, plaintext,
2430                                 _dbus_string_get_length (plaintext));
2431     }
2432 }
2433
2434 /**
2435  * Sets credentials received via reliable means from the operating
2436  * system.
2437  *
2438  * @param auth the auth conversation
2439  * @param credentials the credentials received
2440  */
2441 void
2442 _dbus_auth_set_credentials (DBusAuth               *auth,
2443                             const DBusCredentials  *credentials)
2444 {
2445   auth->credentials = *credentials;
2446 }
2447
2448 /**
2449  * Gets the identity we authorized the client as.  Apps may have
2450  * different policies as to what identities they allow.
2451  *
2452  * @param auth the auth conversation
2453  * @param credentials the credentials we've authorized
2454  */
2455 void
2456 _dbus_auth_get_identity (DBusAuth               *auth,
2457                          DBusCredentials        *credentials)
2458 {
2459   if (auth->state == &common_state_authenticated)
2460     *credentials = auth->authorized_identity;
2461   else
2462     _dbus_credentials_clear (credentials);
2463 }
2464
2465 /**
2466  * Gets the GUID from the server if we've authenticated; gets
2467  * #NULL otherwise.
2468  * @param auth the auth object
2469  * @returns the GUID in ASCII hex format
2470  */
2471 const char*
2472 _dbus_auth_get_guid_from_server (DBusAuth *auth)
2473 {
2474   _dbus_assert (DBUS_AUTH_IS_CLIENT (auth));
2475
2476   if (auth->state == &common_state_authenticated)
2477     return _dbus_string_get_const_data (& DBUS_AUTH_CLIENT (auth)->guid_from_server);
2478   else
2479     return NULL;
2480 }
2481
2482 /**
2483  * Sets the "authentication context" which scopes cookies
2484  * with the DBUS_COOKIE_SHA1 auth mechanism for example.
2485  *
2486  * @param auth the auth conversation
2487  * @param context the context
2488  * @returns #FALSE if no memory
2489  */
2490 dbus_bool_t
2491 _dbus_auth_set_context (DBusAuth               *auth,
2492                         const DBusString       *context)
2493 {
2494   return _dbus_string_replace_len (context, 0, _dbus_string_get_length (context),
2495                                    &auth->context, 0, _dbus_string_get_length (context));
2496 }
2497
2498 /** @} */
2499
2500 /* tests in dbus-auth-util.c */