DarkflameServer/dNet/PacketHandler.h

#ifndef __RaknetPacket_H__
#define __RaknetPacket_H__

#include <cstdint>
#include <memory>
#include <functional>
#include <map>
#include "MessageIdentifiers.h"
#include <RakNetTypes.h>

struct Packet;
namespace RakNet {
	class BitStream;
}

struct RaknetPacket {
	DefaultMessageIDTypes messageID = static_cast<DefaultMessageIDTypes>(-1);
	SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;

	RaknetPacket() = default;
	RaknetPacket(DefaultMessageIDTypes _messageID) : messageID{_messageID} {};

	void Serialize(RakNet::BitStream& bitStream) const;
	bool Deserialize(RakNet::BitStream& bitStream);

	virtual ~RaknetPacket() = default;
	virtual void Handle() {};
};

namespace PacketHandler {
	struct InternalPing : public RaknetPacket {
		void Handle() override {};
		InternalPing() : RaknetPacket(ID_INTERNAL_PING) {}
	};

	struct Ping : public RaknetPacket {
		void Handle() override {};
		Ping() : RaknetPacket(ID_PING) {}
	};

	struct PingOpenConnections : public RaknetPacket {
		void Handle() override {};
		PingOpenConnections() : RaknetPacket(ID_PING_OPEN_CONNECTIONS) {}
	};

	struct ConnectedPong : public RaknetPacket {
		void Handle() override {};
		ConnectedPong() : RaknetPacket(ID_CONNECTED_PONG) {}
	};

	struct ConnectionRequest : public RaknetPacket {
		void Handle() override {};
		ConnectionRequest() : RaknetPacket(ID_CONNECTION_REQUEST) {}
	};

	struct SecuredConnectionResponse : public RaknetPacket {
		void Handle() override {};
		SecuredConnectionResponse() : RaknetPacket(ID_SECURED_CONNECTION_RESPONSE) {}
	};

	struct SecuredConnectionConfirmation : public RaknetPacket {
		void Handle() override {};
		SecuredConnectionConfirmation() : RaknetPacket(ID_SECURED_CONNECTION_CONFIRMATION) {}
	};

	struct RPCMapping : public RaknetPacket {
		void Handle() override {};
		RPCMapping() : RaknetPacket(ID_RPC_MAPPING) {}
	};

	struct DetectLostConnections : public RaknetPacket {
		void Handle() override {};
		DetectLostConnections() : RaknetPacket(ID_DETECT_LOST_CONNECTIONS) {}
	};

	struct OpenConnectionRequest : public RaknetPacket {
		void Handle() override {};
		OpenConnectionRequest() : RaknetPacket(ID_OPEN_CONNECTION_REQUEST) {}
	};

	struct OpenConnectionReply : public RaknetPacket {
		void Handle() override {};
		OpenConnectionReply() : RaknetPacket(ID_OPEN_CONNECTION_REPLY) {}
	};

	struct RPC : public RaknetPacket {
		void Handle() override {};
		RPC() : RaknetPacket(ID_RPC) {}
	};

	struct RPCReply : public RaknetPacket {
		void Handle() override {};
		RPCReply() : RaknetPacket(ID_RPC_REPLY) {}
	};

	struct OutOfBandInternal : public RaknetPacket {
		void Handle() override {};
		OutOfBandInternal() : RaknetPacket(ID_OUT_OF_BAND_INTERNAL) {}
	};

	struct ConnectionRequestAccepted : public RaknetPacket {
		void Handle() override {};
		ConnectionRequestAccepted() : RaknetPacket(ID_CONNECTION_REQUEST_ACCEPTED) {}
	};

	struct ConnectionAttemptFailed : public RaknetPacket {
		void Handle() override {};
		ConnectionAttemptFailed() : RaknetPacket(ID_CONNECTION_ATTEMPT_FAILED) {}
	};

	struct AlreadyConnected : public RaknetPacket {
		void Handle() override {};
		AlreadyConnected() : RaknetPacket(ID_ALREADY_CONNECTED) {}
	};

	struct NewIncomingConnection : public RaknetPacket {
		void Handle() override {};
		NewIncomingConnection() : RaknetPacket(ID_NEW_INCOMING_CONNECTION) {}
	};

	struct NoFreeIncomingConnections : public RaknetPacket {
		void Handle() override {};
		NoFreeIncomingConnections() : RaknetPacket(ID_NO_FREE_INCOMING_CONNECTIONS) {}
	};

	struct DisconnectionNotification : public RaknetPacket {
		void Handle() override {};
		DisconnectionNotification() : RaknetPacket(ID_DISCONNECTION_NOTIFICATION) {}
	};

	struct ConnectionLost : public RaknetPacket {
		void Handle() override {};
		ConnectionLost() : RaknetPacket(ID_CONNECTION_LOST) {}
	};

	struct RSAPublicKeyMismatch : public RaknetPacket {
		void Handle() override {};
		RSAPublicKeyMismatch() : RaknetPacket(ID_RSA_PUBLIC_KEY_MISMATCH) {}
	};

	struct ConnectionBanned : public RaknetPacket {
		void Handle() override {};
		ConnectionBanned() : RaknetPacket(ID_CONNECTION_BANNED) {}
	};

	struct InvalidPassword : public RaknetPacket {
		void Handle() override {};
		InvalidPassword() : RaknetPacket(ID_INVALID_PASSWORD) {}
	};

	struct ModifiedPacket : public RaknetPacket {
		void Handle() override {};
		ModifiedPacket() : RaknetPacket(ID_MODIFIED_PACKET) {}
	};

	struct Timestamp : public RaknetPacket {
		void Handle() override {};
		Timestamp() : RaknetPacket(ID_TIMESTAMP) {}
	};

	struct Pong : public RaknetPacket {
		void Handle() override {};
		Pong() : RaknetPacket(ID_PONG) {}
	};

	struct AdvertiseSystem : public RaknetPacket {
		void Handle() override {};
		AdvertiseSystem() : RaknetPacket(ID_ADVERTISE_SYSTEM) {}
	};

	struct RemoteDisconnectionNotification : public RaknetPacket {
		void Handle() override {};
		RemoteDisconnectionNotification() : RaknetPacket(ID_REMOTE_DISCONNECTION_NOTIFICATION) {}
	};

	struct RemoteConnectionLost : public RaknetPacket {
		void Handle() override {};
		RemoteConnectionLost() : RaknetPacket(ID_REMOTE_CONNECTION_LOST) {}
	};

	struct RemoteNewIncomingConnection : public RaknetPacket {
		void Handle() override {};
		RemoteNewIncomingConnection() : RaknetPacket(ID_REMOTE_NEW_INCOMING_CONNECTION) {}
	};

	struct DownloadProgress : public RaknetPacket {
		void Handle() override {};
		DownloadProgress() : RaknetPacket(ID_DOWNLOAD_PROGRESS) {}
	};

	struct FileListTransferHeader : public RaknetPacket {
		void Handle() override {};
		FileListTransferHeader() : RaknetPacket(ID_FILE_LIST_TRANSFER_HEADER) {}
	};

	struct FileListTransferFile : public RaknetPacket {
		void Handle() override {};
		FileListTransferFile() : RaknetPacket(ID_FILE_LIST_TRANSFER_FILE) {}
	};

	struct DDTDownloadRequest : public RaknetPacket {
		void Handle() override {};
		DDTDownloadRequest() : RaknetPacket(ID_DDT_DOWNLOAD_REQUEST) {}
	};

	struct TransportString : public RaknetPacket {
		void Handle() override {};
		TransportString() : RaknetPacket(ID_TRANSPORT_STRING) {}
	};

	struct ReplicaManagerConstruction : public RaknetPacket {
		void Handle() override {};
		ReplicaManagerConstruction() : RaknetPacket(ID_REPLICA_MANAGER_CONSTRUCTION) {}
	};

	struct ReplicaManagerDestruction : public RaknetPacket {
		void Handle() override {};
		ReplicaManagerDestruction() : RaknetPacket(ID_REPLICA_MANAGER_DESTRUCTION) {}
	};

	struct ReplicaManagerScopeChange : public RaknetPacket {
		void Handle() override {};
		ReplicaManagerScopeChange() : RaknetPacket(ID_REPLICA_MANAGER_SCOPE_CHANGE) {}
	};

	struct ReplicaManagerSerialize : public RaknetPacket {
		void Handle() override {};
		ReplicaManagerSerialize() : RaknetPacket(ID_REPLICA_MANAGER_SERIALIZE) {}
	};

	struct ReplicaManagerDownloadStarted : public RaknetPacket {
		void Handle() override {};
		ReplicaManagerDownloadStarted() : RaknetPacket(ID_REPLICA_MANAGER_DOWNLOAD_STARTED) {}
	};

	struct ReplicaManagerDownloadComplete : public RaknetPacket {
		void Handle() override {};
		ReplicaManagerDownloadComplete() : RaknetPacket(ID_REPLICA_MANAGER_DOWNLOAD_COMPLETE) {}
	};

	struct ConnectionGraphRequest : public RaknetPacket {
		void Handle() override {};
		ConnectionGraphRequest() : RaknetPacket(ID_CONNECTION_GRAPH_REQUEST) {}
	};

	struct ConnectionGraphReply : public RaknetPacket {
		void Handle() override {};
		ConnectionGraphReply() : RaknetPacket(ID_CONNECTION_GRAPH_REPLY) {}
	};

	struct ConnectionGraphUpdate : public RaknetPacket {
		void Handle() override {};
		ConnectionGraphUpdate() : RaknetPacket(ID_CONNECTION_GRAPH_UPDATE) {}
	};

	struct ConnectionGraphNewConnection : public RaknetPacket {
		void Handle() override {};
		ConnectionGraphNewConnection() : RaknetPacket(ID_CONNECTION_GRAPH_NEW_CONNECTION) {}
	};

	struct ConnectionGraphConnectionLost : public RaknetPacket {
		void Handle() override {};
		ConnectionGraphConnectionLost() : RaknetPacket(ID_CONNECTION_GRAPH_CONNECTION_LOST) {}
	};

	struct ConnectionGraphDisconnectionNotification : public RaknetPacket {
		void Handle() override {};
		ConnectionGraphDisconnectionNotification() : RaknetPacket(ID_CONNECTION_GRAPH_DISCONNECTION_NOTIFICATION) {}
	};

	struct RouteAndMulticast : public RaknetPacket {
		void Handle() override {};
		RouteAndMulticast() : RaknetPacket(ID_ROUTE_AND_MULTICAST) {}
	};

	struct RakVoiceOpenChannelRequest : public RaknetPacket {
		void Handle() override {};
		RakVoiceOpenChannelRequest() : RaknetPacket(ID_RAKVOICE_OPEN_CHANNEL_REQUEST) {}
	};

	struct RakVoiceOpenChannelReply : public RaknetPacket {
		void Handle() override {};
		RakVoiceOpenChannelReply() : RaknetPacket(ID_RAKVOICE_OPEN_CHANNEL_REPLY) {}
	};

	struct RakVoiceCloseChannel : public RaknetPacket {
		void Handle() override {};
		RakVoiceCloseChannel() : RaknetPacket(ID_RAKVOICE_CLOSE_CHANNEL) {}
	};

	struct RakVoiceData : public RaknetPacket {
		void Handle() override {};
		RakVoiceData() : RaknetPacket(ID_RAKVOICE_DATA) {}
	};

	struct AutopatcherGetChangelistSinceDate : public RaknetPacket {
		void Handle() override {};
		AutopatcherGetChangelistSinceDate() : RaknetPacket(ID_AUTOPATCHER_GET_CHANGELIST_SINCE_DATE) {}
	};

	struct AutopatcherCreationList : public RaknetPacket {
		void Handle() override {};
		AutopatcherCreationList() : RaknetPacket(ID_AUTOPATCHER_CREATION_LIST) {}
	};

	struct AutopatcherDeletionList : public RaknetPacket {
		void Handle() override {};
		AutopatcherDeletionList() : RaknetPacket(ID_AUTOPATCHER_DELETION_LIST) {}
	};

	struct AutopatcherGetPatch : public RaknetPacket {
		void Handle() override {};
		AutopatcherGetPatch() : RaknetPacket(ID_AUTOPATCHER_GET_PATCH) {}
	};

	struct AutopatcherPatchList : public RaknetPacket {
		void Handle() override {};
		AutopatcherPatchList() : RaknetPacket(ID_AUTOPATCHER_PATCH_LIST) {}
	};

	struct AutopatcherRepositoryFatalError : public RaknetPacket {
		void Handle() override {};
		AutopatcherRepositoryFatalError() : RaknetPacket(ID_AUTOPATCHER_REPOSITORY_FATAL_ERROR) {}
	};

	struct AutopatcherFinishedInternal : public RaknetPacket {
		void Handle() override {};
		AutopatcherFinishedInternal() : RaknetPacket(ID_AUTOPATCHER_FINISHED_INTERNAL) {}
	};

	struct AutopatcherFinished : public RaknetPacket {
		void Handle() override {};
		AutopatcherFinished() : RaknetPacket(ID_AUTOPATCHER_FINISHED) {}
	};

	struct AutopatcherRestartApplication : public RaknetPacket {
		void Handle() override {};
		AutopatcherRestartApplication() : RaknetPacket(ID_AUTOPATCHER_RESTART_APPLICATION) {}
	};

	struct NATpunchtroughRequest : public RaknetPacket {
		void Handle() override {};
		NATpunchtroughRequest() : RaknetPacket(ID_NAT_PUNCHTHROUGH_REQUEST) {}
	};

	struct NATTargetNotConnected : public RaknetPacket {
		void Handle() override {};
		NATTargetNotConnected() : RaknetPacket(ID_NAT_TARGET_NOT_CONNECTED) {}
	};

	struct NATTargetConnectionLost : public RaknetPacket {
		void Handle() override {};
		NATTargetConnectionLost() : RaknetPacket(ID_NAT_TARGET_CONNECTION_LOST) {}
	};

	struct NATConnectAtTime : public RaknetPacket {
		void Handle() override {};
		NATConnectAtTime() : RaknetPacket(ID_NAT_CONNECT_AT_TIME) {}
	};

	struct NATSendOfflineMessageAtTime : public RaknetPacket {
		void Handle() override {};
		NATSendOfflineMessageAtTime() : RaknetPacket(ID_NAT_SEND_OFFLINE_MESSAGE_AT_TIME) {}
	};

	struct NATInProgress : public RaknetPacket {
		void Handle() override {};
		NATInProgress() : RaknetPacket(ID_NAT_IN_PROGRESS) {}
	};

	struct DatabaseQueryRequest : public RaknetPacket {
		void Handle() override {};
		DatabaseQueryRequest() : RaknetPacket(ID_DATABASE_QUERY_REQUEST) {}
	};

	struct DatabaseUpdateRow : public RaknetPacket {
		void Handle() override {};
		DatabaseUpdateRow() : RaknetPacket(ID_DATABASE_UPDATE_ROW) {}
	};

	struct DatabaseRemoveRow : public RaknetPacket {
		void Handle() override {};
		DatabaseRemoveRow() : RaknetPacket(ID_DATABASE_REMOVE_ROW) {}
	};

	struct DatabaseQueryReply : public RaknetPacket {
		void Handle() override {};
		DatabaseQueryReply() : RaknetPacket(ID_DATABASE_QUERY_REPLY) {}
	};

	struct DatabaseUnknownTable : public RaknetPacket {
		void Handle() override {};
		DatabaseUnknownTable() : RaknetPacket(ID_DATABASE_UNKNOWN_TABLE) {}
	};

	struct DatabaseIncorrectPassword : public RaknetPacket {
		void Handle() override {};
		DatabaseIncorrectPassword() : RaknetPacket(ID_DATABASE_INCORRECT_PASSWORD) {}
	};

	struct ReadyEventSet : public RaknetPacket {
		void Handle() override {};
		ReadyEventSet() : RaknetPacket(ID_READY_EVENT_SET) {}
	};

	struct ReadyEventUnset : public RaknetPacket {
		void Handle() override {};
		ReadyEventUnset() : RaknetPacket(ID_READY_EVENT_UNSET) {}
	};

	struct ReadyEventAllSet : public RaknetPacket {
		void Handle() override {};
		ReadyEventAllSet() : RaknetPacket(ID_READY_EVENT_ALL_SET) {}
	};

	struct ReadyEventQuery : public RaknetPacket {
		void Handle() override {};
		ReadyEventQuery() : RaknetPacket(ID_READY_EVENT_QUERY) {}
	};

	struct LobbyGeneral : public RaknetPacket {
		void Handle() override {};
		LobbyGeneral() : RaknetPacket(ID_LOBBY_GENERAL) {}
	};

	struct AutoRPCCall : public RaknetPacket {
		void Handle() override {};
		AutoRPCCall() : RaknetPacket(ID_AUTO_RPC_CALL) {}
	};

	struct AutoRPCRemoteIndex : public RaknetPacket {
		void Handle() override {};
		AutoRPCRemoteIndex() : RaknetPacket(ID_AUTO_RPC_REMOTE_INDEX) {}
	};

	struct AutoRPCUnknownRemoteIndex : public RaknetPacket {
		void Handle() override {};
		AutoRPCUnknownRemoteIndex() : RaknetPacket(ID_AUTO_RPC_UNKNOWN_REMOTE_INDEX) {}
	};

	struct RPCRemoteError : public RaknetPacket {
		void Handle() override {};
		RPCRemoteError() : RaknetPacket(ID_RPC_REMOTE_ERROR) {}
	};

	struct UserPacketEnum : public RaknetPacket {
		void Handle() override {};
		UserPacketEnum() : RaknetPacket(ID_USER_PACKET_ENUM) {}
	};

	extern std::map<DefaultMessageIDTypes, std::function<std::unique_ptr<RaknetPacket>()>> g_Handlers;

	void HandlePacket(RakNet::BitStream& inStream, const SystemAddress& sysAddr);
}

#endif // __RaknetPacket_H__