Add KBOOT.

apps/elftosb/common/Blob.cpp

@@ -0,0 +1,122 @@
+/*
+ * File:	Blob.cpp
+ *
+ * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
+ * See included license file for license details.
+ */
+
+#include "Blob.h"
+#include <stdexcept>
+#include <stdlib.h>
+#include <string.h>
+
+Blob::Blob()
+    : m_data(0)
+    , m_length(0)
+{
+}
+
+//! Makes a local copy of the \a data argument.
+//!
+Blob::Blob(const uint8_t *data, unsigned length)
+    : m_data(0)
+    , m_length(length)
+{
+    m_data = reinterpret_cast<uint8_t *>(malloc(length));
+    memcpy(m_data, data, length);
+}
+
+//! Makes a local copy of the data owned by \a other.
+//!
+Blob::Blob(const Blob &other)
+    : m_data(0)
+    , m_length(other.m_length)
+{
+    m_data = reinterpret_cast<uint8_t *>(malloc(m_length));
+    memcpy(m_data, other.m_data, m_length);
+}
+
+//! Disposes of the binary data associated with this object.
+Blob::~Blob()
+{
+    if (m_data)
+    {
+        free(m_data);
+    }
+}
+
+//! Copies \a data onto the blob's data. The blob does not assume ownership
+//! of \a data.
+//!
+//! \param data Pointer to a buffer containing the data which will be copied
+//!		into the blob.
+//! \param length Number of bytes pointed to by \a data.
+void Blob::setData(const uint8_t *data, unsigned length)
+{
+    setLength(length);
+    memcpy(m_data, data, length);
+}
+
+//! Sets the #m_length member variable to \a length and resizes #m_data to
+//! the new length. The contents of #m_data past any previous contents are undefined.
+//! If the new \a length is 0 then the data will be freed and a subsequent call
+//! to getData() will return NULL.
+//!
+//! \param length New length of the blob's data in bytes.
+void Blob::setLength(unsigned length)
+{
+    if (length == 0)
+    {
+        clear();
+        return;
+    }
+
+    // Allocate new block.
+    if (!m_data)
+    {
+        m_data = reinterpret_cast<uint8_t *>(malloc(length));
+        if (!m_data)
+        {
+            throw std::runtime_error("failed to allocate memory");
+        }
+    }
+    // Reallocate previous block.
+    else
+    {
+        void *newBlob = realloc(m_data, length);
+        if (!newBlob)
+        {
+            throw std::runtime_error("failed to reallocate memory");
+        }
+        m_data = reinterpret_cast<uint8_t *>(newBlob);
+    }
+
+    // Set length.
+    m_length = length;
+}
+
+void Blob::append(const uint8_t *newData, unsigned newDataLength)
+{
+    unsigned oldLength = m_length;
+
+    setLength(m_length + newDataLength);
+
+    memcpy(m_data + oldLength, newData, newDataLength);
+}
+
+void Blob::clear()
+{
+    if (m_data)
+    {
+        free(m_data);
+        m_data = NULL;
+    }
+
+    m_length = 0;
+}
+
+void Blob::relinquish()
+{
+    m_data = NULL;
+    m_length = 0;
+}