123 lines
4.0 KiB
C++
123 lines
4.0 KiB
C++
|
|
#include "TcpBase.hpp"
|
|
|
|
#include <sys/socket.h>
|
|
#include <string.h>
|
|
|
|
TcpBase::TcpBase(LoggerService* logger) : logger_(logger) {
|
|
|
|
}
|
|
|
|
TcpBase::~TcpBase() {
|
|
|
|
}
|
|
|
|
ssize_t TcpBase::tcpRead(int fd, void* buffer, size_t maxBytes) {
|
|
|
|
// read header first
|
|
char header[kHeaderSize];
|
|
ssize_t bytesReceived = receiveFull(fd, &header, kHeaderSize);
|
|
if(bytesReceived != kHeaderSize) {
|
|
logger_->log("TcpNetworker", LogFlag::Error, "Unable to receive header.");
|
|
return -1;
|
|
}
|
|
|
|
// parse header: 4 bytes payload length 4 bytes message type
|
|
uint32_t payloadLength;
|
|
uint32_t messageType;
|
|
memcpy(&payloadLength, header, sizeof(payloadLength));
|
|
memcpy(&messageType, header + sizeof(payloadLength), sizeof(messageType));
|
|
size_t payloadLengthS = static_cast<size_t>(payloadLength);
|
|
|
|
if(maxBytes < payloadLength) {
|
|
logger_->log("TcpNetworker", LogFlag::Warning,
|
|
"Payload length is larger than buffer size; payload may be truncated.");
|
|
payloadLengthS = maxBytes;
|
|
}
|
|
|
|
// read payload
|
|
bytesReceived = receiveFull(fd, buffer, payloadLengthS);
|
|
if(bytesReceived != payloadLengthS) {
|
|
logger_->log("TcpNetworker", LogFlag::Error, "Did not receive amount of expected data.");
|
|
}
|
|
return bytesReceived;
|
|
|
|
} // TODO: tcp read should accept a header struct as an argument and write the header data into the struct
|
|
// can be as simple as a union with a char[8] if you want;
|
|
|
|
ssize_t TcpBase::tcpTimedRead(int fd, void* buffer, size_t maxBytes, int timeoutPlaceholder) {
|
|
return 0;
|
|
}
|
|
|
|
ssize_t TcpBase::tcpSend(int fd, const void* buffer, size_t numBytes) {
|
|
|
|
// assemble header
|
|
char header[kHeaderSize];
|
|
uint32_t payloadLength = static_cast<uint32_t>(numBytes & 0xffffffffffffffff);
|
|
uint32_t messageType = 0; // placeholder
|
|
memcpy(header, &payloadLength, sizeof(payloadLength));
|
|
memcpy(header + sizeof(payloadLength), &messageType, sizeof(messageType));
|
|
|
|
// send header
|
|
ssize_t bytesSent = sendFull(fd, header, kHeaderSize);
|
|
if(bytesSent != kHeaderSize) {
|
|
logger_->log("TcpNetworker", LogFlag::Error, "Error sending header.");
|
|
}
|
|
|
|
// send payload
|
|
bytesSent = sendFull(fd, buffer, numBytes);
|
|
if(bytesSent != numBytes) {
|
|
logger_->log("TcpNetworker", LogFlag::Error, "Error sending payload.");
|
|
}
|
|
return bytesSent;
|
|
}
|
|
|
|
ssize_t TcpBase::tcpTimedSend(int fd, const void* backuffer, size_t numBytes, int timeoutPlaceholder) {
|
|
return 0;
|
|
}
|
|
|
|
ssize_t TcpBase::receiveHeader(int fd, void* buffer, size_t maxBytes) {
|
|
return 0;
|
|
}
|
|
|
|
ssize_t TcpBase::receivePayload(int fd, void* buffer, size_t maxBytes) {
|
|
return 0;
|
|
}
|
|
|
|
ssize_t TcpBase::sendHeader(int fd, const void* buffer, size_t maxBytes) {
|
|
return 0;
|
|
}
|
|
|
|
ssize_t TcpBase::sendPayload(int fd, const void* buffer, size_t maxBytes) {
|
|
return 0;
|
|
}
|
|
|
|
ssize_t TcpBase::receiveFull(int fd, void* buffer, size_t maxBytes) {
|
|
ssize_t total = 0;
|
|
// attempt to receive maxBytes bytes; continue receiving until we have received maxBytes bytes
|
|
while(total < maxBytes) {
|
|
ssize_t bytesReceived = recv(fd, static_cast<char*>(buffer) + total, maxBytes - total, 0);
|
|
if (bytesReceived <= 0) return bytesReceived; // error or connection closed
|
|
total += bytesReceived;
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
ssize_t TcpBase::sendFull(int fd, const void* buffer, size_t numBytes) {
|
|
ssize_t total = 0;
|
|
// attempt to receive maxBytes bytes; continue receiving until we have received maxBytes bytes
|
|
while(total < numBytes) {
|
|
ssize_t bytesSent = send(fd, static_cast<const char*>(buffer) + total, numBytes - total, 0);
|
|
|
|
// last arg is flags, 0=default
|
|
// MSG_PEEK: read without consuming the message from the queue
|
|
// MSG_WAITALL: block until all of the specified size is received
|
|
// MSG_DONTWAIT: non-blocking receive, returns -1 immediately if queue is empty
|
|
|
|
if (bytesSent <= 0) return bytesSent; // error or connection closed
|
|
total += bytesSent;
|
|
}
|
|
return total;
|
|
}
|