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
  28 /* See doc/dbus-sasl-profile.txt */
  29
  30 /**
  31  * @defgroup DBusAuth Authentication
  32  * @ingroup  DBusInternals
  33  * @brief DBusAuth object
  34  *
  35  * DBusAuth manages the authentication negotiation when a connection
  36  * is first established, and also manage any encryption used over a
  37  * connection.
  38  *
  39  * The file doc/dbus-sasl-profile.txt documents the network protocol
  40  * used for authentication.
  41  *
  42  * @todo some SASL profiles require sending the empty string as a
  43  * challenge/response, but we don't currently allow that in our
  44  * protocol.
  45  */
  46
  47 /**
  48  * @defgroup DBusAuthInternals Authentication implementation details
  49  * @ingroup  DBusInternals
  50  * @brief DBusAuth implementation details
  51  *
  52  * Private details of authentication code.
  53  *
  54  * @{
  55  */
  56
  57 /**
  58  * Processes a command. Returns whether we had enough memory to
  59  * complete the operation.
  60  */
  61 typedef dbus_bool_t (* DBusProcessAuthCommandFunction) (DBusAuth         *auth,
  62                                                         const DBusString *command,
  63                                                         const DBusString *args);
  64
  65 typedef struct
  66 {
  67   const char *command;
  68   DBusProcessAuthCommandFunction func;
  69 } DBusAuthCommandHandler;
  70
  71 /**
  72  * This function appends an initial client response to the given string
  73  */
  74 typedef dbus_bool_t (* DBusInitialResponseFunction)  (DBusAuth         *auth,
  75                                                       DBusString       *response);
  76
  77 /**
  78  * This function processes a block of data received from the peer.
  79  * i.e. handles a DATA command.
  80  */
  81 typedef dbus_bool_t (* DBusAuthDataFunction)     (DBusAuth         *auth,
  82                                                   const DBusString *data);
  83
  84 /**
  85  * This function encodes a block of data from the peer.
  86  */
  87 typedef dbus_bool_t (* DBusAuthEncodeFunction)   (DBusAuth         *auth,
  88                                                   const DBusString *data,
  89                                                   DBusString       *encoded);
  90
  91 /**
  92  * This function decodes a block of data from the peer.
  93  */
  94 typedef dbus_bool_t (* DBusAuthDecodeFunction)   (DBusAuth         *auth,
  95                                                   const DBusString *data,
  96                                                   DBusString       *decoded);
  97
  98 /**
  99  * This function is called when the mechanism is abandoned.
 100  */
 101 typedef void        (* DBusAuthShutdownFunction) (DBusAuth       *auth);
 102
 103 typedef struct
 104 {
 105   const char *mechanism;
 106   DBusAuthDataFunction server_data_func;
 107   DBusAuthEncodeFunction server_encode_func;
 108   DBusAuthDecodeFunction server_decode_func;
 109   DBusAuthShutdownFunction server_shutdown_func;
 110   DBusInitialResponseFunction client_initial_response_func;
 111   DBusAuthDataFunction client_data_func;
 112   DBusAuthEncodeFunction client_encode_func;
 113   DBusAuthDecodeFunction client_decode_func;
 114   DBusAuthShutdownFunction client_shutdown_func;
 115 } DBusAuthMechanismHandler;
 116
 117 /**
 118  * Internal members of DBusAuth.
 119  */
 120 struct DBusAuth
 121 {
 122   int refcount;           /**< reference count */
 123
 124   DBusString incoming;    /**< Incoming data buffer */
 125   DBusString outgoing;    /**< Outgoing data buffer */
 126
 127   const DBusAuthCommandHandler *handlers; /**< Handlers for commands */
 128
 129   const DBusAuthMechanismHandler *mech;   /**< Current auth mechanism */
 130
 131   DBusString identity;                   /**< Current identity we're authorizing
 132                                           *   as.
 133                                           */
 134
 135   DBusCredentials credentials;      /**< Credentials, fields may be -1 */
 136
 137   DBusCredentials authorized_identity; /**< Credentials that are authorized */
 138
 139   unsigned int needed_memory : 1;   /**< We needed memory to continue since last
 140                                      * successful getting something done
 141                                      */
 142   unsigned int need_disconnect : 1; /**< We've given up, time to disconnect */
 143   unsigned int authenticated : 1;   /**< We are authenticated */
 144   unsigned int authenticated_pending_output : 1; /**< Authenticated once we clear outgoing buffer */
 145   unsigned int authenticated_pending_begin : 1;  /**< Authenticated once we get BEGIN */
 146   unsigned int already_got_mechanisms : 1;       /**< Client already got mech list */
 147   unsigned int already_asked_for_initial_response : 1; /**< Already sent a blank challenge to get an initial response */
 148 };
 149
 150 typedef struct
 151 {
 152   DBusAuth base;
 153
 154   DBusList *mechs_to_try; /**< Mechanisms we got from the server that we're going to try using */
 155
 156 } DBusAuthClient;
 157
 158 typedef struct
 159 {
 160   DBusAuth base;
 161
 162   int failures;     /**< Number of times client has been rejected */
 163   int max_failures; /**< Number of times we reject before disconnect */
 164
 165 } DBusAuthServer;
 166
 167 static dbus_bool_t process_auth         (DBusAuth         *auth,
 168                                          const DBusString *command,
 169                                          const DBusString *args);
 170 static dbus_bool_t process_cancel       (DBusAuth         *auth,
 171                                          const DBusString *command,
 172                                          const DBusString *args);
 173 static dbus_bool_t process_begin        (DBusAuth         *auth,
 174                                          const DBusString *command,
 175                                          const DBusString *args);
 176 static dbus_bool_t process_data_server  (DBusAuth         *auth,
 177                                          const DBusString *command,
 178                                          const DBusString *args);
 179 static dbus_bool_t process_error_server (DBusAuth         *auth,
 180                                          const DBusString *command,
 181                                          const DBusString *args);
 182 static dbus_bool_t process_rejected     (DBusAuth         *auth,
 183                                          const DBusString *command,
 184                                          const DBusString *args);
 185 static dbus_bool_t process_ok           (DBusAuth         *auth,
 186                                          const DBusString *command,
 187                                          const DBusString *args);
 188 static dbus_bool_t process_data_client  (DBusAuth         *auth,
 189                                          const DBusString *command,
 190                                          const DBusString *args);
 191 static dbus_bool_t process_error_client (DBusAuth         *auth,
 192                                          const DBusString *command,
 193                                          const DBusString *args);
 194
 195
 196 static dbus_bool_t client_try_next_mechanism (DBusAuth *auth);
 197 static dbus_bool_t send_rejected             (DBusAuth *auth);
 198
 199 static DBusAuthCommandHandler
 200 server_handlers[] = {
 201   { "AUTH", process_auth },
 202   { "CANCEL", process_cancel },
 203   { "BEGIN", process_begin },
 204   { "DATA", process_data_server },
 205   { "ERROR", process_error_server },
 206   { NULL, NULL }
 207 };
 208
 209 static DBusAuthCommandHandler
 210 client_handlers[] = {
 211   { "REJECTED", process_rejected },
 212   { "OK", process_ok },
 213   { "DATA", process_data_client },
 214   { "ERROR", process_error_client },
 215   { NULL, NULL }
 216 };
 217
 218 /**
 219  * @param auth the auth conversation
 220  * @returns #TRUE if the conversation is the server side
 221  */
 222 #define DBUS_AUTH_IS_SERVER(auth) ((auth)->handlers == server_handlers)
 223 /**
 224  * @param auth the auth conversation
 225  * @returns #TRUE if the conversation is the client side
 226  */
 227 #define DBUS_AUTH_IS_CLIENT(auth) ((auth)->handlers == client_handlers)
 228 /**
 229  * @param auth the auth conversation
 230  * @returns auth cast to DBusAuthClient
 231  */
 232 #define DBUS_AUTH_CLIENT(auth)    ((DBusAuthClient*)(auth))
 233 /**
 234  * @param auth the auth conversation
 235  * @returns auth cast to DBusAuthServer
 236  */
 237 #define DBUS_AUTH_SERVER(auth)    ((DBusAuthServer*)(auth))
 238
 239 static DBusAuth*
 240 _dbus_auth_new (int size)
 241 {
 242   DBusAuth *auth;
 243
 244   auth = dbus_malloc0 (size);
 245   if (auth == NULL)
 246     return NULL;
 247
 248   auth->refcount = 1;
 249
 250   auth->credentials.pid = -1;
 251   auth->credentials.uid = -1;
 252   auth->credentials.gid = -1;
 253
 254   auth->authorized_identity.pid = -1;
 255   auth->authorized_identity.uid = -1;
 256   auth->authorized_identity.gid = -1;
 257
 258   /* note that we don't use the max string length feature,
 259    * because you can't use that feature if you're going to
 260    * try to recover from out-of-memory (it creates
 261    * what looks like unrecoverable inability to alloc
 262    * more space in the string). But we do handle
 263    * overlong buffers in _dbus_auth_do_work().
 264    */
 265
 266   if (!_dbus_string_init (&auth->incoming, _DBUS_INT_MAX))
 267     {
 268       dbus_free (auth);
 269       return NULL;
 270     }
 271
 272   if (!_dbus_string_init (&auth->outgoing, _DBUS_INT_MAX))
 273     {
 274       _dbus_string_free (&auth->incoming);
 275       dbus_free (auth);
 276       return NULL;
 277     }
 278
 279   if (!_dbus_string_init (&auth->identity, _DBUS_INT_MAX))
 280     {
 281       _dbus_string_free (&auth->incoming);
 282       _dbus_string_free (&auth->outgoing);
 283       dbus_free (auth);
 284       return NULL;
 285     }
 286
 287   return auth;
 288 }
 289
 290 static void
 291 shutdown_mech (DBusAuth *auth)
 292 {
 293   /* Cancel any auth */
 294   auth->authenticated_pending_begin = FALSE;
 295   auth->authenticated = FALSE;
 296   auth->already_asked_for_initial_response = FALSE;
 297   _dbus_string_set_length (&auth->identity, 0);
 298   auth->authorized_identity.pid = -1;
 299   auth->authorized_identity.uid = -1;
 300   auth->authorized_identity.gid = -1;
 301
 302   if (auth->mech != NULL)
 303     {
 304       _dbus_verbose ("Shutting down mechanism %s\n",
 305                      auth->mech->mechanism);
 306
 307       if (DBUS_AUTH_IS_CLIENT (auth))
 308         (* auth->mech->client_shutdown_func) (auth);
 309       else
 310         (* auth->mech->server_shutdown_func) (auth);
 311
 312       auth->mech = NULL;
 313     }
 314 }
 315
 316 static dbus_bool_t
 317 handle_server_data_stupid_test_mech (DBusAuth         *auth,
 318                                      const DBusString *data)
 319 {
 320   if (!_dbus_string_append (&auth->outgoing,
 321                             "OK\r\n"))
 322     return FALSE;
 323
 324   auth->authenticated_pending_begin = TRUE;
 325
 326   return TRUE;
 327 }
 328
 329 static void
 330 handle_server_shutdown_stupid_test_mech (DBusAuth *auth)
 331 {
 332
 333 }
 334
 335 static dbus_bool_t
 336 handle_client_data_stupid_test_mech (DBusAuth         *auth,
 337                                      const DBusString *data)
 338 {
 339
 340   return TRUE;
 341 }
 342
 343 static void
 344 handle_client_shutdown_stupid_test_mech (DBusAuth *auth)
 345 {
 346
 347 }
 348
 349 /* the stupid test mech is a base64-encoded string;
 350  * all the inefficiency, none of the security!
 351  */
 352 static dbus_bool_t
 353 handle_encode_stupid_test_mech (DBusAuth         *auth,
 354                                 const DBusString *plaintext,
 355                                 DBusString       *encoded)
 356 {
 357   if (!_dbus_string_base64_encode (plaintext, 0, encoded,
 358                                    _dbus_string_get_length (encoded)))
 359     return FALSE;
 360
 361   return TRUE;
 362 }
 363
 364 static dbus_bool_t
 365 handle_decode_stupid_test_mech (DBusAuth         *auth,
 366                                 const DBusString *encoded,
 367                                 DBusString       *plaintext)
 368 {
 369   if (!_dbus_string_base64_decode (encoded, 0, plaintext,
 370                                    _dbus_string_get_length (plaintext)))
 371     return FALSE;
 372
 373   return TRUE;
 374 }
 375
 376 static dbus_bool_t
 377 handle_server_data_external_mech (DBusAuth         *auth,
 378                                   const DBusString *data)
 379 {
 380   DBusCredentials desired_identity;
 381
 382   if (auth->credentials.uid < 0)
 383     {
 384       _dbus_verbose ("no credentials, mechanism EXTERNAL can't authenticate\n");
 385       return send_rejected (auth);
 386     }
 387
 388   if (_dbus_string_get_length (data) > 0)
 389     {
 390       if (_dbus_string_get_length (&auth->identity) > 0)
 391         {
 392           /* Tried to send two auth identities, wtf */
 393           _dbus_verbose ("client tried to send auth identity, but we already have one\n");
 394           return send_rejected (auth);
 395         }
 396       else
 397         {
 398           /* this is our auth identity */
 399           if (!_dbus_string_copy (data, 0, &auth->identity, 0))
 400             return FALSE;
 401         }
 402     }
 403
 404   /* Poke client for an auth identity, if none given */
 405   if (_dbus_string_get_length (&auth->identity) == 0 &&
 406       !auth->already_asked_for_initial_response)
 407     {
 408       if (_dbus_string_append (&auth->outgoing,
 409                                "DATA\r\n"))
 410         {
 411           _dbus_verbose ("sending empty challenge asking client for auth identity\n");
 412           auth->already_asked_for_initial_response = TRUE;
 413           return TRUE;
 414         }
 415       else
 416         return FALSE;
 417     }
 418
 419   desired_identity.pid = -1;
 420   desired_identity.uid = -1;
 421   desired_identity.gid = -1;
 422
 423   /* If auth->identity is still empty here, then client
 424    * responded with an empty string after we poked it for
 425    * an initial response. This means to try to auth the
 426    * identity provided in the credentials.
 427    */
 428   if (_dbus_string_get_length (&auth->identity) == 0)
 429     {
 430       desired_identity.uid = auth->credentials.uid;
 431     }
 432   else
 433     {
 434       if (!_dbus_credentials_from_uid_string (&auth->identity,
 435                                               &desired_identity))
 436         {
 437           _dbus_verbose ("could not get credentials from uid string\n");
 438           return send_rejected (auth);
 439         }
 440     }
 441
 442   if (desired_identity.uid < 0)
 443     {
 444       _dbus_verbose ("desired UID %d is no good\n", desired_identity.uid);
 445       return send_rejected (auth);
 446     }
 447
 448   if (_dbus_credentials_match (&desired_identity,
 449                                &auth->credentials))
 450     {
 451       /* client has authenticated */
 452       _dbus_verbose ("authenticated client with UID %d matching socket credentials UID %d\n",
 453                      desired_identity.uid,
 454                      auth->credentials.uid);
 455
 456       if (!_dbus_string_append (&auth->outgoing,
 457                                 "OK\r\n"))
 458         return FALSE;
 459
 460       auth->authorized_identity.uid = desired_identity.uid;
 461
 462       auth->authenticated_pending_begin = TRUE;
 463
 464       return TRUE;
 465     }
 466   else
 467     {
 468       _dbus_verbose ("credentials uid=%d gid=%d do not allow uid=%d gid=%d\n",
 469                      auth->credentials.uid, auth->credentials.gid,
 470                      desired_identity.uid, desired_identity.gid);
 471       return send_rejected (auth);
 472     }
 473 }
 474
 475 static void
 476 handle_server_shutdown_external_mech (DBusAuth *auth)
 477 {
 478
 479 }
 480
 481 static dbus_bool_t
 482 handle_client_initial_response_external_mech (DBusAuth         *auth,
 483                                               DBusString       *response)
 484 {
 485   /* We always append our UID as an initial response, so the server
 486    * doesn't have to send back an empty challenge to check whether we
 487    * want to specify an identity. i.e. this avoids a round trip that
 488    * the spec for the EXTERNAL mechanism otherwise requires.
 489    */
 490   DBusString plaintext;
 491
 492   if (!_dbus_string_init (&plaintext, _DBUS_INT_MAX))
 493     return FALSE;
 494
 495   if (!_dbus_string_append_our_uid (&plaintext))
 496     goto failed;
 497
 498   if (!_dbus_string_base64_encode (&plaintext, 0,
 499                                    response,
 500                                    _dbus_string_get_length (response)))
 501     goto failed;
 502
 503   _dbus_string_free (&plaintext);
 504
 505   return TRUE;
 506
 507  failed:
 508   _dbus_string_free (&plaintext);
 509   return FALSE;
 510 }
 511
 512 static dbus_bool_t
 513 handle_client_data_external_mech (DBusAuth         *auth,
 514                                   const DBusString *data)
 515 {
 516
 517   return TRUE;
 518 }
 519
 520 static void
 521 handle_client_shutdown_external_mech (DBusAuth *auth)
 522 {
 523
 524 }
 525
 526 /* Put mechanisms here in order of preference.
 527  * What I eventually want to have is:
 528  *
 529  *  - a mechanism that checks UNIX domain socket credentials
 530  *  - a simple magic cookie mechanism like X11 or ICE
 531  *  - mechanisms that chain to Cyrus SASL, so we can use anything it
 532  *    offers such as Kerberos, X509, whatever.
 533  *
 534  */
 535 static const DBusAuthMechanismHandler
 536 all_mechanisms[] = {
 537   { "EXTERNAL",
 538     handle_server_data_external_mech,
 539     NULL, NULL,
 540     handle_server_shutdown_external_mech,
 541     handle_client_initial_response_external_mech,
 542     handle_client_data_external_mech,
 543     NULL, NULL,
 544     handle_client_shutdown_external_mech },
 545   /* Obviously this has to die for production use */
 546   { "DBUS_STUPID_TEST_MECH",
 547     handle_server_data_stupid_test_mech,
 548     handle_encode_stupid_test_mech,
 549     handle_decode_stupid_test_mech,
 550     handle_server_shutdown_stupid_test_mech,
 551     NULL,
 552     handle_client_data_stupid_test_mech,
 553     handle_encode_stupid_test_mech,
 554     handle_decode_stupid_test_mech,
 555     handle_client_shutdown_stupid_test_mech },
 556   { NULL, NULL }
 557 };
 558
 559 static const DBusAuthMechanismHandler*
 560 find_mech (const DBusString *name)
 561 {
 562   int i;
 563
 564   i = 0;
 565   while (all_mechanisms[i].mechanism != NULL)
 566     {
 567       if (_dbus_string_equal_c_str (name,
 568                                     all_mechanisms[i].mechanism))
 569
 570         return &all_mechanisms[i];
 571
 572       ++i;
 573     }
 574
 575   return NULL;
 576 }
 577
 578 static dbus_bool_t
 579 send_rejected (DBusAuth *auth)
 580 {
 581   DBusString command;
 582   DBusAuthServer *server_auth;
 583   int i;
 584
 585   if (!_dbus_string_init (&command, _DBUS_INT_MAX))
 586     return FALSE;
 587
 588   if (!_dbus_string_append (&command,
 589                             "REJECTED"))
 590     goto nomem;
 591
 592   i = 0;
 593   while (all_mechanisms[i].mechanism != NULL)
 594     {
 595       if (!_dbus_string_append (&command,
 596                                 " "))
 597         goto nomem;
 598
 599       if (!_dbus_string_append (&command,
 600                                 all_mechanisms[i].mechanism))
 601         goto nomem;
 602
 603       ++i;
 604     }
 605
 606   if (!_dbus_string_append (&command, "\r\n"))
 607     goto nomem;
 608
 609   if (!_dbus_string_copy (&command, 0, &auth->outgoing,
 610                           _dbus_string_get_length (&auth->outgoing)))
 611     goto nomem;
 612
 613   shutdown_mech (auth);
 614
 615   _dbus_assert (DBUS_AUTH_IS_SERVER (auth));
 616   server_auth = DBUS_AUTH_SERVER (auth);
 617   server_auth->failures += 1;
 618
 619   return TRUE;
 620
 621  nomem:
 622   _dbus_string_free (&command);
 623   return FALSE;
 624 }
 625
 626 static dbus_bool_t
 627 process_auth (DBusAuth         *auth,
 628               const DBusString *command,
 629               const DBusString *args)
 630 {
 631   if (auth->mech)
 632     {
 633       /* We are already using a mechanism, client is on crack */
 634       if (!_dbus_string_append (&auth->outgoing,
 635                                 "ERROR \"Sent AUTH while another AUTH in progress\"\r\n"))
 636         return FALSE;
 637
 638       return TRUE;
 639     }
 640   else if (_dbus_string_get_length (args) == 0)
 641     {
 642       /* No args to the auth, send mechanisms */
 643       if (!send_rejected (auth))
 644         return FALSE;
 645
 646       return TRUE;
 647     }
 648   else
 649     {
 650       int i;
 651       DBusString mech;
 652       DBusString base64_response;
 653       DBusString decoded_response;
 654
 655       _dbus_string_find_blank (args, 0, &i);
 656
 657       if (!_dbus_string_init (&mech, _DBUS_INT_MAX))
 658         return FALSE;
 659
 660       if (!_dbus_string_init (&base64_response, _DBUS_INT_MAX))
 661         {
 662           _dbus_string_free (&mech);
 663           return FALSE;
 664         }
 665
 666       if (!_dbus_string_init (&decoded_response, _DBUS_INT_MAX))
 667         {
 668           _dbus_string_free (&mech);
 669           _dbus_string_free (&base64_response);
 670           return FALSE;
 671         }
 672
 673       if (!_dbus_string_copy_len (args, 0, i, &mech, 0))
 674         goto failed;
 675
 676       if (!_dbus_string_copy (args, i, &base64_response, 0))
 677         goto failed;
 678
 679       if (!_dbus_string_base64_decode (&base64_response, 0,
 680                                        &decoded_response, 0))
 681         goto failed;
 682
 683       auth->mech = find_mech (&mech);
 684       if (auth->mech != NULL)
 685         {
 686           _dbus_verbose ("Trying mechanism %s with initial response of %d bytes\n",
 687                          auth->mech->mechanism,
 688                          _dbus_string_get_length (&decoded_response));
 689
 690           if (!(* auth->mech->server_data_func) (auth,
 691                                                  &decoded_response))
 692             goto failed;
 693         }
 694       else
 695         {
 696           /* Unsupported mechanism */
 697           if (!send_rejected (auth))
 698             return FALSE;
 699         }
 700
 701       _dbus_string_free (&mech);
 702       _dbus_string_free (&base64_response);
 703       _dbus_string_free (&decoded_response);
 704
 705       return TRUE;
 706
 707     failed:
 708       auth->mech = NULL;
 709       _dbus_string_free (&mech);
 710       _dbus_string_free (&base64_response);
 711       _dbus_string_free (&decoded_response);
 712       return FALSE;
 713     }
 714 }
 715
 716 static dbus_bool_t
 717 process_cancel (DBusAuth         *auth,
 718                 const DBusString *command,
 719                 const DBusString *args)
 720 {
 721   shutdown_mech (auth);
 722
 723   return TRUE;
 724 }
 725
 726 static dbus_bool_t
 727 process_begin (DBusAuth         *auth,
 728                const DBusString *command,
 729                const DBusString *args)
 730 {
 731   if (auth->authenticated_pending_begin)
 732     auth->authenticated = TRUE;
 733   else
 734     {
 735       auth->need_disconnect = TRUE; /* client trying to send data before auth,
 736                                      * kick it
 737                                      */
 738       shutdown_mech (auth);
 739     }
 740
 741   return TRUE;
 742 }
 743
 744 static dbus_bool_t
 745 process_data_server (DBusAuth         *auth,
 746                      const DBusString *command,
 747                      const DBusString *args)
 748 {
 749   if (auth->mech != NULL)
 750     {
 751       DBusString decoded;
 752
 753       if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
 754         return FALSE;
 755
 756       if (!_dbus_string_base64_decode (args, 0, &decoded, 0))
 757         {
 758           _dbus_string_free (&decoded);
 759           return FALSE;
 760         }
 761
 762       if (!(* auth->mech->server_data_func) (auth, &decoded))
 763         {
 764           _dbus_string_free (&decoded);
 765           return FALSE;
 766         }
 767
 768       _dbus_string_free (&decoded);
 769     }
 770   else
 771     {
 772       if (!_dbus_string_append (&auth->outgoing,
 773                                 "ERROR \"Not currently in an auth conversation\"\r\n"))
 774         return FALSE;
 775     }
 776
 777   return TRUE;
 778 }
 779
 780 static dbus_bool_t
 781 process_error_server (DBusAuth         *auth,
 782                       const DBusString *command,
 783                       const DBusString *args)
 784 {
 785
 786   return TRUE;
 787 }
 788
 789 /* return FALSE if no memory, TRUE if all OK */
 790 static dbus_bool_t
 791 get_word (const DBusString *str,
 792           int              *start,
 793           DBusString       *word)
 794 {
 795   int i;
 796
 797   _dbus_string_skip_blank (str, *start, start);
 798   _dbus_string_find_blank (str, *start, &i);
 799
 800   if (i > *start)
 801     {
 802       if (!_dbus_string_copy_len (str, *start, i, word, 0))
 803         return FALSE;
 804
 805       *start = i;
 806     }
 807
 808   return TRUE;
 809 }
 810
 811 static dbus_bool_t
 812 record_mechanisms (DBusAuth         *auth,
 813                    const DBusString *command,
 814                    const DBusString *args)
 815 {
 816   int next;
 817   int len;
 818
 819   if (auth->already_got_mechanisms)
 820     return TRUE;
 821
 822   len = _dbus_string_get_length (args);
 823
 824   next = 0;
 825   while (next < len)
 826     {
 827       DBusString m;
 828       const DBusAuthMechanismHandler *mech;
 829
 830       if (!_dbus_string_init (&m, _DBUS_INT_MAX))
 831         goto nomem;
 832
 833       if (!get_word (args, &next, &m))
 834         goto nomem;
 835
 836       mech = find_mech (&m);
 837
 838       if (mech != NULL)
 839         {
 840           /* FIXME right now we try mechanisms in the order
 841            * the server lists them; should we do them in
 842            * some more deterministic order?
 843            *
 844            * Probably in all_mechanisms order, our order of
 845            * preference. Of course when the server is us,
 846            * it lists things in that order anyhow.
 847            */
 848
 849           _dbus_verbose ("Adding mechanism %s to list we will try\n",
 850                          mech->mechanism);
 851
 852           if (!_dbus_list_append (& DBUS_AUTH_CLIENT (auth)->mechs_to_try,
 853                                   (void*) mech))
 854             goto nomem;
 855         }
 856       else
 857         {
 858           const char *s;
 859
 860           _dbus_string_get_const_data (&m, &s);
 861           _dbus_verbose ("Server offered mechanism \"%s\" that we don't know how to use\n",
 862                          s);
 863         }
 864
 865       _dbus_string_free (&m);
 866     }
 867
 868   auth->already_got_mechanisms = TRUE;
 869
 870   return TRUE;
 871
 872  nomem:
 873   _dbus_list_clear (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
 874
 875   return FALSE;
 876 }
 877
 878 static dbus_bool_t
 879 client_try_next_mechanism (DBusAuth *auth)
 880 {
 881   const DBusAuthMechanismHandler *mech;
 882   DBusString auth_command;
 883
 884   if (DBUS_AUTH_CLIENT (auth)->mechs_to_try == NULL)
 885     return FALSE;
 886
 887   mech = DBUS_AUTH_CLIENT (auth)->mechs_to_try->data;
 888
 889   if (!_dbus_string_init (&auth_command, _DBUS_INT_MAX))
 890     return FALSE;
 891
 892   if (!_dbus_string_append (&auth_command,
 893                             "AUTH "))
 894     {
 895       _dbus_string_free (&auth_command);
 896       return FALSE;
 897     }
 898
 899   if (!_dbus_string_append (&auth_command,
 900                             mech->mechanism))
 901     {
 902       _dbus_string_free (&auth_command);
 903       return FALSE;
 904     }
 905
 906   if (mech->client_initial_response_func != NULL)
 907     {
 908       if (!_dbus_string_append (&auth_command, " "))
 909         {
 910           _dbus_string_free (&auth_command);
 911           return FALSE;
 912         }
 913
 914       if (!(* mech->client_initial_response_func) (auth, &auth_command))
 915         {
 916           _dbus_string_free (&auth_command);
 917           return FALSE;
 918         }
 919     }
 920
 921   if (!_dbus_string_append (&auth_command,
 922                             "\r\n"))
 923     {
 924       _dbus_string_free (&auth_command);
 925       return FALSE;
 926     }
 927
 928   if (!_dbus_string_copy (&auth_command, 0,
 929                           &auth->outgoing,
 930                           _dbus_string_get_length (&auth->outgoing)))
 931     {
 932       _dbus_string_free (&auth_command);
 933       return FALSE;
 934     }
 935
 936   auth->mech = mech;
 937   _dbus_list_pop_first (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
 938
 939   _dbus_verbose ("Trying mechanism %s\n",
 940                  auth->mech->mechanism);
 941
 942   return TRUE;
 943 }
 944
 945 static dbus_bool_t
 946 process_rejected (DBusAuth         *auth,
 947                   const DBusString *command,
 948                   const DBusString *args)
 949 {
 950   shutdown_mech (auth);
 951
 952   if (!auth->already_got_mechanisms)
 953     {
 954       if (!record_mechanisms (auth, command, args))
 955         return FALSE;
 956     }
 957
 958   if (DBUS_AUTH_CLIENT (auth)->mechs_to_try != NULL)
 959     {
 960       client_try_next_mechanism (auth);
 961     }
 962   else
 963     {
 964       /* Give up */
 965       auth->need_disconnect = TRUE;
 966     }
 967
 968   return TRUE;
 969 }
 970
 971 static dbus_bool_t
 972 process_ok (DBusAuth         *auth,
 973             const DBusString *command,
 974             const DBusString *args)
 975 {
 976   if (!_dbus_string_append (&auth->outgoing,
 977                             "BEGIN\r\n"))
 978     return FALSE;
 979
 980   auth->authenticated_pending_output = TRUE;
 981
 982   return TRUE;
 983 }
 984
 985
 986 static dbus_bool_t
 987 process_data_client (DBusAuth         *auth,
 988                      const DBusString *command,
 989                      const DBusString *args)
 990 {
 991   if (auth->mech != NULL)
 992     {
 993       DBusString decoded;
 994
 995       if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
 996         return FALSE;
 997
 998       if (!_dbus_string_base64_decode (args, 0, &decoded, 0))
 999         {
1000           _dbus_string_free (&decoded);
1001           return FALSE;
1002         }
1003
1004       if (!(* auth->mech->client_data_func) (auth, &decoded))
1005         {
1006           _dbus_string_free (&decoded);
1007           return FALSE;
1008         }
1009
1010       _dbus_string_free (&decoded);
1011     }
1012   else
1013     {
1014       if (!_dbus_string_append (&auth->outgoing,
1015                                 "ERROR \"Got DATA when not in an auth exchange\"\r\n"))
1016         return FALSE;
1017     }
1018
1019   return TRUE;
1020 }
1021
1022 static dbus_bool_t
1023 process_error_client (DBusAuth         *auth,
1024                       const DBusString *command,
1025                       const DBusString *args)
1026 {
1027   return TRUE;
1028 }
1029
1030 static dbus_bool_t
1031 process_unknown (DBusAuth         *auth,
1032                  const DBusString *command,
1033                  const DBusString *args)
1034 {
1035   if (!_dbus_string_append (&auth->outgoing,
1036                             "ERROR \"Unknown command\"\r\n"))
1037     return FALSE;
1038
1039   return TRUE;
1040 }
1041
1042 /* returns whether to call it again right away */
1043 static dbus_bool_t
1044 process_command (DBusAuth *auth)
1045 {
1046   DBusString command;
1047   DBusString args;
1048   int eol;
1049   int i, j;
1050   dbus_bool_t retval;
1051
1052   /* _dbus_verbose ("  trying process_command()\n"); */
1053
1054   retval = FALSE;
1055
1056   eol = 0;
1057   if (!_dbus_string_find (&auth->incoming, 0, "\r\n", &eol))
1058     return FALSE;
1059
1060   if (!_dbus_string_init (&command, _DBUS_INT_MAX))
1061     {
1062       auth->needed_memory = TRUE;
1063       return FALSE;
1064     }
1065
1066   if (!_dbus_string_init (&args, _DBUS_INT_MAX))
1067     {
1068       auth->needed_memory = TRUE;
1069       return FALSE;
1070     }
1071
1072   if (eol > _DBUS_ONE_MEGABYTE)
1073     {
1074       /* This is a giant line, someone is trying to hose us. */
1075       if (!_dbus_string_append (&auth->outgoing, "ERROR \"Command too long\"\r\n"))
1076         goto out;
1077       else
1078         goto next_command;
1079     }
1080
1081   if (!_dbus_string_copy_len (&auth->incoming, 0, eol, &command, 0))
1082     goto out;
1083
1084   if (!_dbus_string_validate_ascii (&command, 0,
1085                                     _dbus_string_get_length (&command)))
1086     {
1087       _dbus_verbose ("Command contained non-ASCII chars or embedded nul\n");
1088       if (!_dbus_string_append (&auth->outgoing, "ERROR \"Command contained non-ASCII\"\r\n"))
1089         goto out;
1090       else
1091         goto next_command;
1092     }
1093
1094   {
1095     const char *q;
1096     _dbus_string_get_const_data (&command, &q);
1097     _dbus_verbose ("got command \"%s\"\n", q);
1098   }
1099
1100   _dbus_string_find_blank (&command, 0, &i);
1101   _dbus_string_skip_blank (&command, i, &j);
1102
1103   if (j > i)
1104     _dbus_string_delete (&command, i, j - i);
1105
1106   if (!_dbus_string_move (&command, i, &args, 0))
1107     goto out;
1108
1109   i = 0;
1110   while (auth->handlers[i].command != NULL)
1111     {
1112       if (_dbus_string_equal_c_str (&command,
1113                                     auth->handlers[i].command))
1114         {
1115           _dbus_verbose ("Processing auth command %s\n",
1116                          auth->handlers[i].command);
1117
1118           if (!(* auth->handlers[i].func) (auth, &command, &args))
1119             goto out;
1120
1121           break;
1122         }
1123       ++i;
1124     }
1125
1126   if (auth->handlers[i].command == NULL)
1127     {
1128       if (!process_unknown (auth, &command, &args))
1129         goto out;
1130     }
1131
1132  next_command:
1133
1134   /* We've succeeded in processing the whole command so drop it out
1135    * of the incoming buffer and return TRUE to try another command.
1136    */
1137
1138   _dbus_string_delete (&auth->incoming, 0, eol);
1139
1140   /* kill the \r\n */
1141   _dbus_string_delete (&auth->incoming, 0, 2);
1142
1143   retval = TRUE;
1144
1145  out:
1146   _dbus_string_free (&args);
1147   _dbus_string_free (&command);
1148
1149   if (!retval)
1150     auth->needed_memory = TRUE;
1151   else
1152     auth->needed_memory = FALSE;
1153
1154   return retval;
1155 }
1156
1157
1158 /** @} */
1159
1160 /**
1161  * @addtogroup DBusAuth
1162  * @{
1163  */
1164
1165 /**
1166  * Creates a new auth conversation object for the server side.
1167  * See doc/dbus-sasl-profile.txt for full details on what
1168  * this object does.
1169  *
1170  * @returns the new object or #NULL if no memory
1171  */
1172 DBusAuth*
1173 _dbus_auth_server_new (void)
1174 {
1175   DBusAuth *auth;
1176   DBusAuthServer *server_auth;
1177
1178   auth = _dbus_auth_new (sizeof (DBusAuthServer));
1179   if (auth == NULL)
1180     return NULL;
1181
1182   auth->handlers = server_handlers;
1183
1184   server_auth = DBUS_AUTH_SERVER (auth);
1185
1186   /* perhaps this should be per-mechanism with a lower
1187    * max
1188    */
1189   server_auth->failures = 0;
1190   server_auth->max_failures = 6;
1191
1192   return auth;
1193 }
1194
1195 /**
1196  * Creates a new auth conversation object for the client side.
1197  * See doc/dbus-sasl-profile.txt for full details on what
1198  * this object does.
1199  *
1200  * @returns the new object or #NULL if no memory
1201  */
1202 DBusAuth*
1203 _dbus_auth_client_new (void)
1204 {
1205   DBusAuth *auth;
1206
1207   auth = _dbus_auth_new (sizeof (DBusAuthClient));
1208   if (auth == NULL)
1209     return NULL;
1210
1211   auth->handlers = client_handlers;
1212
1213   /* Add a default mechanism to try */
1214   if (!_dbus_list_append (& DBUS_AUTH_CLIENT (auth)->mechs_to_try,
1215                           (void*) &all_mechanisms[0]))
1216     {
1217       _dbus_auth_unref (auth);
1218       return NULL;
1219     }
1220
1221   /* Now try the mechanism we just added */
1222   if (!client_try_next_mechanism (auth))
1223     {
1224       _dbus_auth_unref (auth);
1225       return NULL;
1226     }
1227
1228   return auth;
1229 }
1230
1231 /**
1232  * Increments the refcount of an auth object.
1233  *
1234  * @param auth the auth conversation
1235  */
1236 void
1237 _dbus_auth_ref (DBusAuth *auth)
1238 {
1239   _dbus_assert (auth != NULL);
1240
1241   auth->refcount += 1;
1242 }
1243
1244 /**
1245  * Decrements the refcount of an auth object.
1246  *
1247  * @param auth the auth conversation
1248  */
1249 void
1250 _dbus_auth_unref (DBusAuth *auth)
1251 {
1252   _dbus_assert (auth != NULL);
1253   _dbus_assert (auth->refcount > 0);
1254
1255   auth->refcount -= 1;
1256   if (auth->refcount == 0)
1257     {
1258       shutdown_mech (auth);
1259
1260       if (DBUS_AUTH_IS_CLIENT (auth))
1261         {
1262           _dbus_list_clear (& DBUS_AUTH_CLIENT (auth)->mechs_to_try);
1263         }
1264
1265       _dbus_string_free (&auth->identity);
1266       _dbus_string_free (&auth->incoming);
1267       _dbus_string_free (&auth->outgoing);
1268       dbus_free (auth);
1269     }
1270 }
1271
1272 /**
1273  * @param auth the auth conversation object
1274  * @returns #TRUE if we're in a final state
1275  */
1276 #define DBUS_AUTH_IN_END_STATE(auth) ((auth)->need_disconnect || (auth)->authenticated)
1277
1278 /**
1279  * Analyzes buffered input and moves the auth conversation forward,
1280  * returning the new state of the auth conversation.
1281  *
1282  * @param auth the auth conversation
1283  * @returns the new state
1284  */
1285 DBusAuthState
1286 _dbus_auth_do_work (DBusAuth *auth)
1287 {
1288   auth->needed_memory = FALSE;
1289
1290   /* Max amount we'll buffer up before deciding someone's on crack */
1291 #define MAX_BUFFER (16 * _DBUS_ONE_KILOBYTE)
1292
1293   do
1294     {
1295       if (DBUS_AUTH_IN_END_STATE (auth))
1296         break;
1297
1298       if (_dbus_string_get_length (&auth->incoming) > MAX_BUFFER ||
1299           _dbus_string_get_length (&auth->outgoing) > MAX_BUFFER)
1300         {
1301           auth->need_disconnect = TRUE;
1302           _dbus_verbose ("Disconnecting due to excessive data buffered in auth phase\n");
1303           break;
1304         }
1305
1306       if (auth->mech == NULL &&
1307           auth->already_got_mechanisms &&
1308           DBUS_AUTH_CLIENT (auth)->mechs_to_try == NULL)
1309         {
1310           auth->need_disconnect = TRUE;
1311           _dbus_verbose ("Disconnecting because we are out of mechanisms to try using\n");
1312           break;
1313         }
1314     }
1315   while (process_command (auth));
1316
1317   if (DBUS_AUTH_IS_SERVER (auth) &&
1318       DBUS_AUTH_SERVER (auth)->failures >=
1319       DBUS_AUTH_SERVER (auth)->max_failures)
1320     auth->need_disconnect = TRUE;
1321
1322   if (auth->need_disconnect)
1323     return DBUS_AUTH_STATE_NEED_DISCONNECT;
1324   else if (auth->authenticated)
1325     {
1326       if (_dbus_string_get_length (&auth->incoming) > 0)
1327         return DBUS_AUTH_STATE_AUTHENTICATED_WITH_UNUSED_BYTES;
1328       else
1329         return DBUS_AUTH_STATE_AUTHENTICATED;
1330     }
1331   else if (auth->needed_memory)
1332     return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
1333   else if (_dbus_string_get_length (&auth->outgoing) > 0)
1334     return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
1335   else
1336     return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
1337 }
1338
1339 /**
1340  * Gets bytes that need to be sent to the peer we're conversing with.
1341  * After writing some bytes, _dbus_auth_bytes_sent() must be called
1342  * to notify the auth object that they were written.
1343  *
1344  * @param auth the auth conversation
1345  * @param str return location for a ref to the buffer to send
1346  * @returns #FALSE if nothing to send
1347  */
1348 dbus_bool_t
1349 _dbus_auth_get_bytes_to_send (DBusAuth          *auth,
1350                               const DBusString **str)
1351 {
1352   _dbus_assert (auth != NULL);
1353   _dbus_assert (str != NULL);
1354
1355   *str = NULL;
1356
1357   if (DBUS_AUTH_IN_END_STATE (auth))
1358     return FALSE;
1359
1360   if (_dbus_string_get_length (&auth->outgoing) == 0)
1361     return FALSE;
1362
1363   *str = &auth->outgoing;
1364
1365   return TRUE;
1366 }
1367
1368 /**
1369  * Notifies the auth conversation object that
1370  * the given number of bytes of the outgoing buffer
1371  * have been written out.
1372  *
1373  * @param auth the auth conversation
1374  * @param bytes_sent number of bytes written out
1375  */
1376 void
1377 _dbus_auth_bytes_sent (DBusAuth *auth,
1378                        int       bytes_sent)
1379 {
1380   _dbus_string_delete (&auth->outgoing,
1381                        0, bytes_sent);
1382
1383   if (auth->authenticated_pending_output &&
1384       _dbus_string_get_length (&auth->outgoing) == 0)
1385     auth->authenticated = TRUE;
1386 }
1387
1388 /**
1389  * Stores bytes received from the peer we're conversing with.
1390  *
1391  * @param auth the auth conversation
1392  * @param str the received bytes.
1393  * @returns #FALSE if not enough memory to store the bytes or we were already authenticated.
1394  */
1395 dbus_bool_t
1396 _dbus_auth_bytes_received (DBusAuth   *auth,
1397                            const DBusString *str)
1398 {
1399   _dbus_assert (auth != NULL);
1400   _dbus_assert (str != NULL);
1401
1402   if (DBUS_AUTH_IN_END_STATE (auth))
1403     return FALSE;
1404
1405   auth->needed_memory = FALSE;
1406
1407   if (!_dbus_string_copy (str, 0,
1408                           &auth->incoming,
1409                           _dbus_string_get_length (&auth->incoming)))
1410     {
1411       auth->needed_memory = TRUE;
1412       return FALSE;
1413     }
1414
1415   _dbus_auth_do_work (auth);
1416
1417   return TRUE;
1418 }
1419
1420 /**
1421  * Returns leftover bytes that were not used as part of the auth
1422  * conversation.  These bytes will be part of the message stream
1423  * instead. This function may not be called until authentication has
1424  * succeeded.
1425  *
1426  * @param auth the auth conversation
1427  * @param str string to append the unused bytes to
1428  * @returns #FALSE if not enough memory to return the bytes
1429  */
1430 dbus_bool_t
1431 _dbus_auth_get_unused_bytes (DBusAuth   *auth,
1432                              DBusString *str)
1433 {
1434   if (!DBUS_AUTH_IN_END_STATE (auth))
1435     return FALSE;
1436
1437   if (!_dbus_string_move (&auth->incoming,
1438                           0, str,
1439                           _dbus_string_get_length (str)))
1440     return FALSE;
1441
1442   return TRUE;
1443 }
1444
1445 /**
1446  * Called post-authentication, indicates whether we need to encode
1447  * the message stream with _dbus_auth_encode_data() prior to
1448  * sending it to the peer.
1449  *
1450  * @param auth the auth conversation
1451  * @returns #TRUE if we need to encode the stream
1452  */
1453 dbus_bool_t
1454 _dbus_auth_needs_encoding (DBusAuth *auth)
1455 {
1456   if (!auth->authenticated)
1457     return FALSE;
1458
1459   if (auth->mech != NULL)
1460     {
1461       if (DBUS_AUTH_IS_CLIENT (auth))
1462         return auth->mech->client_encode_func != NULL;
1463       else
1464         return auth->mech->server_encode_func != NULL;
1465     }
1466   else
1467     return FALSE;
1468 }
1469
1470 /**
1471  * Called post-authentication, encodes a block of bytes for sending to
1472  * the peer. If no encoding was negotiated, just copies the bytes
1473  * (you can avoid this by checking _dbus_auth_needs_encoding()).
1474  *
1475  * @param auth the auth conversation
1476  * @param plaintext the plain text data
1477  * @param encoded initialized string to where encoded data is appended
1478  * @returns #TRUE if we had enough memory and successfully encoded
1479  */
1480 dbus_bool_t
1481 _dbus_auth_encode_data (DBusAuth         *auth,
1482                         const DBusString *plaintext,
1483                         DBusString       *encoded)
1484 {
1485   _dbus_assert (plaintext != encoded);
1486
1487   if (!auth->authenticated)
1488     return FALSE;
1489
1490   if (_dbus_auth_needs_encoding (auth))
1491     {
1492       if (DBUS_AUTH_IS_CLIENT (auth))
1493         return (* auth->mech->client_encode_func) (auth, plaintext, encoded);
1494       else
1495         return (* auth->mech->server_encode_func) (auth, plaintext, encoded);
1496     }
1497   else
1498     {
1499       return _dbus_string_copy (plaintext, 0, encoded,
1500                                 _dbus_string_get_length (encoded));
1501     }
1502 }
1503
1504 /**
1505  * Called post-authentication, indicates whether we need to decode
1506  * the message stream with _dbus_auth_decode_data() after
1507  * receiving it from the peer.
1508  *
1509  * @param auth the auth conversation
1510  * @returns #TRUE if we need to encode the stream
1511  */
1512 dbus_bool_t
1513 _dbus_auth_needs_decoding (DBusAuth *auth)
1514 {
1515   if (!auth->authenticated)
1516     return FALSE;
1517
1518   if (auth->mech != NULL)
1519     {
1520       if (DBUS_AUTH_IS_CLIENT (auth))
1521         return auth->mech->client_decode_func != NULL;
1522       else
1523         return auth->mech->server_decode_func != NULL;
1524     }
1525   else
1526     return FALSE;
1527 }
1528
1529
1530 /**
1531  * Called post-authentication, decodes a block of bytes received from
1532  * the peer. If no encoding was negotiated, just copies the bytes (you
1533  * can avoid this by checking _dbus_auth_needs_decoding()).
1534  *
1535  * @todo We need to be able to distinguish "out of memory" error
1536  * from "the data is hosed" error.
1537  *
1538  * @param auth the auth conversation
1539  * @param encoded the encoded data
1540  * @param plaintext initialized string where decoded data is appended
1541  * @returns #TRUE if we had enough memory and successfully decoded
1542  */
1543 dbus_bool_t
1544 _dbus_auth_decode_data (DBusAuth         *auth,
1545                         const DBusString *encoded,
1546                         DBusString       *plaintext)
1547 {
1548   _dbus_assert (plaintext != encoded);
1549
1550   if (!auth->authenticated)
1551     return FALSE;
1552
1553   if (_dbus_auth_needs_decoding (auth))
1554     {
1555       if (DBUS_AUTH_IS_CLIENT (auth))
1556         return (* auth->mech->client_decode_func) (auth, encoded, plaintext);
1557       else
1558         return (* auth->mech->server_decode_func) (auth, encoded, plaintext);
1559     }
1560   else
1561     {
1562       return _dbus_string_copy (encoded, 0, plaintext,
1563                                 _dbus_string_get_length (plaintext));
1564     }
1565 }
1566
1567 /**
1568  * Sets credentials received via reliable means from the operating
1569  * system.
1570  *
1571  * @param auth the auth conversation
1572  * @param credentials the credentials received
1573  */
1574 void
1575 _dbus_auth_set_credentials (DBusAuth               *auth,
1576                             const DBusCredentials  *credentials)
1577 {
1578   auth->credentials = *credentials;
1579 }
1580
1581 /**
1582  * Gets the identity we authorized the client as.  Apps may have
1583  * different policies as to what identities they allow.
1584  *
1585  * @param auth the auth conversation
1586  * @param credentials the credentials we've authorized
1587  */
1588 void
1589 _dbus_auth_get_identity (DBusAuth               *auth,
1590                          DBusCredentials        *credentials)
1591 {
1592   if (auth->authenticated)
1593     {
1594       *credentials = auth->authorized_identity;
1595     }
1596   else
1597     {
1598       credentials->pid = -1;
1599       credentials->uid = -1;
1600       credentials->gid = -1;
1601     }
1602 }
1603
1604 /** @} */
1605
1606 #ifdef DBUS_BUILD_TESTS
1607 #include "dbus-test.h"
1608 #include "dbus-auth-script.h"
1609 #include <stdio.h>
1610
1611 static dbus_bool_t
1612 process_test_subdir (const DBusString          *test_base_dir,
1613                      const char                *subdir)
1614 {
1615   DBusString test_directory;
1616   DBusString filename;
1617   DBusDirIter *dir;
1618   dbus_bool_t retval;
1619   DBusResultCode result;
1620
1621   retval = FALSE;
1622   dir = NULL;
1623
1624   if (!_dbus_string_init (&test_directory, _DBUS_INT_MAX))
1625     _dbus_assert_not_reached ("didn't allocate test_directory\n");
1626
1627   _dbus_string_init_const (&filename, subdir);
1628
1629   if (!_dbus_string_copy (test_base_dir, 0,
1630                           &test_directory, 0))
1631     _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
1632
1633   if (!_dbus_concat_dir_and_file (&test_directory, &filename))
1634     _dbus_assert_not_reached ("couldn't allocate full path");
1635
1636   _dbus_string_free (&filename);
1637   if (!_dbus_string_init (&filename, _DBUS_INT_MAX))
1638     _dbus_assert_not_reached ("didn't allocate filename string\n");
1639
1640   dir = _dbus_directory_open (&test_directory, &result);
1641   if (dir == NULL)
1642     {
1643       const char *s;
1644       _dbus_string_get_const_data (&test_directory, &s);
1645       _dbus_warn ("Could not open %s: %s\n", s,
1646                   dbus_result_to_string (result));
1647       goto failed;
1648     }
1649
1650   printf ("Testing:\n");
1651
1652   result = DBUS_RESULT_SUCCESS;
1653  next:
1654   while (_dbus_directory_get_next_file (dir, &filename, &result))
1655     {
1656       DBusString full_path;
1657
1658       if (!_dbus_string_init (&full_path, _DBUS_INT_MAX))
1659         _dbus_assert_not_reached ("couldn't init string");
1660
1661       if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
1662         _dbus_assert_not_reached ("couldn't copy dir to full_path");
1663
1664       if (!_dbus_concat_dir_and_file (&full_path, &filename))
1665         _dbus_assert_not_reached ("couldn't concat file to dir");
1666
1667       if (!_dbus_string_ends_with_c_str (&filename, ".auth-script"))
1668         {
1669           const char *filename_c;
1670           _dbus_string_get_const_data (&filename, &filename_c);
1671           _dbus_verbose ("Skipping non-.auth-script file %s\n",
1672                          filename_c);
1673           goto next;
1674         }
1675
1676       {
1677         const char *s;
1678         _dbus_string_get_const_data (&filename, &s);
1679         printf ("    %s\n", s);
1680       }
1681
1682       if (!_dbus_auth_script_run (&full_path))
1683         {
1684           _dbus_string_free (&full_path);
1685           goto failed;
1686         }
1687       else
1688         _dbus_string_free (&full_path);
1689     }
1690
1691   if (result != DBUS_RESULT_SUCCESS)
1692     {
1693       const char *s;
1694       _dbus_string_get_const_data (&test_directory, &s);
1695       _dbus_warn ("Could not get next file in %s: %s\n",
1696                   s, dbus_result_to_string (result));
1697       goto failed;
1698     }
1699
1700   retval = TRUE;
1701
1702  failed:
1703
1704   if (dir)
1705     _dbus_directory_close (dir);
1706   _dbus_string_free (&test_directory);
1707   _dbus_string_free (&filename);
1708
1709   return retval;
1710 }
1711
1712 static dbus_bool_t
1713 process_test_dirs (const char *test_data_dir)
1714 {
1715   DBusString test_directory;
1716   dbus_bool_t retval;
1717
1718   retval = FALSE;
1719
1720   _dbus_string_init_const (&test_directory, test_data_dir);
1721
1722   if (!process_test_subdir (&test_directory, "auth"))
1723     goto failed;
1724
1725   retval = TRUE;
1726
1727  failed:
1728
1729   _dbus_string_free (&test_directory);
1730
1731   return retval;
1732 }
1733
1734 dbus_bool_t
1735 _dbus_auth_test (const char *test_data_dir)
1736 {
1737
1738   if (test_data_dir == NULL)
1739     return TRUE;
1740
1741   if (!process_test_dirs (test_data_dir))
1742     return FALSE;
1743
1744   return TRUE;
1745 }
1746
1747 #endif /* DBUS_BUILD_TESTS */