/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-auth-script.c Test DBusAuth using a special script file (internal to D-Bus implementation)

 * 

 * Copyright (C) 2003 Red Hat, Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#ifdef __SYMBIAN32__ 

#include "config.h"

#else

#include <config.h>

#endif

#ifdef DBUS_BUILD_TESTS

#include "dbus-auth-script.h"

#include "dbus-auth.h"

#include "dbus-string.h"

#include "dbus-hash.h"

#include "dbus-internals.h"

#include "dbus-userdb.h"

#include <stdio.h>

/**

 * @defgroup DBusAuthScript code for running unit test scripts for DBusAuth

 * @ingroup  DBusInternals

 * @brief DBusAuth unit test scripting

 *

 * The code in here is used for unit testing, it loads

 * up a script that tests DBusAuth.

 *

 * @{

 */

/* this is slightly different from the other append_quoted_string

 * in dbus-message-builder.c

 */

static dbus_bool_t

append_quoted_string (DBusString       *dest,

                      const DBusString *quoted)

{

  dbus_bool_t in_quotes = FALSE;

  dbus_bool_t in_backslash = FALSE;

  int i;

  i = 0;

  while (i < _dbus_string_get_length (quoted))

    {

      unsigned char b;

      b = _dbus_string_get_byte (quoted, i);

      if (in_backslash)

        {

          unsigned char a;

          if (b == 'r')

            a = '\r';

          else if (b == 'n')

            a = '\n';

          else if (b == '\\')

            a = '\\';

          else

            {

              _dbus_warn ("bad backslashed byte %c\n", b);

              return FALSE;

            }

          if (!_dbus_string_append_byte (dest, a))

            return FALSE;

          in_backslash = FALSE;

        }

      else if (b == '\\')

        {

          in_backslash = TRUE;

        }

      else if (in_quotes)

        {

          if (b == '\'')

            in_quotes = FALSE;

          else

            {

              if (!_dbus_string_append_byte (dest, b))

                return FALSE;

            }

        }

      else

        {

          if (b == '\'')

            in_quotes = TRUE;

          else if (b == ' ' || b == '\n' || b == '\t')

            break; /* end on whitespace if not quoted */

          else

            {

              if (!_dbus_string_append_byte (dest, b))

                return FALSE;

            }

        }

      ++i;

    }

  return TRUE;

}

static dbus_bool_t

same_first_word (const DBusString *a,

                 const DBusString *b)

{

  int first_a_blank, first_b_blank;

  _dbus_string_find_blank (a, 0, &first_a_blank);

  _dbus_string_find_blank (b, 0, &first_b_blank);

  if (first_a_blank != first_b_blank)

    return FALSE;

  return _dbus_string_equal_len (a, b, first_a_blank);

}

static DBusAuthState

auth_state_from_string (const DBusString *str)

{ 

  if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_INPUT"))

    return DBUS_AUTH_STATE_WAITING_FOR_INPUT;

  else if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_MEMORY"))

    return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;

  else if (_dbus_string_starts_with_c_str (str, "HAVE_BYTES_TO_SEND"))

    return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;

  else if (_dbus_string_starts_with_c_str (str, "NEED_DISCONNECT"))

    return DBUS_AUTH_STATE_NEED_DISCONNECT;

  else if (_dbus_string_starts_with_c_str (str, "AUTHENTICATED"))

    return DBUS_AUTH_STATE_AUTHENTICATED;

  else

    return -1;

}

static const char*

auth_state_to_string (DBusAuthState state)

{

  switch (state)

    {

    case DBUS_AUTH_STATE_WAITING_FOR_INPUT:

      return "WAITING_FOR_INPUT";

    case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:

      return "WAITING_FOR_MEMORY";

    case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:

      return "HAVE_BYTES_TO_SEND";

    case DBUS_AUTH_STATE_NEED_DISCONNECT:

      return "NEED_DISCONNECT";

    case DBUS_AUTH_STATE_AUTHENTICATED:

      return "AUTHENTICATED";

    }

  return "unknown";

}

static char **

split_string (DBusString *str)

{

  int i, j, k, count, end;

  char **array;

  end = _dbus_string_get_length (str);

  i = 0;

  _dbus_string_skip_blank (str, i, &i);

  for (count = 0; i < end; count++)

    {

      _dbus_string_find_blank (str, i, &i);

      _dbus_string_skip_blank (str, i, &i);

    }

  array = dbus_new0 (char *, count + 1);

  if (array == NULL)

    return NULL;

  i = 0;

  _dbus_string_skip_blank (str, i, &i);

  for (k = 0; k < count; k++)

    {

      _dbus_string_find_blank (str, i, &j);

      array[k] = dbus_malloc (j - i + 1);

      if (array[k] == NULL)

        {

          dbus_free_string_array (array);

          return NULL;

        }

      memcpy (array[k],

              _dbus_string_get_const_data_len (str, i, j - i), j - i);

      array[k][j - i] = '\0';

      _dbus_string_skip_blank (str, j, &i);

    }

  array[k] = NULL;

  return array;

}

/**

 * Runs an "auth script" which is a script for testing the

 * authentication protocol. Scripts send and receive data, and then

 * include assertions about the state of both ends of the connection

 * after processing the data. A script succeeds if these assertions

 * hold.

 *

 * @param filename the file containing the script to run

 * @returns #TRUE if the script succeeds, #FALSE otherwise

 */

#ifdef __SYMBIAN32__

 EXPORT_C

 #endif

dbus_bool_t

_dbus_auth_script_run (const DBusString *filename)

{

  DBusString file;

  DBusError error;

  DBusString line;

  dbus_bool_t retval;

  int line_no;

  DBusAuth *auth;

  DBusString from_auth;

  DBusAuthState state;

  DBusString context;

  int is_auth_server = 0;

  DBusString guid;

  #ifdef __SYMBIAN32__

  DBusString challenge;

  #endif

  retval = FALSE;

  auth = NULL;

  _dbus_string_init_const (&guid, "5fa01f4202cd837709a3274ca0df9d00");

  _dbus_string_init_const (&context, "org_freedesktop_test");

  if(!_dbus_string_init (&challenge))

	return FALSE;

  if (!_dbus_string_init (&file))

    return FALSE;

  if (!_dbus_string_init (&line))

    {

      _dbus_string_free (&file);

      return FALSE;

    }

  if (!_dbus_string_init (&from_auth))

    {

      _dbus_string_free (&file);

      _dbus_string_free (&line);

      return FALSE;

    }

  dbus_error_init (&error);

  if (!_dbus_file_get_contents (&file, filename, &error))    {

      _dbus_warn ("Getting contents of %s failed: %s\n",

                  _dbus_string_get_const_data (filename), error.message);

      dbus_error_free (&error);

      goto out;

    }

  state = DBUS_AUTH_STATE_NEED_DISCONNECT;

  line_no = 0;

 next_iteration:

  while (_dbus_string_pop_line (&file, &line))

    {      

      line_no += 1;

      _dbus_string_delete_leading_blanks (&line);

      if (auth != NULL)

        {

          while ((state = _dbus_auth_do_work (auth)) ==

                 DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)

            {

              const DBusString *tmp;

              if (_dbus_auth_get_bytes_to_send (auth, &tmp))

                {

                  int count = _dbus_string_get_length (tmp);

                  if (_dbus_string_copy (tmp, 0, &from_auth,

                                         _dbus_string_get_length (&from_auth)))

                    _dbus_auth_bytes_sent (auth, count);

                }

            }

        }

      if (_dbus_string_get_length (&line) == 0)

        {

          /* empty line */

          goto next_iteration;

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "#"))

        {

          /* Ignore this comment */

          goto next_iteration;

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "CLIENT"))

        {

          DBusCredentials creds;

          char str[100] ="";	  

          const DBusString* homedir;

          if (auth != NULL)

            {

              _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");

              goto out;

            }

		  #ifndef __SYMBIAN32__ 

          auth = _dbus_auth_client_new ();

          #else

          auth = _dbus_auth_client_new_test();

          #endif

        if(!_dbus_homedir_from_current_process(&homedir))		      //getting the private or homedir directory of the process

  		{

  	 					return FALSE;	

  	    }

  		strcpy(str,(const char*)_dbus_string_get_const_data(homedir)+11);

          if(!_dbus_file_open_and_write(str))

          {

          	return FALSE;

          }

          if (auth == NULL)

            {

              _dbus_warn ("no memory to create DBusAuth\n");

              goto out;

            }

          /* test ref/unref */

          _dbus_auth_ref (auth);

          _dbus_auth_unref (auth);

          _dbus_credentials_from_current_process (&creds);

          _dbus_auth_set_credentials (auth, &creds);

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "SERVER"))

        {

          DBusCredentials creds;

          if (auth != NULL)

            {

              _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");

              goto out;

            }

          auth = _dbus_auth_server_new (&guid);

          is_auth_server = 1;

          if (auth == NULL)

            {

              _dbus_warn ("no memory to create DBusAuth\n");

              goto out;

            }

          /* test ref/unref */

          _dbus_auth_ref (auth);

          _dbus_auth_unref (auth);

          _dbus_credentials_from_current_process (&creds);

          _dbus_auth_set_credentials (auth, &creds);

          _dbus_auth_set_context (auth, &context);

        }

      else if (auth == NULL)

        {

          _dbus_warn ("must specify CLIENT or SERVER\n");

          goto out;

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "NO_CREDENTIALS"))

        {

          // DBusCredentials creds = { -1, -1, -1 }; // sachin

           DBusCredentials creds = { 155, 0, 0 };

          _dbus_auth_set_credentials (auth, &creds);

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "ROOT_CREDENTIALS"))

        {

          // DBusCredentials creds = { -1, 0, 0 }; // sachin

          DBusCredentials creds = { 155, 0, 0 };

          _dbus_auth_set_credentials (auth, &creds);          

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "SILLY_CREDENTIALS"))

        {

          // DBusCredentials creds = { -1, 4312, 1232 }; // sachin

          DBusCredentials creds = { 155, 0, 0 }; 

          _dbus_auth_set_credentials (auth, &creds);          

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "ALLOWED_MECHS"))

        {

          char **mechs;

          _dbus_string_delete_first_word (&line);

          mechs = split_string (&line);

          _dbus_auth_set_mechanisms (auth, (const char **) mechs);

          dbus_free_string_array (mechs);

        }

      else if (_dbus_string_starts_with_c_str (&line,

                                               "SEND"))

        {

          DBusString to_send;

          _dbus_string_delete_first_word (&line);

          if (!_dbus_string_init (&to_send))

            {

              _dbus_warn ("no memory to allocate string\n");

              goto out;

            }

          if (!append_quoted_string (&to_send, &line))

            {

              _dbus_warn ("failed to append quoted string line %d\n",

                          line_no);

              _dbus_string_free (&to_send);

              goto out;

            }

          _dbus_verbose ("Sending '%s'\n", _dbus_string_get_const_data (&to_send));

          if (!_dbus_string_append (&to_send, "\r\n"))

            {

              _dbus_warn ("failed to append \r\n from line %d\n",

                          line_no);

              _dbus_string_free (&to_send);

              goto out;

            }

          /* Replace USERID_HEX with our username in hex */

          {

            int where;

            if (_dbus_string_find (&to_send, 0,

                                   "USERID_HEX", &where))

              {

                DBusString username;

                if (!_dbus_string_init (&username))

                  {

                    _dbus_warn ("no memory for userid\n");

                    _dbus_string_free (&to_send);

                    goto out;

                  }

                if (!_dbus_string_append_uint (&username,

                                               _dbus_getuid ()))

                  {

                    _dbus_warn ("no memory for userid\n");

                    _dbus_string_free (&username);

                    _dbus_string_free (&to_send);

                    goto out;

                  }

                _dbus_string_delete (&to_send, where, strlen ("USERID_HEX"));

                if (!_dbus_string_hex_encode (&username, 0,

					      &to_send, where))

                  {

                    _dbus_warn ("no memory to subst USERID_HEX\n");

                    _dbus_string_free (&username);

                    _dbus_string_free (&to_send);

                    goto out;

                  }

                _dbus_string_free (&username);

              }

            else if (_dbus_string_find (&to_send, 0,

                                        "USERNAME_HEX", &where))

              {

                DBusString username;

                const DBusString *u;

                if (!_dbus_string_init (&username))

                  {

                    _dbus_warn ("no memory for username\n");

                    _dbus_string_free (&to_send);

                    goto out;

                  }

                if (!_dbus_username_from_current_process (&u) ||

                    !_dbus_string_copy (u, 0, &username,

                                        _dbus_string_get_length (&username)))

                  {

                    _dbus_warn ("no memory for username\n");

                    _dbus_string_free (&username);

                    _dbus_string_free (&to_send);

                    goto out;

                  }

                _dbus_string_delete (&to_send, where, strlen ("USERNAME_HEX"));

                if (!_dbus_string_hex_encode (&username, 0,

					      &to_send, where))

                  {

                    _dbus_warn ("no memory to subst USERNAME_HEX\n");

                    _dbus_string_free (&username);

                    _dbus_string_free (&to_send);

                    goto out;

                  }

                _dbus_string_free (&username);

              }

             #ifdef __SYMBIAN32__ 

              else if( _dbus_string_find(&to_send,0,"PROCESS_SID",&where))

              {