dbus/dbus-auth-script.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-auth-script.c Test DBusAuth using a special script file (internal to D-BUS implementation)
   3  *
   4  * Copyright (C) 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 <config.h>
  24
  25 #ifdef DBUS_BUILD_TESTS
  26
  27 #include "dbus-auth-script.h"
  28 #include "dbus-auth.h"
  29 #include "dbus-string.h"
  30 #include "dbus-hash.h"
  31 #include "dbus-internals.h"
  32 #include "dbus-marshal.h"
  33
  34 /**
  35  * @defgroup DBusAuthScript code for running unit test scripts for DBusAuth
  36  * @ingroup  DBusInternals
  37  * @brief DBusAuth unit test scripting
  38  *
  39  * The code in here is used for unit testing, it loads
  40  * up a script that tests DBusAuth.
  41  *
  42  * @{
  43  */
  44
  45 /* this is slightly different from the other append_quoted_string
  46  * in dbus-message-builder.c
  47  */
  48 static dbus_bool_t
  49 append_quoted_string (DBusString       *dest,
  50                       const DBusString *quoted)
  51 {
  52   dbus_bool_t in_quotes = FALSE;
  53   dbus_bool_t in_backslash = FALSE;
  54   int i;
  55
  56   i = 0;
  57   while (i < _dbus_string_get_length (quoted))
  58     {
  59       unsigned char b;
  60
  61       b = _dbus_string_get_byte (quoted, i);
  62
  63       if (in_backslash)
  64         {
  65           unsigned char a;
  66
  67           if (b == 'r')
  68             a = '\r';
  69           else if (b == 'n')
  70             a = '\n';
  71           else if (b == '\\')
  72             a = '\\';
  73           else
  74             {
  75               _dbus_warn ("bad backslashed byte %c\n", b);
  76               return FALSE;
  77             }
  78
  79           if (!_dbus_string_append_byte (dest, a))
  80             return FALSE;
  81
  82           in_backslash = FALSE;
  83         }
  84       else if (b == '\\')
  85         {
  86           in_backslash = TRUE;
  87         }
  88       else if (in_quotes)
  89         {
  90           if (b == '\'')
  91             in_quotes = FALSE;
  92           else
  93             {
  94               if (!_dbus_string_append_byte (dest, b))
  95                 return FALSE;
  96             }
  97         }
  98       else
  99         {
 100           if (b == '\'')
 101             in_quotes = TRUE;
 102           else if (b == ' ' || b == '\n' || b == '\t')
 103             break; /* end on whitespace if not quoted */
 104           else
 105             {
 106               if (!_dbus_string_append_byte (dest, b))
 107                 return FALSE;
 108             }
 109         }
 110
 111       ++i;
 112     }
 113
 114   return TRUE;
 115 }
 116
 117 static dbus_bool_t
 118 same_first_word (const DBusString *a,
 119                  const DBusString *b)
 120 {
 121   int first_a_blank, first_b_blank;
 122
 123   _dbus_string_find_blank (a, 0, &first_a_blank);
 124   _dbus_string_find_blank (b, 0, &first_b_blank);
 125
 126   if (first_a_blank != first_b_blank)
 127     return FALSE;
 128
 129   return _dbus_string_equal_len (a, b, first_a_blank);
 130 }
 131
 132 static DBusAuthState
 133 auth_state_from_string (const DBusString *str)
 134 {
 135   if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_INPUT"))
 136     return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
 137   else if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_MEMORY"))
 138     return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
 139   else if (_dbus_string_starts_with_c_str (str, "HAVE_BYTES_TO_SEND"))
 140     return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
 141   else if (_dbus_string_starts_with_c_str (str, "NEED_DISCONNECT"))
 142     return DBUS_AUTH_STATE_NEED_DISCONNECT;
 143   else if (_dbus_string_starts_with_c_str (str, "AUTHENTICATED_WITH_UNUSED_BYTES"))
 144     return DBUS_AUTH_STATE_AUTHENTICATED_WITH_UNUSED_BYTES;
 145   else if (_dbus_string_starts_with_c_str (str, "AUTHENTICATED"))
 146     return DBUS_AUTH_STATE_AUTHENTICATED;
 147   else
 148     return -1;
 149 }
 150
 151 static const char*
 152 auth_state_to_string (DBusAuthState state)
 153 {
 154   switch (state)
 155     {
 156     case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
 157       return "WAITING_FOR_INPUT";
 158     case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
 159       return "WAITING_FOR_MEMORY";
 160     case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
 161       return "HAVE_BYTES_TO_SEND";
 162     case DBUS_AUTH_STATE_NEED_DISCONNECT:
 163       return "NEED_DISCONNECT";
 164     case DBUS_AUTH_STATE_AUTHENTICATED_WITH_UNUSED_BYTES:
 165       return "AUTHENTICATED_WITH_UNUSED_BYTES";
 166     case DBUS_AUTH_STATE_AUTHENTICATED:
 167       return "AUTHENTICATED";
 168     }
 169
 170   return "unknown";
 171 }
 172
 173 /**
 174  * Runs an "auth script" which is a script for testing the
 175  * authentication protocol. Scripts send and receive data, and then
 176  * include assertions about the state of both ends of the connection
 177  * after processing the data. A script succeeds if these assertions
 178  * hold.
 179  *
 180  * @param filename the file containing the script to run
 181  * @returns #TRUE if the script succeeds, #FALSE otherwise
 182  */
 183 dbus_bool_t
 184 _dbus_auth_script_run (const DBusString *filename)
 185 {
 186   DBusString file;
 187   DBusError error;
 188   DBusString line;
 189   dbus_bool_t retval;
 190   int line_no;
 191   DBusAuth *auth;
 192   DBusString from_auth;
 193   DBusAuthState state;
 194   DBusString context;
 195
 196   retval = FALSE;
 197   auth = NULL;
 198
 199   _dbus_string_init_const (&context, "org_freedesktop_test");
 200
 201   if (!_dbus_string_init (&file, _DBUS_INT_MAX))
 202     return FALSE;
 203
 204   if (!_dbus_string_init (&line, _DBUS_INT_MAX))
 205     {
 206       _dbus_string_free (&file);
 207       return FALSE;
 208     }
 209
 210   if (!_dbus_string_init (&from_auth, _DBUS_INT_MAX))
 211     {
 212       _dbus_string_free (&file);
 213       _dbus_string_free (&line);
 214       return FALSE;
 215     }
 216
 217   dbus_error_init (&error);
 218   if (!_dbus_file_get_contents (&file, filename, &error))    {
 219       const char *s;
 220       _dbus_string_get_const_data (filename, &s);
 221       _dbus_warn ("Getting contents of %s failed: %s\n",
 222                   s, error.message);
 223       dbus_error_free (&error);
 224       goto out;
 225     }
 226
 227   state = DBUS_AUTH_STATE_NEED_DISCONNECT;
 228   line_no = 0;
 229  next_iteration:
 230   while (_dbus_string_pop_line (&file, &line))
 231     {
 232       line_no += 1;
 233
 234       _dbus_string_delete_leading_blanks (&line);
 235
 236       if (auth != NULL)
 237         {
 238           while ((state = _dbus_auth_do_work (auth)) ==
 239                  DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
 240             {
 241               const DBusString *tmp;
 242               if (_dbus_auth_get_bytes_to_send (auth, &tmp))
 243                 {
 244                   int count = _dbus_string_get_length (tmp);
 245
 246                   if (_dbus_string_copy (tmp, 0, &from_auth,
 247                                          _dbus_string_get_length (&from_auth)))
 248                     _dbus_auth_bytes_sent (auth, count);
 249                 }
 250             }
 251         }
 252
 253       if (_dbus_string_get_length (&line) == 0)
 254         {
 255           /* empty line */
 256           goto next_iteration;
 257         }
 258       else if (_dbus_string_starts_with_c_str (&line,
 259                                                "#"))
 260         {
 261           /* Ignore this comment */
 262           goto next_iteration;
 263         }
 264       else if (_dbus_string_starts_with_c_str (&line,
 265                                                "CLIENT"))
 266         {
 267           DBusCredentials creds;
 268
 269           if (auth != NULL)
 270             {
 271               _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");
 272               goto out;
 273             }
 274
 275           auth = _dbus_auth_client_new ();
 276           if (auth == NULL)
 277             {
 278               _dbus_warn ("no memory to create DBusAuth\n");
 279               goto out;
 280             }
 281
 282           _dbus_credentials_from_current_process (&creds);
 283           _dbus_auth_set_credentials (auth, &creds);
 284         }
 285       else if (_dbus_string_starts_with_c_str (&line,
 286                                                "SERVER"))
 287         {
 288           DBusCredentials creds;
 289
 290           if (auth != NULL)
 291             {
 292               _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");
 293               goto out;
 294             }
 295
 296           auth = _dbus_auth_server_new ();
 297           if (auth == NULL)
 298             {
 299               _dbus_warn ("no memory to create DBusAuth\n");
 300               goto out;
 301             }
 302
 303           _dbus_credentials_from_current_process (&creds);
 304           _dbus_auth_set_credentials (auth, &creds);
 305           _dbus_auth_set_context (auth, &context);
 306         }
 307       else if (auth == NULL)
 308         {
 309           _dbus_warn ("must specify CLIENT or SERVER\n");
 310           goto out;
 311
 312         }
 313       else if (_dbus_string_starts_with_c_str (&line,
 314                                                "NO_CREDENTIALS"))
 315         {
 316           DBusCredentials creds = { -1, -1, -1 };
 317           _dbus_auth_set_credentials (auth, &creds);
 318         }
 319       else if (_dbus_string_starts_with_c_str (&line,
 320                                                "ROOT_CREDENTIALS"))
 321         {
 322           DBusCredentials creds = { -1, 0, 0 };
 323           _dbus_auth_set_credentials (auth, &creds);
 324         }
 325       else if (_dbus_string_starts_with_c_str (&line,
 326                                                "SILLY_CREDENTIALS"))
 327         {
 328           DBusCredentials creds = { -1, 4312, 1232 };
 329           _dbus_auth_set_credentials (auth, &creds);
 330         }
 331       else if (_dbus_string_starts_with_c_str (&line,
 332                                                "SEND"))
 333         {
 334           DBusString to_send;
 335
 336           _dbus_string_delete_first_word (&line);
 337
 338           if (!_dbus_string_init (&to_send, _DBUS_INT_MAX))
 339             {
 340               _dbus_warn ("no memory to allocate string\n");
 341               goto out;
 342             }
 343
 344           if (!append_quoted_string (&to_send, &line))
 345             {
 346               _dbus_warn ("failed to append quoted string line %d\n",
 347                           line_no);
 348               _dbus_string_free (&to_send);
 349               goto out;
 350             }
 351
 352           {
 353             const char *s4;
 354             _dbus_string_get_const_data (&to_send, &s4);
 355             _dbus_verbose ("Sending '%s'\n", s4);
 356           }
 357
 358           if (!_dbus_string_append (&to_send, "\r\n"))
 359             {
 360               _dbus_warn ("failed to append \r\n from line %d\n",
 361                           line_no);
 362               _dbus_string_free (&to_send);
 363               goto out;
 364             }
 365
 366           /* Replace USERID_BASE64 with our username in base64 */
 367           {
 368             int where;
 369
 370             if (_dbus_string_find (&to_send, 0,
 371                                    "USERID_BASE64", &where))
 372               {
 373                 DBusString username;
 374
 375                 if (!_dbus_string_init (&username, _DBUS_INT_MAX))
 376                   {
 377                     _dbus_warn ("no memory for userid\n");
 378                     _dbus_string_free (&to_send);
 379                     goto out;
 380                   }
 381
 382                 if (!_dbus_string_append_our_uid (&username))
 383                   {
 384                     _dbus_warn ("no memory for userid\n");
 385                     _dbus_string_free (&username);
 386                     _dbus_string_free (&to_send);
 387                     goto out;
 388                   }
 389
 390                 _dbus_string_delete (&to_send, where, strlen ("USERID_BASE64"));
 391
 392                 if (!_dbus_string_base64_encode (&username, 0,
 393                                                  &to_send, where))
 394                   {
 395                     _dbus_warn ("no memory to subst USERID_BASE64\n");
 396                     _dbus_string_free (&username);
 397                     _dbus_string_free (&to_send);
 398                     goto out;
 399                   }
 400
 401                 _dbus_string_free (&username);
 402               }
 403             else if (_dbus_string_find (&to_send, 0,
 404                                         "USERNAME_BASE64", &where))
 405               {
 406                 DBusString username;
 407                 const DBusString *u;
 408
 409                 if (!_dbus_string_init (&username, _DBUS_INT_MAX))
 410                   {
 411                     _dbus_warn ("no memory for username\n");
 412                     _dbus_string_free (&to_send);
 413                     goto out;
 414                   }
 415
 416                 if (!_dbus_user_info_from_current_process (&u, NULL, NULL) ||
 417                     !_dbus_string_copy (u, 0, &username,
 418                                         _dbus_string_get_length (&username)))
 419                   {
 420                     _dbus_warn ("no memory for username\n");
 421                     _dbus_string_free (&username);
 422                     _dbus_string_free (&to_send);
 423                     goto out;
 424                   }
 425
 426                 _dbus_string_delete (&to_send, where, strlen ("USERNAME_BASE64"));
 427
 428                 if (!_dbus_string_base64_encode (&username, 0,
 429                                                  &to_send, where))
 430                   {
 431                     _dbus_warn ("no memory to subst USERNAME_BASE64\n");
 432                     _dbus_string_free (&username);
 433                     _dbus_string_free (&to_send);
 434                     goto out;
 435                   }
 436
 437                 _dbus_string_free (&username);
 438               }
 439           }
 440
 441           if (!_dbus_auth_bytes_received (auth, &to_send))
 442             {
 443               _dbus_warn ("not enough memory to call bytes_received, or can't add bytes to auth object already in end state\n");
 444               _dbus_string_free (&to_send);
 445               goto out;
 446             }
 447
 448           _dbus_string_free (&to_send);
 449         }
 450       else if (_dbus_string_starts_with_c_str (&line,
 451                                                "EXPECT_STATE"))
 452         {
 453           DBusAuthState expected;
 454
 455           _dbus_string_delete_first_word (&line);
 456
 457           expected = auth_state_from_string (&line);
 458           if (expected < 0)
 459             {
 460               _dbus_warn ("bad auth state given to EXPECT_STATE\n");
 461               goto parse_failed;
 462             }
 463
 464           if (expected != state)
 465             {
 466               _dbus_warn ("expected auth state %s but got %s on line %d\n",
 467                           auth_state_to_string (expected),
 468                           auth_state_to_string (state),
 469                           line_no);
 470               goto out;
 471             }
 472         }
 473       else if (_dbus_string_starts_with_c_str (&line,
 474                                                "EXPECT_COMMAND"))
 475         {
 476           DBusString received;
 477
 478           _dbus_string_delete_first_word (&line);
 479
 480           if (!_dbus_string_init (&received, _DBUS_INT_MAX))
 481             {
 482               _dbus_warn ("no mem to allocate string received\n");
 483               goto out;
 484             }
 485
 486           if (!_dbus_string_pop_line (&from_auth, &received))
 487             {
 488               const char *command;
 489               _dbus_string_get_const_data (&line, &command);
 490               _dbus_warn ("no line popped from the DBusAuth being tested, expected command %s on line %d\n",
 491                           command, line_no);
 492               _dbus_string_free (&received);
 493               goto out;
 494             }
 495
 496           if (!same_first_word (&received, &line))
 497             {
 498               const char *s1, *s2;
 499               _dbus_string_get_const_data (&line, &s1);
 500               _dbus_string_get_const_data (&received, &s2);
 501               _dbus_warn ("line %d expected command '%s' and got '%s'\n",
 502                           line_no, s1, s2);
 503               _dbus_string_free (&received);
 504               goto out;
 505             }
 506
 507           _dbus_string_free (&received);
 508         }
 509       else if (_dbus_string_starts_with_c_str (&line,
 510                                                "EXPECT_UNUSED"))
 511         {
 512           DBusString expected;
 513           DBusString unused;
 514
 515           _dbus_string_delete_first_word (&line);
 516
 517           if (!_dbus_string_init (&expected, _DBUS_INT_MAX))
 518             {
 519               _dbus_warn ("no mem to allocate string expected\n");
 520               goto out;
 521             }
 522
 523           if (!append_quoted_string (&expected, &line))
 524             {
 525               _dbus_warn ("failed to append quoted string line %d\n",
 526                           line_no);
 527               _dbus_string_free (&expected);
 528               goto out;
 529             }
 530
 531           if (!_dbus_string_init (&unused, _DBUS_INT_MAX))
 532             {
 533               _dbus_warn ("no mem to allocate string unused\n");
 534               _dbus_string_free (&expected);
 535               goto out;
 536             }
 537
 538           if (!_dbus_auth_get_unused_bytes (auth, &unused))
 539             {
 540               _dbus_warn ("couldn't get unused bytes\n");
 541               _dbus_string_free (&expected);
 542               _dbus_string_free (&unused);
 543               goto out;
 544             }
 545
 546           if (_dbus_string_equal (&expected, &unused))
 547             {
 548               _dbus_string_free (&expected);
 549               _dbus_string_free (&unused);
 550             }
 551           else
 552             {
 553               const char *e1, *h1;
 554               _dbus_string_get_const_data (&expected, &e1);
 555               _dbus_string_get_const_data (&unused, &h1);
 556               _dbus_warn ("Expected unused bytes '%s' and have '%s'\n",
 557                           e1, h1);
 558               _dbus_string_free (&expected);
 559               _dbus_string_free (&unused);
 560               goto out;
 561             }
 562         }
 563       else if (_dbus_string_starts_with_c_str (&line,
 564                                                "EXPECT"))
 565         {
 566           DBusString expected;
 567
 568           _dbus_string_delete_first_word (&line);
 569
 570           if (!_dbus_string_init (&expected, _DBUS_INT_MAX))
 571             {
 572               _dbus_warn ("no mem to allocate string expected\n");
 573               goto out;
 574             }
 575
 576           if (!append_quoted_string (&expected, &line))
 577             {
 578               _dbus_warn ("failed to append quoted string line %d\n",
 579                           line_no);
 580               _dbus_string_free (&expected);
 581               goto out;
 582             }
 583
 584           if (_dbus_string_equal_len (&expected, &from_auth,
 585                                       _dbus_string_get_length (&expected)))
 586             {
 587               _dbus_string_delete (&from_auth, 0,
 588                                    _dbus_string_get_length (&expected));
 589               _dbus_string_free (&expected);
 590             }
 591           else
 592             {
 593               const char *e1, *h1;
 594               _dbus_string_get_const_data (&expected, &e1);
 595               _dbus_string_get_const_data (&from_auth, &h1);
 596               _dbus_warn ("Expected exact string '%s' and have '%s'\n",
 597                           e1, h1);
 598               _dbus_string_free (&expected);
 599               goto out;
 600             }
 601         }
 602       else
 603         goto parse_failed;
 604
 605       goto next_iteration; /* skip parse_failed */
 606
 607     parse_failed:
 608       {
 609         const char *s;
 610         _dbus_string_get_const_data (&line, &s);
 611         _dbus_warn ("couldn't process line %d \"%s\"\n",
 612                     line_no, s);
 613         goto out;
 614       }
 615     }
 616
 617   if (auth != NULL &&
 618       state == DBUS_AUTH_STATE_AUTHENTICATED_WITH_UNUSED_BYTES)
 619     {
 620       _dbus_warn ("did not expect unused bytes (scripts must specify explicitly if they are expected)\n");
 621       goto out;
 622     }
 623
 624   if (_dbus_string_get_length (&from_auth) > 0)
 625     {
 626       const char *s;
 627       _dbus_warn ("script did not have EXPECT_ statements for all the data received from the DBusAuth\n");
 628       _dbus_string_get_const_data (&from_auth, &s);
 629       _dbus_warn ("Leftover data: %s\n", s);
 630       goto out;
 631     }
 632
 633   retval = TRUE;
 634
 635  out:
 636   if (auth)
 637     _dbus_auth_unref (auth);
 638
 639   _dbus_string_free (&file);
 640   _dbus_string_free (&line);
 641   _dbus_string_free (&from_auth);
 642
 643   return retval;
 644 }
 645
 646 /** @} */
 647 #endif /* DBUS_BUILD_TESTS */