phosit
78652aa92c
The user doesn't have to fiddle with `std::shared_ptr`. And two (more unrelated) things: use `std::unordered_map`, use a `std::find_if` in the callback. Comments By: @vladislavbelov, @Stan Differential Revision: https://code.wildfiregames.com/D5239 This was SVN commit r28048.
128 lines
3.5 KiB
C++
128 lines
3.5 KiB
C++
/* Copyright (C) 2024 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef NETFILETRANSFER_H
|
|
#define NETFILETRANSFER_H
|
|
|
|
#include <functional>
|
|
#include <map>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
class CNetMessage;
|
|
class CFileTransferResponseMessage;
|
|
class CFileTransferDataMessage;
|
|
class CFileTransferAckMessage;
|
|
class INetSession;
|
|
|
|
// Assume this is sufficiently less than MTU that packets won't get
|
|
// fragmented or dropped.
|
|
static const size_t DEFAULT_FILE_TRANSFER_PACKET_SIZE = 1024;
|
|
|
|
// To improve performance without flooding ENet's internal buffers,
|
|
// maintain a small number of in-flight packets.
|
|
// Pick numbers so that with e.g. 200ms round-trip latency
|
|
// we can hopefully get windowSize*packetSize*1000/200 = 160KB/s bandwidth
|
|
static const size_t DEFAULT_FILE_TRANSFER_WINDOW_SIZE = 32;
|
|
|
|
// Some arbitrary limit to make it slightly harder to use up all of someone's RAM
|
|
static const size_t MAX_FILE_TRANSFER_SIZE = 8*MiB;
|
|
|
|
/**
|
|
* Handles transferring files between clients and servers.
|
|
*/
|
|
class CNetFileTransferer
|
|
{
|
|
public:
|
|
CNetFileTransferer(INetSession* session)
|
|
: m_Session(session), m_NextRequestID(1), m_LastProgressReportTime(0)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Should be called when a message is received from the network.
|
|
* Returns INFO::SKIPPED if the message is not one that this class handles.
|
|
* Returns INFO::OK if the message is handled successfully,
|
|
* or ERR::FAIL if handled unsuccessfully.
|
|
*/
|
|
Status HandleMessageReceive(const CNetMessage& message);
|
|
|
|
/**
|
|
* Registers a file-receiving task.
|
|
*/
|
|
void StartTask(std::function<void(std::string)> task);
|
|
|
|
/**
|
|
* Registers data to be sent in response to a request.
|
|
* (Callers are expected to have their own mechanism for receiving
|
|
* requests and deciding what to respond with.)
|
|
*/
|
|
void StartResponse(u32 requestID, const std::string& data);
|
|
|
|
/**
|
|
* Call frequently (e.g. once per frame) to trigger any necessary
|
|
* packet processing.
|
|
*/
|
|
void Poll();
|
|
|
|
private:
|
|
Status OnFileTransferResponse(const CFileTransferResponseMessage& message);
|
|
Status OnFileTransferData(const CFileTransferDataMessage& message);
|
|
Status OnFileTransferAck(const CFileTransferAckMessage& message);
|
|
|
|
/**
|
|
* Asynchronous file-sending task.
|
|
*/
|
|
struct CNetFileSendTask
|
|
{
|
|
u32 requestID;
|
|
std::string buffer;
|
|
size_t offset;
|
|
size_t maxWindowSize;
|
|
size_t packetsInFlight;
|
|
};
|
|
|
|
INetSession* m_Session;
|
|
|
|
u32 m_NextRequestID;
|
|
|
|
|
|
struct AsyncFileReceiveTask
|
|
{
|
|
/**
|
|
* Called when m_Buffer contains the full received data.
|
|
*/
|
|
std::function<void(std::string)> onComplete;
|
|
|
|
// TODO: Ought to have a failure channel, e.g. when the session drops or there's another error.
|
|
|
|
size_t length{0};
|
|
|
|
std::string buffer;
|
|
};
|
|
|
|
using FileReceiveTasksMap = std::unordered_map<u32, AsyncFileReceiveTask>;
|
|
FileReceiveTasksMap m_FileReceiveTasks;
|
|
|
|
using FileSendTasksMap = std::map<u32, CNetFileSendTask>;
|
|
FileSendTasksMap m_FileSendTasks;
|
|
|
|
double m_LastProgressReportTime;
|
|
};
|
|
|
|
#endif // NETFILETRANSFER_H
|