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

/* dbus-message-factory.c Generator of valid and invalid message data for test suite

 *

 * Copyright (C) 2005 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

#ifndef DOXYGEN_SHOULD_SKIP_THIS

#ifdef DBUS_BUILD_TESTS

#include "dbus-message-factory.h"

#include "dbus-message-private.h"

#include "dbus-test.h"

#include <stdio.h>

typedef enum

  {

    CHANGE_TYPE_ADJUST,

    CHANGE_TYPE_ABSOLUTE

  } ChangeType;

#define BYTE_ORDER_OFFSET  0

#define TYPE_OFFSET        1

#define BODY_LENGTH_OFFSET 4

#define FIELDS_ARRAY_LENGTH_OFFSET 12

static void

iter_recurse (DBusMessageDataIter *iter)

{

  iter->depth += 1;

  _dbus_assert (iter->depth < _DBUS_MESSAGE_DATA_MAX_NESTING);

  _dbus_assert (iter->sequence_nos[iter->depth] >= 0);

}

static int

iter_get_sequence (DBusMessageDataIter *iter)

{

  _dbus_assert (iter->sequence_nos[iter->depth] >= 0);

  return iter->sequence_nos[iter->depth];

}

static void

iter_set_sequence (DBusMessageDataIter *iter,

                   int                  sequence)

{

  _dbus_assert (sequence >= 0);

  iter->sequence_nos[iter->depth] = sequence;

}

static void

iter_unrecurse (DBusMessageDataIter *iter)

{

  iter->depth -= 1;

  _dbus_assert (iter->depth >= 0);

}

static void

iter_next (DBusMessageDataIter *iter)

{

  iter->sequence_nos[iter->depth] += 1;

}

static dbus_bool_t

iter_first_in_series (DBusMessageDataIter *iter)

{

  int i;

  i = iter->depth;

  while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)

    {

      if (iter->sequence_nos[i] != 0)

        return FALSE;

      ++i;

    }

  return TRUE;

}

typedef dbus_bool_t (* DBusInnerGeneratorFunc)   (DBusMessageDataIter *iter,

                                                  DBusMessage        **message_p);

typedef dbus_bool_t (* DBusMessageGeneratorFunc) (DBusMessageDataIter *iter,

                                                  DBusString          *data,

                                                  DBusValidity        *expected_validity);

static void

set_reply_serial (DBusMessage *message)

{

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  if (!dbus_message_set_reply_serial (message, 100))

    _dbus_assert_not_reached ("oom");

}

static dbus_bool_t

generate_trivial_inner (DBusMessageDataIter *iter,

                        DBusMessage        **message_p)

{

  DBusMessage *message;

  switch (iter_get_sequence (iter))

    {

    case 0:

      message = dbus_message_new_method_call ("org.freedesktop.TextEditor",

                                              "/foo/bar",

                                              "org.freedesktop.DocumentFactory",

                                              "Create");

      break;

    case 1:

      message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);

      set_reply_serial (message);

      break;

    case 2:

      message = dbus_message_new_signal ("/foo/bar",

                                         "org.freedesktop.DocumentFactory",

                                         "Created");

      break;

    case 3:

      message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);

      if (!dbus_message_set_error_name (message,

                                        "org.freedesktop.TestErrorName"))

        _dbus_assert_not_reached ("oom");

      {

        DBusMessageIter iter;

        const char *v_STRING = "This is an error";

        dbus_message_iter_init_append (message, &iter);

        if (!dbus_message_iter_append_basic (&iter,

                                             DBUS_TYPE_STRING,

                                             &v_STRING))

          _dbus_assert_not_reached ("oom");

      }

      set_reply_serial (message);

      break;

    default:

      return FALSE;

    }

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  *message_p = message;

  return TRUE;

}

static dbus_bool_t

generate_many_bodies_inner (DBusMessageDataIter *iter,

                            DBusMessage        **message_p)

{

  DBusMessage *message;

  DBusString signature;

  DBusString body;

  /* Keeping this small makes things go faster */

  message = dbus_message_new_method_call ("o.z.F",

                                          "/",

                                          "o.z.B",

                                          "Nah");

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  set_reply_serial (message);

  if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))

    _dbus_assert_not_reached ("oom");

  if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),

                                                message->byte_order,

                                                &signature, &body))

    {

      const char *v_SIGNATURE;

      v_SIGNATURE = _dbus_string_get_const_data (&signature);

      if (!_dbus_header_set_field_basic (&message->header,

                                         DBUS_HEADER_FIELD_SIGNATURE,

                                         DBUS_TYPE_SIGNATURE,

                                         &v_SIGNATURE))

        _dbus_assert_not_reached ("oom");

      if (!_dbus_string_move (&body, 0, &message->body, 0))

        _dbus_assert_not_reached ("oom");

      _dbus_marshal_set_uint32 (&message->header.data, BODY_LENGTH_OFFSET,

                                _dbus_string_get_length (&message->body),

                                message->byte_order);

      *message_p = message;

    }

  else

    {

      dbus_message_unref (message);

      *message_p = NULL;

    }

  _dbus_string_free (&signature);

  _dbus_string_free (&body);

  return *message_p != NULL;

}

static void

generate_from_message (DBusString            *data,

                       DBusValidity          *expected_validity,

                       DBusMessage           *message)

{

  _dbus_message_set_serial (message, 1);

  _dbus_message_lock (message);

  *expected_validity = DBUS_VALID;

  /* move for efficiency, since we'll nuke the message anyway */

  if (!_dbus_string_move (&message->header.data, 0,

                          data, 0))

    _dbus_assert_not_reached ("oom");

  if (!_dbus_string_copy (&message->body, 0,

                          data, _dbus_string_get_length (data)))

    _dbus_assert_not_reached ("oom");

}

static dbus_bool_t

generate_outer (DBusMessageDataIter   *iter,

                DBusString            *data,

                DBusValidity          *expected_validity,

                DBusInnerGeneratorFunc func)

{

  DBusMessage *message;

  message = NULL;

  if (!(*func)(iter, &message))

    return FALSE;

  iter_next (iter);

  _dbus_assert (message != NULL);

  generate_from_message (data, expected_validity, message);

  dbus_message_unref (message);

  return TRUE;

}

static dbus_bool_t

generate_trivial (DBusMessageDataIter   *iter,

                  DBusString            *data,

                  DBusValidity          *expected_validity)

{

  return generate_outer (iter, data, expected_validity,

                         generate_trivial_inner);

}

static dbus_bool_t

generate_many_bodies (DBusMessageDataIter   *iter,

                      DBusString            *data,

                      DBusValidity          *expected_validity)

{

  return generate_outer (iter, data, expected_validity,

                         generate_many_bodies_inner);

}

static DBusMessage*

simple_method_call (void)

{

  DBusMessage *message;

  /* Keeping this small makes stuff go faster */

  message = dbus_message_new_method_call ("o.b.Q",

                                          "/f/b",

                                          "o.b.Z",

                                          "Fro");

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  return message;

}

static DBusMessage*

simple_signal (void)

{

  DBusMessage *message;

  message = dbus_message_new_signal ("/f/b",

                                     "o.b.Z",

                                     "Fro");

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  return message;

}

static DBusMessage*

simple_method_return (void)

{

  DBusMessage *message;

  message =  dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  set_reply_serial (message);

  return message;

}

static DBusMessage*

simple_error (void)

{

  DBusMessage *message;

  message =  dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);

  if (message == NULL)

    _dbus_assert_not_reached ("oom");

  if (!dbus_message_set_error_name (message, "foo.bar"))

    _dbus_assert_not_reached ("oom");

  set_reply_serial (message);

  return message;

}

static dbus_bool_t

generate_special (DBusMessageDataIter   *iter,

                  DBusString            *data,

                  DBusValidity          *expected_validity)

{

  int item_seq;

  DBusMessage *message;

  int pos;

  dbus_int32_t v_INT32;

  _dbus_assert (_dbus_string_get_length (data) == 0);

  message = NULL;

  pos = -1;

  v_INT32 = 42;

  item_seq = iter_get_sequence (iter);

  if (item_seq == 0)

    {

      message = simple_method_call ();

      if (!dbus_message_append_args (message,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INVALID))

        _dbus_assert_not_reached ("oom");

      _dbus_header_get_field_raw (&message->header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  NULL, &pos);

      generate_from_message (data, expected_validity, message);

      /* set an invalid typecode */

      _dbus_string_set_byte (data, pos + 1, '$');

      *expected_validity = DBUS_INVALID_UNKNOWN_TYPECODE;

    }

  else if (item_seq == 1)

    {

      char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH+2];

      const char *v_STRING;

      int i;

      message = simple_method_call ();

      if (!dbus_message_append_args (message,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INVALID))

        _dbus_assert_not_reached ("oom");

      i = 0;

      while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))

        {

          long_sig[i] = DBUS_TYPE_ARRAY;

          ++i;

        }

      long_sig[i] = DBUS_TYPE_INVALID;

      v_STRING = long_sig;

      if (!_dbus_header_set_field_basic (&message->header,

                                         DBUS_HEADER_FIELD_SIGNATURE,

                                         DBUS_TYPE_SIGNATURE,

                                         &v_STRING))

        _dbus_assert_not_reached ("oom");

      _dbus_header_get_field_raw (&message->header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  NULL, &pos);

      generate_from_message (data, expected_validity, message);

      *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;

    }

  else if (item_seq == 2)

    {

      char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2+4];

      const char *v_STRING;

      int i;

      message = simple_method_call ();

      if (!dbus_message_append_args (message,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INVALID))

        _dbus_assert_not_reached ("oom");

      i = 0;

      while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))

        {

          long_sig[i] = DBUS_STRUCT_BEGIN_CHAR;

          ++i;

        }

      long_sig[i] = DBUS_TYPE_INT32;

      ++i;

      while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2 + 3))

        {

          long_sig[i] = DBUS_STRUCT_END_CHAR;

          ++i;

        }

      long_sig[i] = DBUS_TYPE_INVALID;

      v_STRING = long_sig;

      if (!_dbus_header_set_field_basic (&message->header,

                                         DBUS_HEADER_FIELD_SIGNATURE,

                                         DBUS_TYPE_SIGNATURE,

                                         &v_STRING))

        _dbus_assert_not_reached ("oom");

      _dbus_header_get_field_raw (&message->header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  NULL, &pos);

      generate_from_message (data, expected_validity, message);

      *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;

    }

  else if (item_seq == 3)

    {

      message = simple_method_call ();

      if (!dbus_message_append_args (message,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INVALID))

        _dbus_assert_not_reached ("oom");

      _dbus_header_get_field_raw (&message->header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  NULL, &pos);

      generate_from_message (data, expected_validity, message);

      _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);

      *expected_validity = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;

    }

  else if (item_seq == 4)

    {

      message = simple_method_call ();

      if (!dbus_message_append_args (message,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INVALID))

        _dbus_assert_not_reached ("oom");

      _dbus_header_get_field_raw (&message->header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  NULL, &pos);

      generate_from_message (data, expected_validity, message);

      _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_END_CHAR);

      *expected_validity = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;

    }

  else if (item_seq == 5)

    {

      message = simple_method_call ();

      if (!dbus_message_append_args (message,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INT32, &v_INT32,

                                     DBUS_TYPE_INVALID))

        _dbus_assert_not_reached ("oom");

      _dbus_header_get_field_raw (&message->header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  NULL, &pos);

      generate_from_message (data, expected_validity, message);

      _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);

      _dbus_string_set_byte (data, pos + 2, DBUS_STRUCT_END_CHAR);

      *expected_validity = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;

    }

  else if (item_seq == 6)

    {

      message = simple_method_call ();

      generate_from_message (data, expected_validity, message);

      _dbus_string_set_byte (data, TYPE_OFFSET, DBUS_MESSAGE_TYPE_INVALID);

      *expected_validity = DBUS_INVALID_BAD_MESSAGE_TYPE;

    }

  else if (item_seq == 7)

    {

      /* Messages of unknown type are considered valid */