/* pdu.cpp Copyright (c) 2020 Kevin Matz (kevin.matz@gmail.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include "pdu.h" #include namespace ACN { namespace PDU { /** * @brief Pdu::Pdu * @param vector_size */ Pdu::Pdu(size_t vector_size) : vector_size_(vector_size) { } /** * @brief Pdu::vector * @return */ uint32_t Pdu::vector() { if (flags_.hasVector) return vector_; if (inherit_) return inherit_->vector(); return 0; } /** * @brief Pdu::header * @return */ std::shared_ptr Pdu::header() { if (flags_.hasHeader) return header_; if (inherit_) return inherit_->header(); return nullptr; } /** * @brief Pdu::data * @return */ std::shared_ptr Pdu::data() { if (flags_.hasData) return data_; if (inherit_) return inherit_->data(); return nullptr; } /** * @brief Pdu::parent * @return */ Message Pdu::parent() { return parent_; } /** * @brief Pdu::stream * @return */ Stream Pdu::stream() { return stream_; } /** * @brief Pdu::streamSize * @return * * The maximum buffer size that could be required to buffer this PDU */ size_t Pdu::streamSize() const { size_t s = 2; // flength is at least 2 octets // plus the length of the vector if (flags_.hasVector) { if (inherit_) { if (vector_ != inherit_->vector()) s += vector_size_; } else { s += vector_size_; } } // plus the length of the header if (header_) { if (inherit_) { if (header_ != inherit_->header()) s += header_->streamSize(); } else { s += header_->streamSize(); } } // plus the lenth of the data if (data_) { if (inherit_) { if (data_ != inherit_->data()) s += data_->streamSize(); } else { s += data_->streamSize(); } } // and another bit if the length needs it if (s > 0x0fff) s++; return s; } /** * @brief Pdu::iStream * @param stream */ void Pdu::iStream(Stream stream) { // get the flags flags_.set(stream->peek()); // get the length size_t length; length = stream->readType() & 0x0fff; // high 4 bits are flags if (flags_.hasLength) length = (length << 8 ) | stream->readType(); // get the vector if (flags_.hasVector) switch (vector_size_) { case 1: vector_ = stream->readType(); break; case 2: vector_ = stream->readType(); break; case 4: vector_ = stream->readType(); break; default: stream->setstate(std::ios_base::failbit); return; } // length includes the flags, length, and vector. // the remainder of the length of header and data unsigned int hd_length = length - (flags_.hasLength ? 3 : 2) - vector_size_; // abort if the remaining PDU length isn't available if (!stream->good() || stream->available() < hd_length) return stream->setstate(std::ios_base::failbit); // create a stream buffer for the header and data stream_ = Stream(new pdu_stream(stream->data(), hd_length)); if (stream_->available() != hd_length) return stream->setstate(std::ios_base::failbit); // fast-forward the input stream stream->ignore(hd_length); if (!stream->available()) return stream->setstate(std::ios_base::eofbit); } /** * @brief Pdu::oStream * @param stream */ void Pdu::oStream(Stream stream) const { pdu_flags flags = flags_; size_t length = streamSize(); // check if length flag need to be set if (length > 0x0fff) flags.hasLength = true; // see if we can inherit members if (inherit_) { if (flags.hasVector) if (vector_ == inherit_->vector()) flags.hasVector = false; if (flags.hasHeader) if (header_ == inherit_->header()) flags.hasHeader = false; if (flags.hasData) if (data_ == inherit_->data()) flags.hasData = false; } // inject flags onto the high 4 bits of the length if (flags.hasLength) { uint8_t flength[3]; flength[0] = ((length >> 16) & 0x0f) | (uint8_t)flags; flength[1] = length >> 8; flength[2] = length; stream->write(flength, sizeof(flength)); } else { uint8_t flength[2]; flength[0] = ((length >> 8) & 0x0f) | (uint8_t)flags; flength[1] = length; stream->write(flength, sizeof(flength)); } // write the vector to stream if (flags.hasVector) switch (vector_size_) { case 1: stream->writeType(vector_); break; case 2: stream->writeType(vector_); break; case 4: stream->writeType(vector_); break; default: stream->setstate(std::ios_base::failbit); return; } // write the header to stream if (flags.hasHeader) header_->oStream(stream); // write the data to steam if (flags.hasData) data_->oStream(stream); } /** * @brief Pdu::setVector * @param v */ void Pdu::setVector (const uint32_t v) { vector_ = v; flags_.hasVector = true; } /** * @brief Pdu::setHeader * @param h */ void Pdu::setHeader (std::shared_ptr h) { header_ = h; flags_.hasHeader = true; } /** * @brief Pdu::setData * @param d */ void Pdu::setData (std::shared_ptr d) { data_ = d; flags_.hasData = true; } /** * @brief Pdu::setParent * @param pdu */ void Pdu::setParent (Message pdu) { parent_ = pdu; } /** * @brief Pdu::setInherit * @param pdu */ void Pdu::setInherit(Message pdu) { inherit_ = pdu; } /** * @brief pdu_flags::set * @param val */ void pdu_flags::set(const uint8_t val) { hasLength = (val >> 7) & 0b1; hasVector = (val >> 6) & 0b1; hasHeader = (val >> 5) & 0b1; hasData = (val >> 4) & 0b1; }; } // PDU } // ACN