contexthubhal/message_buf.h

/*
 * Copyright (c) 2016, Google. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#ifndef _MESSAGE_BUF_H_
#define _MESSAGE_BUF_H_

#include <endian.h>
#include <cstring>

namespace android {

namespace nanohub {

/*
 * Marshaling helper;
 * deals with alignment and endianness.
 * Assumption is:
 * read*()  parse buffer from device in LE format;
 *          return host endianness, aligned data
 * write*() primitives take host endinnness, aligned data,
 *          generate buffer to be passed to device in LE format
 *
 * Primitives do minimal error checking, only to ensure buffer read/write
 * safety. Caller is responsible for making sure correct amount of data
 * has been processed.
 */
class MessageBuf {
    char *data;
    size_t size;
    size_t pos;
    bool readOnly;
public:
    MessageBuf(char *buf, size_t bufSize) {
        size = bufSize;
        pos = 0;
        data = buf;
        readOnly = false;
    }
    MessageBuf(const char *buf, size_t bufSize) {
        size = bufSize;
        pos = 0;
        data = const_cast<char *>(buf);
        readOnly = true;
    }
    const char *getData() const { return data; }
    size_t getSize() const { return size; }
    size_t getPos() const { return pos; }
    size_t getRoom() const { return size - pos; }
    uint8_t readU8() {
        if (pos == size) {
            return 0;
        }
        return data[pos++];
    }
    void writeU8(uint8_t val) {
        if (pos == size || readOnly)
            return;
        data[pos++] = val;
    }
    uint16_t readU16() {
        if (pos > (size - sizeof(uint16_t))) {
            return 0;
        }
        uint16_t val;
        memcpy(&val, &data[pos], sizeof(val));
        pos += sizeof(val);
        return le16toh(val);
    }
    void writeU16(uint16_t val) {
        if (pos > (size - sizeof(uint16_t)) || readOnly) {
            return;
        }
        uint16_t tmp = htole16(val);
        memcpy(&data[pos], &tmp, sizeof(tmp));
        pos += sizeof(tmp);
    }
    uint32_t readU32() {
        if (pos > (size - sizeof(uint32_t))) {
            return 0;
        }
        uint32_t val;
        memcpy(&val, &data[pos], sizeof(val));
        pos += sizeof(val);
        return le32toh(val);
    }
    void writeU32(uint32_t val) {
        if (pos > (size - sizeof(uint32_t)) || readOnly) {
            return;
        }
        uint32_t tmp = htole32(val);
        memcpy(&data[pos], &tmp, sizeof(tmp));
        pos += sizeof(tmp);
    }
    uint64_t readU64() {
        if (pos > (size - sizeof(uint64_t))) {
            return 0;
        }
        uint64_t val;
        memcpy(&val, &data[pos], sizeof(val));
        pos += sizeof(val);
        return le32toh(val);
    }
    void writeU64(uint64_t val) {
        if (pos > (size - sizeof(uint64_t)) || readOnly) {
            return;
        }
        uint64_t tmp = htole64(val);
        memcpy(&data[pos], &tmp, sizeof(tmp));
        pos += sizeof(tmp);
    }
    const void *readRaw(size_t bufSize) {
        if (pos > (size - bufSize)) {
            return nullptr;
        }
        const void *buf = &data[pos];
        pos += bufSize;
        return buf;
    }
    void writeRaw(const void *buf, size_t bufSize) {
        if (pos > (size - bufSize) || readOnly) {
            return;
        }
        memcpy(&data[pos], buf, bufSize);
        pos += bufSize;
    }
};

}; // namespace nanohub

}; // namespace android

#endif