Reorganize system/keymaster.
This CL moves the includes that should be exported to include/ and
removes the trusty-specific code (some of which is moving to
hardware/google and some of which is moving to the trusty tree.)
Change-Id: Ie4fabf6b5c5f36b50c2f5ff356548ca2e9140fcb
diff --git a/serializable.cpp b/serializable.cpp
index ddac8f1..9cfbac7 100644
--- a/serializable.cpp
+++ b/serializable.cpp
@@ -14,7 +14,8 @@
* limitations under the License.
*/
-#include "serializable.h"
+#include <keymaster/serializable.h>
+#include <keymaster/google_keymaster_utils.h>
namespace keymaster {
@@ -47,4 +48,95 @@
return copy_from_buf(buf_ptr, end, dest->get(), *size);
}
+bool Buffer::reserve(size_t size) {
+ if (available_write() < size) {
+ size_t new_size = buffer_size_ + size - available_write();
+ uint8_t* new_buffer = new uint8_t[new_size];
+ if (!new_buffer)
+ return false;
+ memcpy(new_buffer, buffer_.get() + read_position_, available_read());
+ memset_s(buffer_.get(), 0, buffer_size_);
+ buffer_.reset(new_buffer);
+ buffer_size_ = new_size;
+ write_position_ -= read_position_;
+ read_position_ = 0;
+ }
+ return true;
+}
+
+bool Buffer::Reinitialize(size_t size) {
+ Clear();
+ buffer_.reset(new uint8_t[size]);
+ if (buffer_.get() == NULL)
+ return false;
+ buffer_size_ = size;
+ read_position_ = 0;
+ write_position_ = 0;
+ return true;
+}
+
+bool Buffer::Reinitialize(const void* data, size_t data_len) {
+ Clear();
+ buffer_.reset(new uint8_t[data_len]);
+ if (buffer_.get() == NULL)
+ return false;
+ buffer_size_ = data_len;
+ memcpy(buffer_.get(), data, data_len);
+ read_position_ = 0;
+ write_position_ = buffer_size_;
+ return true;
+}
+
+size_t Buffer::available_write() const {
+ return buffer_size_ - write_position_;
+}
+
+size_t Buffer::available_read() const {
+ return write_position_ - read_position_;
+}
+
+bool Buffer::write(const uint8_t* src, size_t write_length) {
+ if (available_write() < write_length)
+ return false;
+ memcpy(buffer_.get() + write_position_, src, write_length);
+ write_position_ += write_length;
+ return true;
+}
+
+bool Buffer::read(uint8_t* dest, size_t read_length) {
+ if (available_read() < read_length)
+ return false;
+ memcpy(dest, buffer_.get() + read_position_, read_length);
+ read_position_ += read_length;
+ return true;
+}
+
+size_t Buffer::SerializedSize() const {
+ return sizeof(uint32_t) + available_read();
+}
+
+uint8_t* Buffer::Serialize(uint8_t* buf, const uint8_t* end) const {
+ return append_size_and_data_to_buf(buf, end, peek_read(), available_read());
+}
+
+bool Buffer::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
+ Clear();
+ if (!copy_size_and_data_from_buf(buf_ptr, end, &buffer_size_, &buffer_)) {
+ buffer_.reset();
+ buffer_size_ = 0;
+ return false;
+ }
+ write_position_ = buffer_size_;
+ return true;
+}
+
+void Buffer::Clear() {
+ if (buffer_.get())
+ memset_s(buffer_.get(), 0, buffer_size_);
+ buffer_.reset();
+ read_position_ = 0;
+ write_position_ = 0;
+ buffer_size_ = 0;
+}
+
} // namespace keymaster