dbus/dbus-auth.c

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