From 57d76f488cabb8850c36b5c7770b049a764b8eef Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 6 Jul 2015 11:33:46 -0700 Subject: [PATCH] make PacketPayload a QIODevice subclass --- domain-server/src/DomainServer.cpp | 18 ++-- libraries/networking/src/PacketByteArray.cpp | 10 +-- libraries/networking/src/PacketByteArray.h | 29 ------- libraries/networking/src/PacketPayload.cpp | 89 ++++++++++++++++++++ libraries/networking/src/PacketPayload.h | 42 +++++++++ 5 files changed, 148 insertions(+), 40 deletions(-) delete mode 100644 libraries/networking/src/PacketByteArray.h create mode 100644 libraries/networking/src/PacketPayload.cpp create mode 100644 libraries/networking/src/PacketPayload.h diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp index 203b6842be..5750a33faf 100644 --- a/domain-server/src/DomainServer.cpp +++ b/domain-server/src/DomainServer.cpp @@ -617,11 +617,16 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock QString reason; if (!isAssignment && !shouldAllowConnectionFromNode(username, usernameSignature, senderSockAddr, reason)) { // this is an agent and we've decided we won't let them connect - send them a packet to deny connection - QByteArray connectionDeniedByteArray = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeDomainConnectionDenied); - QDataStream out(&connectionDeniedByteArray, QIODevice::WriteOnly | QIODevice::Append); - out << reason; + + QByteArray utfString = reason.toUtf8(); + int payloadSize = utfString.size(); + + auto connectionDeniedPacket = NodeListPacket::make(PacketType::DomainConnectionDenied, payloadSize); + + memcpy(connectionDeniedPacket.payload().data(), utfString.data(), utfString.size()); + // tell client it has been refused. - DependencyManager::get()->writeUnverifiedDatagram(connectionDeniedByteArray, senderSockAddr); + limitedNodeList->sendPacket(std::move(connectionDeniedPacket, senderSockAddr); return; } @@ -921,10 +926,11 @@ int DomainServer::parseNodeDataFromByteArray(QDataStream& packetStream, NodeType void DomainServer::sendDomainListToNode(const SharedNodePointer& node, const HifiSockAddr &senderSockAddr, const NodeSet& nodeInterestSet) { auto limitedNodeList = DependencyManager::get(); - QByteArray broadcastPacket = limitedNodeList->byteArrayWithPopulatedHeader(PacketTypeDomainList); + + auto listPacket = NodeListPacket::make(PacketType::DomainList); // always send the node their own UUID back - QDataStream broadcastDataStream(&broadcastPacket, QIODevice::Append); + QDataStream broadcastDataStream(&listPacket.payload(), QIODevice::Append); broadcastDataStream << node->getUUID(); broadcastDataStream << node->getCanAdjustLocks(); broadcastDataStream << node->getCanRez(); diff --git a/libraries/networking/src/PacketByteArray.cpp b/libraries/networking/src/PacketByteArray.cpp index 010a083cfe..4d456b9066 100644 --- a/libraries/networking/src/PacketByteArray.cpp +++ b/libraries/networking/src/PacketByteArray.cpp @@ -1,5 +1,5 @@ // -// PacketByteArray.cpp +// PacketPayload.cpp // libraries/networking/src // // Created by Stephen Birarda on 07/06/15. @@ -9,16 +9,16 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // -#include "PacketByteArray.h" +#include "PacketPayload.h" -PacketByteArray::PacketByteArray(char* data, int maxBytes) : +PacketPayload::PacketPayload(char* data, int maxBytes) : _data(data) _maxBytes(maxBytes) { } -int PacketByteArray::append(const char* src, int srcBytes) { +int PacketPayload::append(const char* src, int srcBytes) { // this is a call to write at the current index int numWrittenBytes = write(src, srcBytes, _index); @@ -33,7 +33,7 @@ int PacketByteArray::append(const char* src, int srcBytes) { const int PACKET_WRITE_ERROR = -1; -int PacketByteArray::write(const char* src, int srcBytes, int index) { +int PacketPayload::write(const char* src, int srcBytes, int index) { if (index >= _maxBytes) { // we were passed a bad index, return -1 return PACKET_WRITE_ERROR; diff --git a/libraries/networking/src/PacketByteArray.h b/libraries/networking/src/PacketByteArray.h deleted file mode 100644 index 23ba55780b..0000000000 --- a/libraries/networking/src/PacketByteArray.h +++ /dev/null @@ -1,29 +0,0 @@ -// -// PacketByteArray.h -// libraries/networking/src -// -// Created by Stephen Birarda on 07/06/15. -// Copyright 2015 High Fidelity, Inc. -// -// Distributed under the Apache License, Version 2.0. -// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html -// - -#ifndef hifi_PacketByteArray_h -#define hifi_PacketByteArray_h - -#pragma once - -class PacketByteArray { -public: - PacketByteArray(char* data, int maxBytes); - - int write(const char* src, int srcBytes, int index = 0); - int append(const char* src, int srcBytes) -private: - char* _data; - int _index = 0; - int _maxBytes = 0; -}; - -#endif // hifi_PacketByteArray_h diff --git a/libraries/networking/src/PacketPayload.cpp b/libraries/networking/src/PacketPayload.cpp new file mode 100644 index 0000000000..d6a63364ee --- /dev/null +++ b/libraries/networking/src/PacketPayload.cpp @@ -0,0 +1,89 @@ +// +// PacketPayload.cpp +// libraries/networking/src +// +// Created by Stephen Birarda on 07/06/15. +// Copyright 2015 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#include "PacketPayload.h" + +PacketPayload::PacketPayload(char* data, qint64 maxBytes) : + _data(data) + _maxBytes(maxBytes) +{ + +} + +qint64 PacketPayload::append(const char* src, qint64 srcBytes) { + // this is a call to write at the current index + qint64 numWrittenBytes = write(src, srcBytes, _index); + + if (numWrittenBytes > 0) { + // we wrote some bytes, push the index + _index += numWrittenBytes; + return numWrittenBytes; + } else { + return numWrittenBytes; + } +} + +const int PACKET_READ_ERROR = -1; + +qint64 PacketPayload::write(const char* src, qint64 srcBytes, qint64 index) { + if (index >= _maxBytes) { + // we were passed a bad index, return error + return PACKET_WRITE_ERROR; + } + + // make sure we have the space required to write this block + qint64 bytesAvailable = _maxBytes - index; + + if (bytesAvailable < srcBytes) { + // good to go - write the data + memcpy(_data + index, src, srcBytes); + + // should this cause us to push our index (is this the farthest we've written in data)? + _writeIndex = std::max(_data + index + srcBytes, _writeIndex); + + // return the number of bytes written + return srcBytes; + } else { + // not enough space left for this write - return an error + return PACKET_WRITE_ERROR; + } +} + +qint64 PacketPayload::readNext(char* dest, qint64 maxSize) { + // call read at the current _readIndex + int numBytesRead = read(dest, maxSize, _readIndex); + + if (numBytesRead > 0) { + // we read some data, push the read index + _readIndex += numBytesRead; + } + + return numBytesRead; +} + +const qint64 PACKET_READ_ERROR = -1; + +qint64 PacketPayload::read(char* dest, qint64 maxSize, qint64 index) { + if (index >= _maxBytes) { + // we were passed a bad index, return error + return PACKET_READ_ERROR; + } + + // we're either reading what is left from the index or what was asked to be read + qint64 numBytesToRead = std::min(_maxSize - index, maxSize); + + if (numBytesToRead > 0) { + // read out the data + memcpy(dest, _data + index, numBytesToRead); + } + + return numBytesToRead; +} diff --git a/libraries/networking/src/PacketPayload.h b/libraries/networking/src/PacketPayload.h new file mode 100644 index 0000000000..1e84c182d4 --- /dev/null +++ b/libraries/networking/src/PacketPayload.h @@ -0,0 +1,42 @@ +// +// PacketPayload.h +// libraries/networking/src +// +// Created by Stephen Birarda on 07/06/15. +// Copyright 2015 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#ifndef hifi_PacketPayload_h +#define hifi_PacketPayload_h + +#pragma once + +#include + +class PacketPayload : public QIODevice { +public: + PacketPayload(char* data, qint64 maxBytes); + + qint64 write(const char* src, qint64 srcBytes, qint64 index = 0); + qint64 append(const char* src, qint64 srcBytes); + + qint64 read(char* dest, qint64 maxSize, qint64 index = 0); + qint64 readNext(char* dest, qint64 maxSize); + +protected: + virtual qint64 writeData(const char* data, qint64 maxSize) { return append(data, maxSize) }; + virtual qint64 readData(const char* data, qint64 maxSize) { return readNext(data, maxSize) }; + +private: + char* _data; + + qint64 _writeIndex = 0; + qint64 _readIndex = 0; + + qint64 _maxBytes = 0; +}; + +#endif // hifi_PacketByteArray_h