// Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef TRUNKS_TSS_TPM_MESSAGE_H_
#define TRUNKS_TSS_TPM_MESSAGE_H_

#include <base/macros.h>

#include <stdint.h>
#include <stddef.h>
#include <vector>

namespace trunks {

// A class that manages proper formatting of messages to and from the TPM.
// Main features are: (a) safe functions to add single values and arrays, and
// (b) endian correction in case the host endianness differs from that of the
// TPM.

class TpmMessage {
 public:
  TpmMessage();
  ~TpmMessage();

  // A series of functions that push |value| to the end of |data_|.
  // Corrects for endianness (converts from host to big-endian). Returns the
  // number of bytes added.
  uint32_t PushBackUint8(uint8_t value);
  uint32_t PushBackInt8(int8_t value);
  uint32_t PushBackUint16(uint16_t value);
  uint32_t PushBackUint32(uint32_t value);
  uint32_t PushBackUint64(uint64_t value);

  // A series of functions that push arrays to the end of |data_|. First
  // the size of |array| is pushed as a uint32_t, then the contents of |array|
  // are pushed individually. Corrects for endianness (converts from host to
  // big-endian). Returns the number of bytes added.
  uint32_t PushBackArrayUint8(const std::vector<uint8_t>& array);
  uint32_t PushBackArrayInt8(const std::vector<int8_t>& array);
  uint32_t PushBackArrayUint16(const std::vector<uint16_t>& array);
  uint32_t PushBackArrayUint32(const std::vector<uint32_t>& array);
  uint32_t PushBackArrayUint64(const std::vector<uint64_t>& array);

  // A series of functions that pop from the start of |data_| into |value|.
  // Corrects for endianness (converts from big-endian to host). Returns the
  // number of bytes read, or 0 if there is not enough data to create such a
  // value.
  uint32_t PopFrontUint8(uint8_t* value);
  uint32_t PopFrontInt8(int8_t* value);
  uint32_t PopFrontUint16(uint16_t* value);
  uint32_t PopFrontUint32(uint32_t* value);
  uint32_t PopFrontUint64(uint64_t* value);

  // A series of functions that pop arrays from the start of |data_|. First
  // the size of |array| is popped as a uint32_t, then |array| is filled with
  // the appropriate number of elements. Corrects for endianness (converts from
  // big-endian to host). Returns the number of bytes read, or 0 if there is
  // not enough data to produce an array.
  // Side effect: |array| is initially cleared such that |array| will only
  // contain the contents popped off from |data_|.
  uint32_t PopFrontArrayUint8(std::vector<uint8_t>* array);
  uint32_t PopFrontArrayInt8(std::vector<int8_t>* array);
  uint32_t PopFrontArrayUint16(std::vector<uint16_t>* array);
  uint32_t PopFrontArrayUint32(std::vector<uint32_t>* array);
  uint32_t PopFrontArrayUint64(std::vector<uint64_t>* array);

  // Convenience function to push a uint32_t to the front of |data_|
  // should there be a size mismatch in popping off an array.
  // The TPM specification defines the way arrays are sent/received in a
  // byte-stream as consisting of a uint32_t size (defining the number of
  // elements that are in the array). This function serves to pop the size
  // back on the buffer should we find that the amount of data remaining on the
  // buffer is less than the size we received.
  uint32_t PushFrontUint32(uint32_t value);

  // Sets the message header (request |tag_|, ordinal |code_|).
  void SetHeader(uint16_t tag, uint32_t code);

  // Gets the message header (response |tag_|, response |code_|).
  void GetHeader(uint16_t* tag, uint32_t* code);

  // Exports the contents of this TpmMessage into |buffer| for writing to the
  // TPM. Returns |size|, the number of bytes that were written to |buffer|.
  // |buffer| must be at least of size kTpmPacketSize.
  void ExportPacketData(uint8_t* packet_buffer, uint32_t* size);

  // Imports data from |buffer| into this TpmMessage, up to |size| bytes.
  void ImportPacketData(const uint8_t* packet_buffer, uint32_t size);

  // Clears |data_| and resets |tag_| and |code_| to zero.
  void Clear();

  // Returns a pointer to a const version of |data_| (for testing purposes).
  const std::vector<uint8_t>* GetDataForTest() { return &data_; }

 private:
  // Internal data buffer.
  std::vector<uint8_t> data_;
  // Request/Response tag.
  uint16_t tag_;
  // Ordinal/Return code.
  uint32_t code_;

  DISALLOW_COPY_AND_ASSIGN(TpmMessage);
};

}  // namespace trunks

#endif  // TRUNKS_TSS_TPM_MESSAGE_H_