dbus/dbus-auth-script.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   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 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23 #include <config.h>
  24
  25 #ifdef DBUS_ENABLE_EMBEDDED_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-credentials.h"
  32 #include "dbus-internals.h"
  33 #include "dbus-authorization.h"
  34
  35 /**
  36  * @defgroup DBusAuthScript code for running unit test scripts for DBusAuth
  37  * @ingroup  DBusInternals
  38  * @brief DBusAuth unit test scripting
  39  *
  40  * The code in here is used for unit testing, it loads
  41  * up a script that tests DBusAuth.
  42  *
  43  * @{
  44  */
  45
  46 /* this is slightly different from the other append_quoted_string
  47  * in dbus-message-builder.c
  48  */
  49 static dbus_bool_t
  50 append_quoted_string (DBusString       *dest,
  51                       const DBusString *quoted)
  52 {
  53   dbus_bool_t in_quotes = FALSE;
  54   dbus_bool_t in_backslash = FALSE;
  55   int i;
  56
  57   i = 0;
  58   while (i < _dbus_string_get_length (quoted))
  59     {
  60       unsigned char b;
  61
  62       b = _dbus_string_get_byte (quoted, i);
  63
  64       if (in_backslash)
  65         {
  66           unsigned char a;
  67
  68           if (b == 'r')
  69             a = '\r';
  70           else if (b == 'n')
  71             a = '\n';
  72           else if (b == '\\')
  73             a = '\\';
  74           else
  75             {
  76               _dbus_warn ("bad backslashed byte %c\n", b);
  77               return FALSE;
  78             }
  79
  80           if (!_dbus_string_append_byte (dest, a))
  81             return FALSE;
  82
  83           in_backslash = FALSE;
  84         }
  85       else if (b == '\\')
  86         {
  87           in_backslash = TRUE;
  88         }
  89       else if (in_quotes)
  90         {
  91           if (b == '\'')
  92             in_quotes = FALSE;
  93           else
  94             {
  95               if (!_dbus_string_append_byte (dest, b))
  96                 return FALSE;
  97             }
  98         }
  99       else
 100         {
 101           if (b == '\'')
 102             in_quotes = TRUE;
 103           else if (b == ' ' || b == '\n' || b == '\t')
 104             break; /* end on whitespace if not quoted */
 105           else
 106             {
 107               if (!_dbus_string_append_byte (dest, b))
 108                 return FALSE;
 109             }
 110         }
 111
 112       ++i;
 113     }
 114
 115   return TRUE;
 116 }
 117
 118 static dbus_bool_t
 119 same_first_word (const DBusString *a,
 120                  const DBusString *b)
 121 {
 122   int first_a_blank, first_b_blank;
 123
 124   _dbus_string_find_blank (a, 0, &first_a_blank);
 125   _dbus_string_find_blank (b, 0, &first_b_blank);
 126
 127   if (first_a_blank != first_b_blank)
 128     return FALSE;
 129
 130   return _dbus_string_equal_len (a, b, first_a_blank);
 131 }
 132
 133 static DBusAuthState
 134 auth_state_from_string (const DBusString *str)
 135 {
 136   if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_INPUT"))
 137     return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
 138   else if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_MEMORY"))
 139     return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
 140   else if (_dbus_string_starts_with_c_str (str, "HAVE_BYTES_TO_SEND"))
 141     return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
 142   else if (_dbus_string_starts_with_c_str (str, "NEED_DISCONNECT"))
 143     return DBUS_AUTH_STATE_NEED_DISCONNECT;
 144   else if (_dbus_string_starts_with_c_str (str, "AUTHENTICATED"))
 145     return DBUS_AUTH_STATE_AUTHENTICATED;
 146   else
 147     return -1;
 148 }
 149
 150 static const char*
 151 auth_state_to_string (DBusAuthState state)
 152 {
 153   switch (state)
 154     {
 155     case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
 156       return "WAITING_FOR_INPUT";
 157     case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
 158       return "WAITING_FOR_MEMORY";
 159     case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
 160       return "HAVE_BYTES_TO_SEND";
 161     case DBUS_AUTH_STATE_NEED_DISCONNECT:
 162       return "NEED_DISCONNECT";
 163     case DBUS_AUTH_STATE_AUTHENTICATED:
 164       return "AUTHENTICATED";
 165     }
 166
 167   return "unknown";
 168 }
 169
 170 static char **
 171 split_string (DBusString *str)
 172 {
 173   int i, j, k, count, end;
 174   char **array;
 175
 176   end = _dbus_string_get_length (str);
 177
 178   i = 0;
 179   _dbus_string_skip_blank (str, i, &i);
 180   for (count = 0; i < end; count++)
 181     {
 182       _dbus_string_find_blank (str, i, &i);
 183       _dbus_string_skip_blank (str, i, &i);
 184     }
 185
 186   array = dbus_new0 (char *, count + 1);
 187   if (array == NULL)
 188     return NULL;
 189
 190   i = 0;
 191   _dbus_string_skip_blank (str, i, &i);
 192   for (k = 0; k < count; k++)
 193     {
 194       _dbus_string_find_blank (str, i, &j);
 195
 196       array[k] = dbus_malloc (j - i + 1);
 197       if (array[k] == NULL)
 198         {
 199           dbus_free_string_array (array);
 200           return NULL;
 201         }
 202       memcpy (array[k],
 203               _dbus_string_get_const_data_len (str, i, j - i), j - i);
 204       array[k][j - i] = '\0';
 205
 206       _dbus_string_skip_blank (str, j, &i);
 207     }
 208   array[k] = NULL;
 209
 210   return array;
 211 }
 212
 213 static void
 214 auth_set_unix_credentials(DBusAuth  *auth,
 215                           dbus_uid_t uid,
 216                           dbus_pid_t pid)
 217 {
 218   DBusCredentials *credentials;
 219
 220   credentials = _dbus_credentials_new ();
 221   if (credentials == NULL)
 222     _dbus_assert_not_reached ("no memory");
 223
 224   if (uid != DBUS_UID_UNSET)
 225     _dbus_credentials_add_unix_uid (credentials, uid);
 226   if (pid != DBUS_PID_UNSET)
 227     _dbus_credentials_add_pid (credentials, pid);
 228
 229   _dbus_auth_set_credentials (auth, credentials);
 230
 231   _dbus_credentials_unref (credentials);
 232 }
 233
 234 /**
 235  * Runs an "auth script" which is a script for testing the
 236  * authentication protocol. Scripts send and receive data, and then
 237  * include assertions about the state of both ends of the connection
 238  * after processing the data. A script succeeds if these assertions
 239  * hold.
 240  *
 241  * @param filename the file containing the script to run
 242  * @returns #TRUE if the script succeeds, #FALSE otherwise
 243  */
 244 dbus_bool_t
 245 _dbus_auth_script_run (const DBusString *filename)
 246 {
 247   DBusString file;
 248   DBusError error = DBUS_ERROR_INIT;
 249   DBusString line;
 250   dbus_bool_t retval;
 251   int line_no;
 252   DBusAuth *auth;
 253   DBusAuthorization *authorization;
 254   DBusString from_auth;
 255   DBusAuthState state;
 256   DBusString context;
 257   DBusString guid;
 258
 259   retval = FALSE;
 260   auth = NULL;
 261   authorization = NULL;
 262
 263   _dbus_string_init_const (&guid, "5fa01f4202cd837709a3274ca0df9d00");
 264   _dbus_string_init_const (&context, "org_freedesktop_test");
 265
 266   if (!_dbus_string_init (&file))
 267     return FALSE;
 268
 269   if (!_dbus_string_init (&line))
 270     {
 271       _dbus_string_free (&file);
 272       return FALSE;
 273     }
 274
 275   if (!_dbus_string_init (&from_auth))
 276     {
 277       _dbus_string_free (&file);
 278       _dbus_string_free (&line);
 279       return FALSE;
 280     }
 281
 282   if (!_dbus_file_get_contents (&file, filename, &error))    {
 283       _dbus_warn ("Getting contents of %s failed: %s\n",
 284                   _dbus_string_get_const_data (filename), error.message);
 285       dbus_error_free (&error);
 286       goto out;
 287     }
 288
 289   state = DBUS_AUTH_STATE_NEED_DISCONNECT;
 290   line_no = 0;
 291
 292  next_iteration:
 293   while (_dbus_string_pop_line (&file, &line))
 294     {
 295       line_no += 1;
 296
 297       /* _dbus_warn ("%s\n", _dbus_string_get_const_data (&line)); */
 298
 299       _dbus_string_delete_leading_blanks (&line);
 300
 301       if (auth != NULL)
 302         {
 303           while ((state = _dbus_auth_do_work (auth)) ==
 304                  DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
 305             {
 306               const DBusString *tmp;
 307               if (_dbus_auth_get_bytes_to_send (auth, &tmp))
 308                 {
 309                   int count = _dbus_string_get_length (tmp);
 310
 311                   if (_dbus_string_copy (tmp, 0, &from_auth,
 312                                          _dbus_string_get_length (&from_auth)))
 313                     _dbus_auth_bytes_sent (auth, count);
 314                 }
 315             }
 316         }
 317
 318       if (_dbus_string_get_length (&line) == 0)
 319         {
 320           /* empty line */
 321           goto next_iteration;
 322         }
 323       else if (_dbus_string_starts_with_c_str (&line,
 324                                                "#"))
 325         {
 326           /* Ignore this comment */
 327           goto next_iteration;
 328         }
 329 #ifdef DBUS_WIN
 330       else if (_dbus_string_starts_with_c_str (&line,
 331                                                "WIN_ONLY"))
 332         {
 333           /* Ignore this line */
 334           goto next_iteration;
 335         }
 336       else if (_dbus_string_starts_with_c_str (&line,
 337                                                "UNIX_ONLY"))
 338         {
 339           /* skip this file */
 340           _dbus_warn ("skipping unix only auth script\n");
 341           retval = TRUE;
 342           goto out;
 343         }
 344 #endif
 345 #ifdef DBUS_UNIX
 346       else if (_dbus_string_starts_with_c_str (&line,
 347                                                "UNIX_ONLY"))
 348         {
 349           /* Ignore this line */
 350           goto next_iteration;
 351         }
 352       else if (_dbus_string_starts_with_c_str (&line,
 353                                                "WIN_ONLY"))
 354         {
 355           /* skip this file */
 356           _dbus_warn ("skipping windows only auth script\n");
 357           retval = TRUE;
 358           goto out;
 359         }
 360 #endif
 361       else if (_dbus_string_starts_with_c_str (&line,
 362                                                "CLIENT"))
 363         {
 364           DBusCredentials *creds;
 365
 366           if (auth != NULL)
 367             {
 368               _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");
 369               goto out;
 370             }
 371
 372           auth = _dbus_auth_client_new ();
 373           if (auth == NULL)
 374             {
 375               _dbus_warn ("no memory to create DBusAuth\n");
 376               goto out;
 377             }
 378
 379           creds = _dbus_credentials_new_from_current_process ();
 380           if (creds == NULL)
 381             {
 382               _dbus_warn ("no memory for credentials\n");
 383               goto out;
 384             }
 385
 386           if (!_dbus_auth_set_credentials (auth, creds))
 387             {
 388               _dbus_warn ("no memory for setting credentials\n");
 389               _dbus_credentials_unref (creds);
 390               goto out;
 391             }
 392
 393           _dbus_credentials_unref (creds);
 394         }
 395       else if (_dbus_string_starts_with_c_str (&line, "SERVER") ||
 396                _dbus_string_starts_with_c_str (&line, "SERVER_ANONYMOUS"))
 397         {
 398           DBusCredentials *creds;
 399
 400           if (auth != NULL)
 401             {
 402               _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");
 403               goto out;
 404             }
 405
 406           /* empty authorization, it will use default rules */
 407           authorization = _dbus_authorization_new ();
 408           if (authorization == NULL)
 409             {
 410               _dbus_warn ("no memory to create DBusAuthorization\n");
 411               goto out;
 412             }
 413           /* if we are testing an anonymous server, we need to enable
 414            * anonymous authorization, or the mech will REJECT */
 415           if (_dbus_string_starts_with_c_str (&line, "SERVER_ANONYMOUS"))
 416             _dbus_authorization_set_allow_anonymous (authorization, TRUE);
 417
 418           auth = _dbus_auth_server_new (&guid, authorization);
 419           if (auth == NULL)
 420             {
 421               _dbus_warn ("no memory to create DBusAuth\n");
 422               goto out;
 423             }
 424
 425           creds = _dbus_credentials_new_from_current_process ();
 426           if (creds == NULL)
 427             {
 428               _dbus_warn ("no memory for credentials\n");
 429               goto out;
 430             }
 431
 432           if (!_dbus_auth_set_credentials (auth, creds))
 433             {
 434               _dbus_warn ("no memory for setting credentials\n");
 435               _dbus_credentials_unref (creds);
 436               goto out;
 437             }
 438
 439           _dbus_credentials_unref (creds);
 440
 441           _dbus_auth_set_context (auth, &context);
 442         }
 443       else if (auth == NULL)
 444         {
 445           _dbus_warn ("must specify CLIENT or SERVER\n");
 446           goto out;
 447
 448         }
 449       else if (_dbus_string_starts_with_c_str (&line,
 450                                                "NO_CREDENTIALS"))
 451         {
 452           auth_set_unix_credentials (auth, DBUS_UID_UNSET, DBUS_PID_UNSET);
 453         }
 454       else if (_dbus_string_starts_with_c_str (&line,
 455                                                "ROOT_CREDENTIALS"))
 456         {
 457           auth_set_unix_credentials (auth, 0, DBUS_PID_UNSET);
 458         }
 459       else if (_dbus_string_starts_with_c_str (&line,
 460                                                "SILLY_CREDENTIALS"))
 461         {
 462           auth_set_unix_credentials (auth, 4312, DBUS_PID_UNSET);
 463         }
 464       else if (_dbus_string_starts_with_c_str (&line,
 465                                                "ALLOWED_MECHS"))
 466         {
 467           char **mechs;
 468
 469           _dbus_string_delete_first_word (&line);
 470           mechs = split_string (&line);
 471           _dbus_auth_set_mechanisms (auth, (const char **) mechs);
 472           dbus_free_string_array (mechs);
 473         }
 474       else if (_dbus_string_starts_with_c_str (&line,
 475                                                "SEND"))
 476         {
 477           DBusString to_send;
 478
 479           _dbus_string_delete_first_word (&line);
 480
 481           if (!_dbus_string_init (&to_send))
 482             {
 483               _dbus_warn ("no memory to allocate string\n");
 484               goto out;
 485             }
 486
 487           if (!append_quoted_string (&to_send, &line))
 488             {
 489               _dbus_warn ("failed to append quoted string line %d\n",
 490                           line_no);
 491               _dbus_string_free (&to_send);
 492               goto out;
 493             }
 494
 495           _dbus_verbose ("Sending '%s'\n", _dbus_string_get_const_data (&to_send));
 496
 497           if (!_dbus_string_append (&to_send, "\r\n"))
 498             {
 499               _dbus_warn ("failed to append \r\n from line %d\n",
 500                           line_no);
 501               _dbus_string_free (&to_send);
 502               goto out;
 503             }
 504
 505           /* Replace USERID_HEX with our username in hex */
 506           {
 507             int where;
 508
 509             if (_dbus_string_find (&to_send, 0,
 510                                    "USERID_HEX", &where))
 511               {
 512                 DBusString username;
 513
 514                 if (!_dbus_string_init (&username))
 515                   {
 516                     _dbus_warn ("no memory for userid\n");
 517                     _dbus_string_free (&to_send);
 518                     goto out;
 519                   }
 520
 521                 if (!_dbus_append_user_from_current_process (&username))
 522                   {
 523                     _dbus_warn ("no memory for userid\n");
 524                     _dbus_string_free (&username);
 525                     _dbus_string_free (&to_send);
 526                     goto out;
 527                   }
 528
 529                 _dbus_string_delete (&to_send, where, strlen ("USERID_HEX"));
 530
 531                 if (!_dbus_string_hex_encode (&username, 0,
 532                                               &to_send, where))
 533                   {
 534                     _dbus_warn ("no memory to subst USERID_HEX\n");
 535                     _dbus_string_free (&username);
 536                     _dbus_string_free (&to_send);
 537                     goto out;
 538                   }
 539
 540                 _dbus_string_free (&username);
 541               }
 542             else if (_dbus_string_find (&to_send, 0,
 543                                         "USERNAME_HEX", &where))
 544               {
 545                 DBusString username;
 546
 547                 if (!_dbus_string_init (&username))
 548                   {
 549                     _dbus_warn ("no memory for username\n");
 550                     _dbus_string_free (&to_send);
 551                     goto out;
 552                   }
 553
 554                 if (!_dbus_append_user_from_current_process (&username))
 555                   {
 556                     _dbus_warn ("no memory for username\n");
 557                     _dbus_string_free (&username);
 558                     _dbus_string_free (&to_send);
 559                     goto out;
 560                   }
 561
 562                 _dbus_string_delete (&to_send, where, strlen ("USERNAME_HEX"));
 563
 564                 if (!_dbus_string_hex_encode (&username, 0,
 565                                               &to_send, where))
 566                   {
 567                     _dbus_warn ("no memory to subst USERNAME_HEX\n");
 568                     _dbus_string_free (&username);
 569                     _dbus_string_free (&to_send);
 570                     goto out;
 571                   }
 572
 573                 _dbus_string_free (&username);
 574               }
 575           }
 576
 577           {
 578             DBusString *buffer;
 579
 580             _dbus_auth_get_buffer (auth, &buffer);
 581             if (!_dbus_string_copy (&to_send, 0,
 582                                     buffer, _dbus_string_get_length (buffer)))
 583               {
 584                 _dbus_warn ("not enough memory to call bytes_received, or can't add bytes to auth object already in end state\n");
 585                 _dbus_string_free (&to_send);
 586                 _dbus_auth_return_buffer (auth, buffer, 0);
 587                 goto out;
 588               }
 589
 590             _dbus_auth_return_buffer (auth, buffer, _dbus_string_get_length (&to_send));
 591           }
 592
 593           _dbus_string_free (&to_send);
 594         }
 595       else if (_dbus_string_starts_with_c_str (&line,
 596                                                "EXPECT_STATE"))
 597         {
 598           DBusAuthState expected;
 599
 600           _dbus_string_delete_first_word (&line);
 601
 602           expected = auth_state_from_string (&line);
 603           if (expected < 0)
 604             {
 605               _dbus_warn ("bad auth state given to EXPECT_STATE\n");
 606               goto parse_failed;
 607             }
 608
 609           if (expected != state)
 610             {
 611               _dbus_warn ("expected auth state %s but got %s on line %d\n",
 612                           auth_state_to_string (expected),
 613                           auth_state_to_string (state),
 614                           line_no);
 615               goto out;
 616             }
 617         }
 618       else if (_dbus_string_starts_with_c_str (&line,
 619                                                "EXPECT_COMMAND"))
 620         {
 621           DBusString received;
 622
 623           _dbus_string_delete_first_word (&line);
 624
 625           if (!_dbus_string_init (&received))
 626             {
 627               _dbus_warn ("no mem to allocate string received\n");
 628               goto out;
 629             }
 630
 631           if (!_dbus_string_pop_line (&from_auth, &received))
 632             {
 633               _dbus_warn ("no line popped from the DBusAuth being tested, expected command %s on line %d\n",
 634                           _dbus_string_get_const_data (&line), line_no);
 635               _dbus_string_free (&received);
 636               goto out;
 637             }
 638
 639           if (!same_first_word (&received, &line))
 640             {
 641               _dbus_warn ("line %d expected command '%s' and got '%s'\n",
 642                           line_no,
 643                           _dbus_string_get_const_data (&line),
 644                           _dbus_string_get_const_data (&received));
 645               _dbus_string_free (&received);
 646               goto out;
 647             }
 648
 649           _dbus_string_free (&received);
 650         }
 651       else if (_dbus_string_starts_with_c_str (&line,
 652                                                "EXPECT_UNUSED"))
 653         {
 654           DBusString expected;
 655           const DBusString *unused;
 656
 657           _dbus_string_delete_first_word (&line);
 658
 659           if (!_dbus_string_init (&expected))
 660             {
 661               _dbus_warn ("no mem to allocate string expected\n");
 662               goto out;
 663             }
 664
 665           if (!append_quoted_string (&expected, &line))
 666             {
 667               _dbus_warn ("failed to append quoted string line %d\n",
 668                           line_no);
 669               _dbus_string_free (&expected);
 670               goto out;
 671             }
 672
 673           _dbus_auth_get_unused_bytes (auth, &unused);
 674
 675           if (_dbus_string_equal (&expected, unused))
 676             {
 677               _dbus_auth_delete_unused_bytes (auth);
 678               _dbus_string_free (&expected);
 679             }
 680           else
 681             {
 682               _dbus_warn ("Expected unused bytes '%s' and have '%s'\n",
 683                           _dbus_string_get_const_data (&expected),
 684                           _dbus_string_get_const_data (unused));
 685               _dbus_string_free (&expected);
 686               goto out;
 687             }
 688         }
 689       else if (_dbus_string_starts_with_c_str (&line,
 690                                                "EXPECT_HAVE_NO_CREDENTIALS"))
 691         {
 692           DBusCredentials *authorized_identity;
 693
 694           authorized_identity = _dbus_auth_get_identity (auth);
 695           if (!_dbus_credentials_are_anonymous (authorized_identity))
 696             {
 697               _dbus_warn ("Expected anonymous login or failed login, but some credentials were authorized\n");
 698               goto out;
 699             }
 700         }
 701       else if (_dbus_string_starts_with_c_str (&line,
 702                                                "EXPECT_HAVE_SOME_CREDENTIALS"))
 703         {
 704           DBusCredentials *authorized_identity;
 705
 706           authorized_identity = _dbus_auth_get_identity (auth);
 707           if (_dbus_credentials_are_anonymous (authorized_identity))
 708             {
 709               _dbus_warn ("Expected to have some credentials, but we don't\n");
 710               goto out;
 711             }
 712         }
 713       else if (_dbus_string_starts_with_c_str (&line,
 714                                                "EXPECT"))
 715         {
 716           DBusString expected;
 717
 718           _dbus_string_delete_first_word (&line);
 719
 720           if (!_dbus_string_init (&expected))
 721             {
 722               _dbus_warn ("no mem to allocate string expected\n");
 723               goto out;
 724             }
 725
 726           if (!append_quoted_string (&expected, &line))
 727             {
 728               _dbus_warn ("failed to append quoted string line %d\n",
 729                           line_no);
 730               _dbus_string_free (&expected);
 731               goto out;
 732             }
 733
 734           if (_dbus_string_equal_len (&expected, &from_auth,
 735                                       _dbus_string_get_length (&expected)))
 736             {
 737               _dbus_string_delete (&from_auth, 0,
 738                                    _dbus_string_get_length (&expected));
 739               _dbus_string_free (&expected);
 740             }
 741           else
 742             {
 743               _dbus_warn ("Expected exact string '%s' and have '%s'\n",
 744                           _dbus_string_get_const_data (&expected),
 745                           _dbus_string_get_const_data (&from_auth));
 746               _dbus_string_free (&expected);
 747               goto out;
 748             }
 749         }
 750       else
 751         goto parse_failed;
 752
 753       goto next_iteration; /* skip parse_failed */
 754
 755     parse_failed:
 756       {
 757         _dbus_warn ("couldn't process line %d \"%s\"\n",
 758                     line_no, _dbus_string_get_const_data (&line));
 759         goto out;
 760       }
 761     }
 762
 763   if (auth == NULL)
 764     {
 765       _dbus_warn ("Auth script is bogus, did not even have CLIENT or SERVER\n");
 766       goto out;
 767     }
 768   else if (state == DBUS_AUTH_STATE_AUTHENTICATED)
 769     {
 770       const DBusString *unused;
 771
 772       _dbus_auth_get_unused_bytes (auth, &unused);
 773
 774       if (_dbus_string_get_length (unused) > 0)
 775         {
 776           _dbus_warn ("did not expect unused bytes (scripts must specify explicitly if they are expected)\n");
 777           goto out;
 778         }
 779     }
 780
 781   if (_dbus_string_get_length (&from_auth) > 0)
 782     {
 783       _dbus_warn ("script did not have EXPECT_ statements for all the data received from the DBusAuth\n");
 784       _dbus_warn ("Leftover data: %s\n", _dbus_string_get_const_data (&from_auth));
 785       goto out;
 786     }
 787
 788   retval = TRUE;
 789
 790  out:
 791   if (auth)
 792     _dbus_auth_free (auth);
 793   if (authorization)
 794     _dbus_authorization_free (authorization);
 795
 796   _dbus_string_free (&file);
 797   _dbus_string_free (&line);
 798   _dbus_string_free (&from_auth);
 799
 800   return retval;
 801 }
 802
 803 /** @} */
 804 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */