/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2006,2007 INRIA

 *

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

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#include <cstdarg>

#include <iostream>

#include <sstream>

#include "ns3/test.h"

#include "ns3/bit-serializer.h"

#include "ns3/bit-deserializer.h"

using namespace ns3;

/**

 * \ingroup network-test

 * \ingroup tests

 *

 * \brief Bit serialization test

 */

class BitSerializerTest : public TestCase {

public:

  virtual void DoRun (void);

  BitSerializerTest ();

};

BitSerializerTest::BitSerializerTest ()

  : TestCase ("BitSerializer") {

}

void BitSerializerTest::DoRun ()

{

  BitSerializer testBitSerializer1;

  testBitSerializer1.PushBits (0x55, 7);

  testBitSerializer1.PushBits (0x7, 3);

  testBitSerializer1.PushBits (0x0, 2);

  std::vector<uint8_t> result = testBitSerializer1.GetBytes ();

  NS_TEST_EXPECT_MSG_EQ ((result[0] == 0xab) && (result[1] == 0xc0), true,

                         "Incorrect serialization " << result[0] << result[1] << " instead of " << int(0xab) << " " << int(0xc0));

  BitSerializer testBitSerializer2;

  testBitSerializer2.PushBits (0x55, 7);

  testBitSerializer2.PushBits (0x7, 3);

  testBitSerializer2.PushBits (0x0, 2);

  testBitSerializer2.InsertPaddingAtEnd (false);

  result = testBitSerializer2.GetBytes ();

  NS_TEST_EXPECT_MSG_EQ ((result[0] == 0x0a) && (result[1] == 0xbc), true,

                         "Incorrect serialization " << result[0] << result[1] << " instead of " << int(0x0a) << " " << int(0xbc));

}

/**

 * \ingroup network-test

 * \ingroup tests

 *

 * \brief Bit deserialization test

 */

class BitDeserializerTest : public TestCase {

public:

  virtual void DoRun (void);

  BitDeserializerTest ();

};

BitDeserializerTest::BitDeserializerTest ()

  : TestCase ("BitDeserializer") {

}

void BitDeserializerTest::DoRun ()

{

  BitDeserializer testBitDeserializer;

  uint8_t test[2];

  test[0] = 0xab;

  test[1] = 0xc0;

  testBitDeserializer.PushBytes (test,2);

  uint16_t nibble1 = testBitDeserializer.GetBits (7);

  uint16_t nibble2 = testBitDeserializer.GetBits (3);

  uint16_t nibble3 = testBitDeserializer.GetBits (2);

  bool result = (nibble1 == 0x55) && (nibble2 == 0x7) && (nibble3 == 0x0);

  NS_TEST_EXPECT_MSG_EQ (result, true,

                         "Incorrect deserialization " << nibble1 << " " << nibble2 << " " << nibble3 <<

                         " << instead of " << " " << int(0x55) << " " << int(0x7) << " " << int(0x0));

}

/**

 * \ingroup network-test

 * \ingroup tests

 *

 * \brief Packet Metadata TestSuite

 */

class BitSerializerTestSuite : public TestSuite

{

public:

  BitSerializerTestSuite ();

};

BitSerializerTestSuite::BitSerializerTestSuite ()

  : TestSuite ("bit-serializer", UNIT)

{

  AddTestCase (new BitSerializerTest, TestCase::QUICK);

  AddTestCase (new BitDeserializerTest, TestCase::QUICK);

}

static BitSerializerTestSuite g_bitSerializerTest; //!< Static variable for test initialization

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2018 Universita' di Firenze, Italy

 *

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

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#include <iostream>

#include "bit-deserializer.h"

#include "ns3/log.h"

#include "ns3/assert.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("BitDeserializer");

BitDeserializer::BitDeserializer ()

{

  m_deserializing = false;

}

void BitDeserializer::PushBytes (std::vector<uint8_t> bytes)

{

  NS_ASSERT_MSG (!m_deserializing, "Can't add bytes after deserialization started");

  m_bytesBlob.insert (m_bytesBlob.end (), bytes.begin (), bytes.end ());

}

void BitDeserializer::PushBytes (uint8_t* bytes, uint32_t size)

{

  NS_ASSERT_MSG (!m_deserializing, "Can't add bytes after deserialization started");

  for (uint32_t index = 0; index < size; index++)

    {

      m_bytesBlob.push_back (bytes[index]);

    }

}

void BitDeserializer::PushByte (uint8_t byte)

{

  NS_ASSERT_MSG (!m_deserializing, "Can't add bytes after deserialization started");

  m_bytesBlob.push_back (byte);

}

uint64_t BitDeserializer::GetBits (uint8_t size)

{

  uint8_t result = 0;

  PrepareDeserialization ();

  NS_ASSERT_MSG (size <= 64, "Number of requested bits exceeds 64");

  NS_ASSERT_MSG (size <= m_blob.size (), "Number of requested bits exceeds blob size");

  for (uint8_t i = 0; i < size; i++)

    {

      result <<= 1;

      result |= m_blob.front ();

      m_blob.pop_front ();

    }

  return result;

}

void BitDeserializer::PrepareDeserialization ()

{

  if (m_deserializing == false)

    {

      m_deserializing = true;

      for (auto index = m_bytesBlob.begin (); index != m_bytesBlob.end (); index++)

        {

          m_blob.push_back (*index & 0x80);

          m_blob.push_back (*index & 0x40);

          m_blob.push_back (*index & 0x20);

          m_blob.push_back (*index & 0x10);

          m_blob.push_back (*index & 0x8);

          m_blob.push_back (*index & 0x4);

          m_blob.push_back (*index & 0x2);

          m_blob.push_back (*index & 0x1);

        }

    }

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2018 Universita' di Firenze, Italy

 *

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

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#ifndef BITDESERIALIZER_H_

#define BITDESERIALIZER_H_

#include <vector>

#include <deque>

namespace ns3 {

/**

 * \ingroup packet

 *

 * \brief Bit deserializer. See also \sa ns3::BitSerializer

 *

 * This class helps converting a variable number, variable sized

 * number of bit-boundary fields stored as byte array representation

 * and extract the original bit-fields.

 *

 * Note that once the Deserialization starts, it's not anymore

 * possible to add more data to the `packet' to deserialize.

 */

class BitDeserializer

{

public:

  BitDeserializer ();

  /**

   * Pushes some bytes into the blob to be deserialized.

   * \param bytes The bytes to add.

   */

  void PushBytes (std::vector<uint8_t> bytes);

  /**

   * Pushes some bytes into the blob to be deserialized.

   * \param bytes The bytes to add.

   * \param size The length of the array.

   */

  void PushBytes (uint8_t* bytes, uint32_t size);

  /**

   * Pushes one byte into the blob to be deserialized.

   * \param byte The byte to add.

   */

  void PushByte (uint8_t byte);

  /**

   * Pops a given number of bits from the blob front.

   * \param size The number of bits to pop.

   */

  uint64_t GetBits (uint8_t size);

private:

  /**

   * Prepare the byte array to the deserialization.

   */

  void PrepareDeserialization ();

  std::deque<bool> m_blob; //!< Blob of bits ready to be deserialized.

  std::vector<uint8_t> m_bytesBlob;  //!< Blob of bytes to be deserialized.

  bool m_deserializing; //!< True if the deserialization did start alredy.

};

} // namespace ns3

#endif /* BITDESERIALIZER_H_ */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2018 Universita' di Firenze, Italy

 *

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

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#include <iostream>

#include "bit-serializer.h"

#include "ns3/log.h"

#include "ns3/assert.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("BitSerializer");

BitSerializer::BitSerializer ()

{

  m_padAtEnd = true;

}

void BitSerializer::InsertPaddingAtEnd (bool padAtEnd)

{

  m_padAtEnd = padAtEnd;

}

void BitSerializer::PadAtStart ()

{

  uint8_t padding = 8 - (m_blob.size () % 8);

  m_blob.insert (m_blob.begin (), padding, false);

}

void BitSerializer::PadAtEnd ()

{

  uint8_t padding = 8 - (m_blob.size () % 8);

  m_blob.insert (m_blob.end (), padding, false);

}

void BitSerializer::PushBits (uint64_t value, uint8_t significantBits)

{

  uint64_t mask = 1;

  mask <<= significantBits - 1;

  for (uint8_t i = 0; i < significantBits; i++)

    {

      if (value & mask)

        {

          m_blob.push_back (true);

        }

      else

        {

          m_blob.push_back (false);

        }

      mask >>= 1;

    }

}

std::vector<uint8_t> BitSerializer::GetBytes ()

{

  std::vector<uint8_t> result;

  m_padAtEnd ? PadAtEnd () : PadAtStart ();

  for (auto it = m_blob.begin (); it != m_blob.end ();)

    {

      uint8_t tmp = 0;

      for (uint8_t i = 0; i < 8; ++i)

        {

          tmp <<= 1;

          tmp |= (*it & 1);

          it++;

        }

      result.push_back (tmp);

    }

  m_blob.clear ();

  return result;

}

uint8_t BitSerializer::GetBytes (uint8_t *buffer, uint32_t size)

{

  uint8_t resultLen = 0;

  m_padAtEnd ? PadAtEnd () : PadAtStart ();

  NS_ASSERT_MSG (m_blob.size () <= 8 * size, "Target buffer is too short, " << m_blob.size () / 8 << " bytes needed" );

  for (auto it = m_blob.begin (); it != m_blob.end ();)

    {

      uint8_t tmp = 0;

      for (uint8_t i = 0; i < 8; ++i)

        {

          tmp <<= 1;

          tmp |= (*it & 1);

          it++;

        }

      buffer[resultLen] = tmp;

      resultLen++;

    }

  m_blob.clear ();

  return resultLen;

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2018 Universita' di Firenze, Italy

 *

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

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#ifndef BITSERIALIZER_H_

#define BITSERIALIZER_H_

#include <vector>

namespace ns3 {

/**

 * \ingroup packet

 *

 * \brief Bit serializer. See also \sa ns3::BitDeserializer

 *

 * This class helps converting a variable number, variable sized

 * number of bit-boundary fields to its final byte array representation.

 *

 * The typical use-case is:

 * \verbatim

 * aaa: A field

 * bbb: B field

 * ccc: C field

 * ddd: D field

 * 000: padding

 *

 * |aaaa abbb bbcc cdd0|

 * \endverbatim

 *

 * Padding can be automatically added at the end or at the start

 * of the `packet' to reach a multiple of 8 bits. By default the

 * padding is added at the end of the `packet'.

 *

 * This class should be used in two cases:

 *   - When the number of fields is large.

 *   - When the number of fields is variable.

 * In the other cases it's more convenient to use a simple bitmask.

 */

class BitSerializer

{

public:

  BitSerializer ();

  /**

   * Toggles the padding insertion policy.

   * \param padAtEnd true if the padding have to be inserted at the end of the bit blob.

   */

  void InsertPaddingAtEnd (bool padAtEnd);

  /**

   * Pushes a number of bits in the blob.

   * \param value the bits to be inserted.

   * \param significantBits Number of bits to insert.

   */

  void PushBits (uint64_t value, uint8_t significantBits);

  /**

   * Get the bytes representation of the blob.

   * Not that this operation  \b automatically add the

   * needed padding at the end (or start) of the blob.

   *

   * \warning {This operation clears the stored data.}

   *

   * \returns The byte representation of the blob.

   */

  std::vector<uint8_t> GetBytes ();

  /**

   * Get the bytes representation of the blob.

   * Not that this operation  \b automatically add the

   * needed padding at the end (or start) of the blob.

   *

   * \warning {This operation clears the stored data.}

   *

   * \param [out] buffer The buffer where to store the return data.

   * \param [in] size The size of the buffer.

   * \returns The number of bytes actually used in the buffer.

   */

  uint8_t GetBytes (uint8_t *buffer, uint32_t size);

private:

  /**

   * Add the padding at the start of the blob.

   */

  void PadAtStart ();

  /**

   * Add the padding at the end of the blob.

   */

  void PadAtEnd ();

  std::vector<bool> m_blob; //!< Blob of serialized bits.

  bool m_padAtEnd; //!< True if the padding must be added at the end of the blob.

};

} // namespace ns3

#endif /* BITSERIALIZER_H_ */

        'utils/bit-deserializer.cc',

        'utils/bit-serializer.cc',

        'test/bit-serializer-test.cc',

        'utils/bit-deserializer.h',

        'utils/bit-serializer.h',