25 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
   27 #include "dbus-auth-script.h" 
   31 #include "dbus-auth.h" 
   32 #include "dbus-string.h" 
   33 #include "dbus-hash.h" 
   34 #include "dbus-credentials.h" 
   35 #include "dbus-internals.h" 
   37 #include "test/test-utils.h" 
   62   while (i < _dbus_string_get_length (quoted))
 
   66       b = _dbus_string_get_byte (quoted, i);
 
  107           else if (b == 
' ' || b == 
'\n' || b == 
'\t')
 
  126   int first_a_blank, first_b_blank;
 
  131   if (first_a_blank != first_b_blank)
 
  138 auth_state_from_string (
const DBusString *str)
 
  141     return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
 
  143     return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
 
  145     return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
 
  147     return DBUS_AUTH_STATE_NEED_DISCONNECT;
 
  149     return DBUS_AUTH_STATE_AUTHENTICATED;
 
  151     return DBUS_AUTH_STATE_INVALID;
 
  155 auth_state_to_string (DBusAuthState state)
 
  159     case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
 
  160       return "WAITING_FOR_INPUT";
 
  161     case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
 
  162       return "WAITING_FOR_MEMORY";
 
  163     case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
 
  164       return "HAVE_BYTES_TO_SEND";
 
  165     case DBUS_AUTH_STATE_NEED_DISCONNECT:
 
  166       return "NEED_DISCONNECT";
 
  167     case DBUS_AUTH_STATE_AUTHENTICATED:
 
  168       return "AUTHENTICATED";
 
  169     case DBUS_AUTH_STATE_INVALID:
 
  181   int i, j, k, count, end;
 
  184   end = _dbus_string_get_length (str);
 
  188   for (count = 0; i < end; count++)
 
  200   for (k = 0; k < count; k++)
 
  205       if (array[k] == 
NULL)
 
  211               _dbus_string_get_const_data_len (str, i, j - i), j - i);
 
  212       array[k][j - i] = 
'\0';
 
  222 auth_set_unix_credentials(
DBusAuth  *auth,
 
  229   if (credentials == 
NULL)
 
  258 _dbus_auth_script_run (
const DBusString *filename)
 
  294       _dbus_warn (
"Getting contents of %s failed: %s",
 
  295                   _dbus_string_get_const_data (filename), error.
message);
 
  300   state = DBUS_AUTH_STATE_NEED_DISCONNECT;
 
  310       _dbus_string_delete_leading_blanks (&line);
 
  315                  DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
 
  320                   int count = _dbus_string_get_length (tmp);
 
  323                                          _dbus_string_get_length (&from_auth)))
 
  329       if (_dbus_string_get_length (&line) == 0)
 
  351           fprintf (stderr, 
"skipping unix only auth script\n");
 
  367           fprintf (stderr, 
"skipping windows only auth script\n");
 
  379               _dbus_warn (
"already created a DBusAuth (CLIENT or SERVER given twice)");
 
  405               _dbus_warn (
"no memory for setting credentials");
 
  421               _dbus_warn (
"already created a DBusAuth (CLIENT or SERVER given twice)");
 
  447               _dbus_warn (
"no memory for setting credentials");
 
  458       else if (auth == 
NULL)
 
  475                                                "SILLY_CREDENTIALS"))
 
  484           _dbus_string_delete_first_word (&line);
 
  485           mechs = split_string (&line);
 
  494           _dbus_string_delete_first_word (&line);
 
  502           if (!append_quoted_string (&to_send, &line))
 
  504               _dbus_warn (
"failed to append quoted string line %d",
 
  510           _dbus_verbose (
"Sending '%s'\n", _dbus_string_get_const_data (&to_send));
 
  514               _dbus_warn (
"failed to append \\r\\n from line %d",
 
  537                 if (!_dbus_test_append_different_uid (&uid))
 
  546                                      (
int) strlen (
"WRONG_USERID_HEX"));
 
  550                     _dbus_warn (
"no memory to subst WRONG_USERID_HEX");
 
  559                                         "USERID_HEX", &where))
 
  592                                         "WRONG_USERNAME_HEX", &where))
 
  606                 if (!_dbus_test_append_different_username (&username))
 
  615                                      (
int) strlen (
"WRONG_USERNAME_HEX"));
 
  620                     _dbus_warn (
"no memory to subst WRONG_USERNAME_HEX");
 
  631                 _dbus_warn (
"WRONG_USERNAME_HEX cannot be used on Windows");
 
  637                                         "USERNAME_HEX", &where))
 
  661                     _dbus_warn (
"no memory to subst USERNAME_HEX");
 
  676                                     buffer, _dbus_string_get_length (buffer)))
 
  678                 _dbus_warn (
"not enough memory to call bytes_received, or can't add bytes to auth object already in end state");
 
  692           DBusAuthState expected;
 
  694           _dbus_string_delete_first_word (&line);
 
  696           expected = auth_state_from_string (&line);
 
  699               _dbus_warn (
"bad auth state given to EXPECT_STATE");
 
  703           if (expected != state)
 
  705               _dbus_warn (
"expected auth state %s but got %s on line %d",
 
  706                           auth_state_to_string (expected),
 
  707                           auth_state_to_string (state),
 
  717           _dbus_string_delete_first_word (&line);
 
  721               _dbus_warn (
"no mem to allocate string received");
 
  727               _dbus_warn (
"no line popped from the DBusAuth being tested, expected command %s on line %d",
 
  728                           _dbus_string_get_const_data (&line), line_no);
 
  733           if (!same_first_word (&received, &line))
 
  735               _dbus_warn (
"line %d expected command '%s' and got '%s'",
 
  737                           _dbus_string_get_const_data (&line),
 
  738                           _dbus_string_get_const_data (&received));
 
  751           _dbus_string_delete_first_word (&line);
 
  755               _dbus_warn (
"no mem to allocate string expected");
 
  759           if (!append_quoted_string (&expected, &line))
 
  761               _dbus_warn (
"failed to append quoted string line %d",
 
  776               _dbus_warn (
"Expected unused bytes '%s' and have '%s'",
 
  777                           _dbus_string_get_const_data (&expected),
 
  778                           _dbus_string_get_const_data (unused));
 
  784                                                "EXPECT_HAVE_NO_CREDENTIALS"))
 
  791               _dbus_warn (
"Expected anonymous login or failed login, but some credentials were authorized");
 
  796                                                "EXPECT_HAVE_SOME_CREDENTIALS"))
 
  803               _dbus_warn (
"Expected to have some credentials, but we don't");
 
  812           _dbus_string_delete_first_word (&line);
 
  816               _dbus_warn (
"no mem to allocate string expected");
 
  820           if (!append_quoted_string (&expected, &line))
 
  822               _dbus_warn (
"failed to append quoted string line %d",
 
  829                                       _dbus_string_get_length (&expected)))
 
  832                                    _dbus_string_get_length (&expected));
 
  837               _dbus_warn (
"Expected exact string '%s' and have '%s'",
 
  838                           _dbus_string_get_const_data (&expected),
 
  839                           _dbus_string_get_const_data (&from_auth));
 
  851         _dbus_warn (
"couldn't process line %d \"%s\"",
 
  852                     line_no, _dbus_string_get_const_data (&line));
 
  859       _dbus_warn (
"Auth script is bogus, did not even have CLIENT or SERVER");
 
  862   else if (state == DBUS_AUTH_STATE_AUTHENTICATED)
 
  868       if (_dbus_string_get_length (unused) > 0)
 
  870           _dbus_warn (
"did not expect unused bytes (scripts must specify explicitly if they are expected)");
 
  875   if (_dbus_string_get_length (&from_auth) > 0)
 
  877       _dbus_warn (
"script did not have EXPECT_ statements for all the data received from the DBusAuth");
 
  878       _dbus_warn (
"Leftover data: %s", _dbus_string_get_const_data (&from_auth));
 
  
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
dbus_bool_t _dbus_auth_set_context(DBusAuth *auth, const DBusString *context)
Sets the "authentication context" which scopes cookies with the DBUS_COOKIE_SHA1 auth mechanism for e...
void _dbus_auth_return_buffer(DBusAuth *auth, DBusString *buffer)
Returns a buffer with new data read into it.
DBusAuthState _dbus_auth_do_work(DBusAuth *auth)
Analyzes buffered input and moves the auth conversation forward, returning the new state of the auth ...
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
dbus_bool_t _dbus_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code.
dbus_bool_t _dbus_string_equal_len(const DBusString *a, const DBusString *b, int len)
Tests two DBusString for equality up to the given length.
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
dbus_bool_t _dbus_auth_set_mechanisms(DBusAuth *auth, const char **mechanisms)
Sets an array of authentication mechanism names that we are willing to use.
void _dbus_auth_get_buffer(DBusAuth *auth, DBusString **buffer)
Get a buffer to be used for reading bytes from the peer we're conversing with.
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
void _dbus_auth_bytes_sent(DBusAuth *auth, int bytes_sent)
Notifies the auth conversation object that the given number of bytes of the outgoing buffer have been...
DBusAuth * _dbus_auth_server_new(const DBusString *guid)
Creates a new auth conversation object for the server side.
DBusCredentials * _dbus_auth_get_identity(DBusAuth *auth)
Gets the identity we authorized the client as.
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
dbus_bool_t _dbus_credentials_add_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
DBusCredentials * _dbus_credentials_new_from_current_process(void)
Creates a new object with credentials (user ID and process ID) from the current process.
DBusAuth * _dbus_auth_ref(DBusAuth *auth)
Increments the refcount of an auth object.
unsigned long dbus_pid_t
A process ID.
unsigned long dbus_uid_t
A user ID.
dbus_bool_t _dbus_string_find_blank(const DBusString *str, int start, int *found)
Finds a blank (space or tab) in the string.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
Internal members of DBusAuth.
dbus_bool_t _dbus_string_pop_line(DBusString *source, DBusString *dest)
Assigns a newline-terminated or \r\n-terminated line from the front of the string to the given dest s...
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
#define _dbus_assert_not_reached(explanation)
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
dbus_bool_t _dbus_auth_set_credentials(DBusAuth *auth, DBusCredentials *credentials)
Sets credentials received via reliable means from the operating system.
dbus_bool_t _dbus_auth_get_bytes_to_send(DBusAuth *auth, const DBusString **str)
Gets bytes that need to be sent to the peer we're conversing with.
dbus_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
Object representing an exception.
void _dbus_string_skip_blank(const DBusString *str, int start, int *end)
Skips blanks from start, storing the first non-blank in *end (blank is space or tab).
dbus_bool_t _dbus_string_hex_encode(const DBusString *source, int start, DBusString *dest, int insert_at)
Encodes a string in hex, the way MD5 and SHA-1 are usually encoded.
dbus_bool_t _dbus_append_user_from_current_process(DBusString *str)
Append to the string the identity we would like to have when we authenticate, on UNIX this is the cur...
void _dbus_credentials_unref(DBusCredentials *credentials)
Decrement refcount on credentials.
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
void _dbus_auth_unref(DBusAuth *auth)
Decrements the refcount of an auth object.
dbus_bool_t _dbus_string_starts_with_c_str(const DBusString *a, const char *c_str)
Checks whether a string starts with the given C string.
const char * message
public error message field
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
#define dbus_new0(type, count)
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
void _dbus_auth_delete_unused_bytes(DBusAuth *auth)
Gets rid of unused bytes returned by _dbus_auth_get_unused_bytes() after we've gotten them and succes...
DBusAuth * _dbus_auth_client_new(void)
Creates a new auth conversation object for the client side.
dbus_uint32_t dbus_bool_t
void _dbus_auth_get_unused_bytes(DBusAuth *auth, const DBusString **str)
Returns leftover bytes that were not used as part of the auth conversation.
DBusCredentials * _dbus_credentials_new(void)
Creates a new credentials object.
dbus_bool_t _dbus_string_equal(const DBusString *a, const DBusString *b)
Tests two DBusString for equality.
dbus_bool_t _dbus_credentials_add_unix_uid(DBusCredentials *credentials, dbus_uid_t uid)
Add a UNIX user ID to the credentials.