Skip to content

Instantly share code, notes, and snippets.

@Amanieu

Amanieu/default.diff

Created March 17, 2014 23:38
Show Gist options
  • Save Amanieu/9610672 to your computer and use it in GitHub Desktop.
Save Amanieu/9610672 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
default.diff
diff --git a/src/common/IPC.h b/src/common/IPC.h
index d494e2f..f9b60d2 100644
--- a/src/common/IPC.h
+++ b/src/common/IPC.h
@@ -496,7 +496,7 @@ template<> struct SerializeTraits<SharedMemory> {
};
// Message ID to indicate an RPC return
-const uint32_t ID_RETURN = 0xffffffffu;
+const uint32_t ID_RETURN = 0xffffffff;
// Combine a major and minor ID into a single number
template<uint16_t Major, uint16_t Minor> struct Id {
@@ -504,7 +504,71 @@ template<uint16_t Major, uint16_t Minor> struct Id {
value = (Major << 16) + Minor
};
};
-#define IPC_ID(major, minor) ((((uint16_t)major) << 16) + ((uint16_t)minor))
+
+// An IPC channel wraps a socket and provides additional support for sending
+// synchronous typed messages over it.
+class Channel {
+public:
+ Channel()
+ : counter(0) {}
+ Channel(Socket socket)
+ : socket(std::move(socket)), counter(0) {}
+ explicit operator bool() const
+ {
+ return bool(socket);
+ }
+
+ // Wrappers around socket functions
+ void SendMsg(const Writer& writer) const
+ {
+ socket.SendMsg(writer);
+ }
+ Reader RecvMsg() const
+ {
+ return socket.RecvMsg();
+ }
+
+ // Generate a unique message key to match messages with replies
+ uint32_t GenMsgKey()
+ {
+ return counter++;
+ }
+
+ // Wait for a synchronous message reply, returns the message ID and contents
+ std::pair<uint32_t, Reader> RecvReplyMsg(uint32_t key)
+ {
+ // If we have already recieved a reply for this key, just return that
+ auto it = replies.find(key);
+ if (it != replies.end()) {
+ Reader reader = std::move(it->second);
+ replies.erase(it);
+ return {ID_RETURN, std::move(reader)};
+ }
+
+ // Otherwise handle incoming messages until we find the reply we want
+ while (true) {
+ Reader reader = RecvMsg();
+
+ // Is this a reply?
+ uint32_t id = reader.Read<uint32_t>();
+ if (id != ID_RETURN)
+ return {id, std::move(reader)};
+
+ // Is this the reply we are expecting?
+ uint32_t msg_key = reader.Read<uint32_t>();
+ if (msg_key == key)
+ return {ID_RETURN, std::move(reader)};
+
+ // Save the reply for later
+ replies.emplace(msg_key, std::move(reader));
+ }
+ }
+
+private:
+ Socket socket;
+ uint32_t counter;
+ std::unordered_map<uint32_t, Reader> replies;
+};
// Asynchronous message which does not wait for a reply
template<typename Id, typename... T> struct Message {
@@ -561,7 +625,7 @@ template<typename... T> struct MapTuple<std::tuple<T...>> {
};
// Implementations of SendMsg for Message and SyncMessage
-template<typename Func, typename Id, typename... MsgArgs, typename... Args> void SendMsg(const Socket& socket, Func&&, Message<Id, MsgArgs...>, Args&&... args)
+template<typename Func, typename Id, typename... MsgArgs, typename... Args> void SendMsg(const Channel& channel, Func&&, Message<Id, MsgArgs...>, Args&&... args)
{
typedef Message<Id, MsgArgs...> Message;
static_assert(sizeof...(Args) == std::tuple_size<typename Message::Inputs>::value, "Incorrect number of arguments for IPC::SendMsg");
@@ -569,21 +633,24 @@ template<typename Func, typename Id, typename... MsgArgs, typename... Args> void
Writer writer;
writer.Write<uint32_t>(Message::id);
SerializeArgs(Util::TypeListFromTuple<typename Message::Inputs>(), writer, std::forward<Args>(args)...);
- socket.SendMsg(writer);
+ channel.SendMsg(writer);
}
-template<typename Func, typename Msg, typename Reply, typename... Args> void SendMsg(const Socket& socket, Func&& messageHandler, SyncMessage<Msg, Reply>, Args&&... args)
+template<typename Func, typename Msg, typename Reply, typename... Args> void SendMsg(const Channel& channel, Func&& messageHandler, SyncMessage<Msg, Reply>, Args&&... args)
{
typedef SyncMessage<Msg, Reply> Message;
static_assert(sizeof...(Args) == std::tuple_size<typename Message::Inputs>::value + std::tuple_size<typename Message::Outputs>::value, "Incorrect number of arguments for IPC::SendMsg");
Writer writer;
writer.Write<uint32_t>(Message::id);
+ uint32_t key = channel.GenMsgKey();
+ writer.Write<uint32_t>(key);
SerializeArgs(Util::TypeListFromTuple<typename Message::Inputs>(), writer, std::forward<Args>(args)...);
- socket.SendMsg(writer);
+ channel.SendMsg(writer);
while (true) {
- Reader reader = socket.RecvMsg();
- uint32_t id = reader.Read<uint32_t>();
+ Reader reader;
+ uint32_t id;
+ std::tie(reader, id) = channel.RecvReplyMsg();
if (id == ID_RETURN) {
auto out = std::forward_as_tuple(std::forward<Args>(args)...);
FillTuple<std::tuple_size<typename Message::Inputs>::value>(Util::TypeListFromTuple<typename Message::Outputs>(), out, reader);
@@ -594,7 +661,7 @@ template<typename Func, typename Msg, typename Reply, typename... Args> void Sen
}
// Implementations of HandleMsg for Message and SyncMessage
-template<typename Func, typename Id, typename... MsgArgs> void HandleMsg(const Socket&, Message<Id, MsgArgs...>, IPC::Reader reader, Func&& func)
+template<typename Func, typename Id, typename... MsgArgs> void HandleMsg(const Channel&, Message<Id, MsgArgs...>, IPC::Reader reader, Func&& func)
{
typedef Message<Id, MsgArgs...> Message;
@@ -602,10 +669,11 @@ template<typename Func, typename Id, typename... MsgArgs> void HandleMsg(const S
FillTuple<0>(Util::TypeListFromTuple<typename Message::Inputs>(), inputs, reader);
Util::apply(std::forward<Func>(func), std::move(inputs));
}
-template<typename Func, typename Msg, typename Reply> void HandleMsg(const Socket& socket, SyncMessage<Msg, Reply>, IPC::Reader reader, Func&& func)
+template<typename Func, typename Msg, typename Reply> void HandleMsg(const Channel& channel, SyncMessage<Msg, Reply>, IPC::Reader reader, Func&& func)
{
typedef SyncMessage<Msg, Reply> Message;
+ uint32_t key = reader.Read<uint32_t>();
typename MapTuple<typename Message::Inputs>::type inputs;
typename Message::Outputs outputs;
FillTuple<0>(Util::TypeListFromTuple<typename Message::Inputs>(), inputs, reader);
@@ -613,25 +681,26 @@ template<typename Func, typename Msg, typename Reply> void HandleMsg(const Socke
Writer writer;
writer.Write<uint32_t>(ID_RETURN);
+ writer.Write<uint32_t>(key);
SerializeTuple(Util::TypeListFromTuple<typename Message::Outputs>(), writer, std::move(outputs));
- socket.SendMsg(writer);
+ channel.SendMsg(writer);
}
} // namespace detail
-// Send a message to the given socket. If the message is synchronous then messageHandler is invoked for all
+// Send a message to the given channel. If the message is synchronous then messageHandler is invoked for all
// message that are recieved until ID_RETURN is recieved. Values returned by a synchronous message are
// returned through reference parameters.
-template<typename Msg, typename Func, typename... Args> void SendMsg(const Socket& socket, Func&& messageHandler, Args&&... args)
+template<typename Msg, typename Func, typename... Args> void SendMsg(const Channel& channel, Func&& messageHandler, Args&&... args)
{
- detail::SendMsg(socket, messageHandler, Msg(), std::forward<Args>(args)...);
+ detail::SendMsg(channel, messageHandler, Msg(), std::forward<Args>(args)...);
}
// Handle an incoming message using a callback function (which can just be a lambda). If the message is
// synchronous then outputs values are written to using reference parameters.
-template<typename Msg, typename Func> void HandleMsg(const Socket& socket, Reader reader, Func&& func)
+template<typename Msg, typename Func> void HandleMsg(const Channel& channel, Reader reader, Func&& func)
{
- detail::HandleMsg(socket, Msg(), std::move(reader), std::forward<Func>(func));
+ detail::HandleMsg(channel, Msg(), std::move(reader), std::forward<Func>(func));
}
} // namespace IPC
diff --git a/src/engine/framework/CommonVMServices.cpp b/src/engine/framework/CommonVMServices.cpp
index 578cc40..496d5e5 100644
--- a/src/engine/framework/CommonVMServices.cpp
+++ b/src/engine/framework/CommonVMServices.cpp
@@ -43,22 +43,22 @@ namespace VM {
// Command Related
- void CommonVMServices::HandleCommandSyscall(int minor, IPC::Reader& reader, const IPC::Socket& socket) {
+ void CommonVMServices::HandleCommandSyscall(int minor, IPC::Reader& reader, const IPC::Channel& channel) {
switch(minor) {
case ADD_COMMAND:
- AddCommand(reader, socket);
+ AddCommand(reader, channel);
break;
case REMOVE_COMMAND:
- RemoveCommand(reader, socket);
+ RemoveCommand(reader, channel);
break;
case ENV_PRINT:
- EnvPrint(reader, socket);
+ EnvPrint(reader, channel);
break;
case ENV_EXECUTE_AFTER:
- EnvExecuteAfter(reader, socket);
+ EnvExecuteAfter(reader, channel);
break;
default:
@@ -87,8 +87,8 @@ namespace VM {
CommonVMServices& services;
};
- void CommonVMServices::AddCommand(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<AddCommandMsg>(socket, std::move(reader), [this](std::string name, std::string description){
+ void CommonVMServices::AddCommand(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<AddCommandMsg>(channel, std::move(reader), [this](std::string name, std::string description){
if (Cmd::CommandExists(name)) {
Log::Warn("VM '%s' tried to register command '%s' which is already registered", vmName, name);
return;
@@ -99,23 +99,23 @@ namespace VM {
});
}
- void CommonVMServices::RemoveCommand(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<RemoveCommandMsg>(socket, std::move(reader), [this](std::string name){
+ void CommonVMServices::RemoveCommand(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<RemoveCommandMsg>(channel, std::move(reader), [this](std::string name){
if (registeredCommands.find(name) != registeredCommands.end()) {
Cmd::RemoveCommand(name);
}
});
}
- void CommonVMServices::EnvPrint(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<EnvPrintMsg>(socket, std::move(reader), [this](std::string line){
+ void CommonVMServices::EnvPrint(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<EnvPrintMsg>(channel, std::move(reader), [this](std::string line){
//TODO allow it only if we are in a command?
Cmd::GetEnv()->Print(line);
});
}
- void CommonVMServices::EnvExecuteAfter(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<EnvExecuteAfterMsg>(socket, std::move(reader), [this](std::string commandText, bool parseCvars){
+ void CommonVMServices::EnvExecuteAfter(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<EnvExecuteAfterMsg>(channel, std::move(reader), [this](std::string commandText, bool parseCvars){
//TODO check that it isn't sending /quit or other bad commands (/lua "rootkit()")?
Cmd::GetEnv()->ExecuteAfter(commandText, parseCvars);
});
@@ -143,18 +143,18 @@ namespace VM {
CommonVMServices* services;
};
- void CommonVMServices::HandleCvarSyscall(int minor, IPC::Reader& reader, const IPC::Socket& socket) {
+ void CommonVMServices::HandleCvarSyscall(int minor, IPC::Reader& reader, const IPC::Channel& channel) {
switch(minor) {
case REGISTER_CVAR:
- RegisterCvar(reader, socket);
+ RegisterCvar(reader, channel);
break;
case GET_CVAR:
- GetCvar(reader, socket);
+ GetCvar(reader, channel);
break;
case SET_CVAR:
- SetCvar(reader, socket);
+ SetCvar(reader, channel);
break;
default:
@@ -162,23 +162,23 @@ namespace VM {
}
}
- void CommonVMServices::RegisterCvar(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<RegisterCvarMsg>(socket, std::move(reader), [this](Str::StringRef name, Str::StringRef description,
+ void CommonVMServices::RegisterCvar(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<RegisterCvarMsg>(channel, std::move(reader), [this](Str::StringRef name, Str::StringRef description,
int flags, Str::StringRef defaultValue){
// The registration of the cvar is made automatically when it is created
registeredCvars.emplace_back(new ProxyCvar(this, name, description, flags, defaultValue));
});
}
- void CommonVMServices::GetCvar(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<GetCvarMsg>(socket, std::move(reader), [&, this](Str::StringRef name, std::string& value){
+ void CommonVMServices::GetCvar(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<GetCvarMsg>(channel, std::move(reader), [&, this](Str::StringRef name, std::string& value){
//TODO check it is only looking at allowed cvars?
value = Cvar::GetValue(name);
});
}
- void CommonVMServices::SetCvar(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<SetCvarMsg>(socket, std::move(reader), [this](Str::StringRef name, Str::StringRef value){
+ void CommonVMServices::SetCvar(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<SetCvarMsg>(channel, std::move(reader), [this](Str::StringRef name, Str::StringRef value){
//TODO check it is only touching allowed cvars?
Cvar::SetValue(name, value);
});
@@ -196,14 +196,14 @@ namespace VM {
//TODO unregesiter cvars
}
- void CommonVMServices::Syscall(int major, int minor, IPC::Reader reader, const IPC::Socket& socket) {
+ void CommonVMServices::Syscall(int major, int minor, IPC::Reader reader, const IPC::Channel& channel) {
switch (major) {
case COMMAND:
- HandleCommandSyscall(minor, reader, socket);
+ HandleCommandSyscall(minor, reader, channel);
break;
case CVAR:
- HandleCvarSyscall(minor, reader, socket);
+ HandleCvarSyscall(minor, reader, channel);
break;
default:
diff --git a/src/engine/framework/CommonVMServices.h b/src/engine/framework/CommonVMServices.h
index 5dd3d97..045a638 100644
--- a/src/engine/framework/CommonVMServices.h
+++ b/src/engine/framework/CommonVMServices.h
@@ -46,7 +46,7 @@ namespace VM {
CommonVMServices(VMBase& vm, Str::StringRef vmName, int commandFlag);
~CommonVMServices();
- void Syscall(int major, int minor, IPC::Reader reader, const IPC::Socket& socket);
+ void Syscall(int major, int minor, IPC::Reader reader, const IPC::Channel& channel);
private:
std::string vmName;
@@ -55,12 +55,12 @@ namespace VM {
VMBase& GetVM();
// Command Related
- void HandleCommandSyscall(int minor, IPC::Reader& reader, const IPC::Socket& socket);
+ void HandleCommandSyscall(int minor, IPC::Reader& reader, const IPC::Channel& channel);
- void AddCommand(IPC::Reader& reader, const IPC::Socket& socket);
- void RemoveCommand(IPC::Reader& reader, const IPC::Socket& socket);
- void EnvPrint(IPC::Reader& reader, const IPC::Socket& socket);
- void EnvExecuteAfter(IPC::Reader& reader, const IPC::Socket& socket);
+ void AddCommand(IPC::Reader& reader, const IPC::Channel& channel);
+ void RemoveCommand(IPC::Reader& reader, const IPC::Channel& channel);
+ void EnvPrint(IPC::Reader& reader, const IPC::Channel& channel);
+ void EnvExecuteAfter(IPC::Reader& reader, const IPC::Channel& channel);
class ProxyCmd;
int commandFlag;
@@ -69,11 +69,11 @@ namespace VM {
std::unordered_map<std::string, uint64_t> registeredCommands;
// Cvar Related
- void HandleCvarSyscall(int minor, IPC::Reader& reader, const IPC::Socket& socket);
+ void HandleCvarSyscall(int minor, IPC::Reader& reader, const IPC::Channel& channel);
- void RegisterCvar(IPC::Reader& reader, const IPC::Socket& socket);
- void GetCvar(IPC::Reader& reader, const IPC::Socket& socket);
- void SetCvar(IPC::Reader& reader, const IPC::Socket& socket);
+ void RegisterCvar(IPC::Reader& reader, const IPC::Channel& channel);
+ void GetCvar(IPC::Reader& reader, const IPC::Channel& channel);
+ void SetCvar(IPC::Reader& reader, const IPC::Channel& channel);
class ProxyCvar;
std::vector<std::unique_ptr<ProxyCvar>> registeredCvars;
diff --git a/src/engine/framework/VirtualMachine.cpp b/src/engine/framework/VirtualMachine.cpp
index 2284b59..422dd48 100644
--- a/src/engine/framework/VirtualMachine.cpp
+++ b/src/engine/framework/VirtualMachine.cpp
@@ -325,6 +325,7 @@ int VMBase::Create(Str::StringRef name, vmType_t type)
// Create the socket pair to get the handle for ROOT_SOCKET
std::pair<IPC::Socket, IPC::Socket> pair = IPC::Socket::CreatePair();
+ IPC::Socket rootSocket;
if (type == TYPE_NACL || type == TYPE_NACL_DEBUG) {
std::tie(processHandle, rootSocket) = CreateNaClVM(std::move(pair), name, type == TYPE_NACL_DEBUG);
} else if (type == TYPE_NATIVE_EXE || type == TYPE_NATIVE_EXE_DEBUG) {
@@ -332,6 +333,7 @@ int VMBase::Create(Str::StringRef name, vmType_t type)
} else {
rootSocket = CreateInProcessNativeVM(std::move(pair), name, inProcess);
}
+ rootChannel = IPC::Channel(std::move(rootSocket));
vmType = type;
if (type == TYPE_NACL_DEBUG || type == TYPE_NATIVE_EXE_DEBUG)
@@ -339,7 +341,7 @@ int VMBase::Create(Str::StringRef name, vmType_t type)
// Read the ABI version from the root socket.
// If this fails, we assume the remote process failed to start
- IPC::Reader reader = rootSocket.RecvMsg();
+ IPC::Reader reader = rootChannel.RecvMsg();
Com_Printf("Loaded module with the NaCl ABI");
return reader.Read<uint32_t>();
}
@@ -377,7 +379,7 @@ void VMBase::Free()
if (!IsActive())
return;
- rootSocket.Close();
+ rootChannel = IPC::Channel();
if (vmType == TYPE_NACL || vmType == TYPE_NACL_DEBUG || vmType == TYPE_NATIVE_EXE || vmType == TYPE_NATIVE_EXE_DEBUG) {
#ifdef _WIN32
diff --git a/src/engine/framework/VirtualMachine.h b/src/engine/framework/VirtualMachine.h
index fa72d70..e0d1d15 100644
--- a/src/engine/framework/VirtualMachine.h
+++ b/src/engine/framework/VirtualMachine.h
@@ -76,8 +76,8 @@ public:
// Send a message to the VM
template<typename Msg, typename... Args> void SendMsg(Args&&... args) const
{
- IPC::SendMsg<Msg>(rootSocket, [this](uint32_t id, IPC::Reader reader) {
- Syscall(id, std::move(reader), rootSocket);
+ IPC::SendMsg<Msg>(rootChannel, [this](uint32_t id, IPC::Reader reader) {
+ Syscall(id, std::move(reader), rootChannel);
}, std::forward<Args>(args)...);
}
@@ -94,7 +94,7 @@ public:
protected:
// System call handler
- virtual void Syscall(uint32_t id, IPC::Reader reader, const IPC::Socket& socket) const = 0;
+ virtual void Syscall(uint32_t id, IPC::Reader reader, const IPC::Channel& channel) const = 0;
private:
void FreeInProcessVM();
@@ -106,7 +106,7 @@ private:
InProcessInfo inProcess;
// Common
- IPC::Socket rootSocket;
+ IPC::Channel rootChannel;
vmType_t vmType;
};
diff --git a/src/engine/server/server.h b/src/engine/server/server.h
index c9589eb..5305388 100644
--- a/src/engine/server/server.h
+++ b/src/engine/server/server.h
@@ -343,8 +343,8 @@ public:
void GameMessageRecieved(int clientNum, const char *buffer, int bufferSize, int commandTime);
private:
- virtual void Syscall(uint32_t id, IPC::Reader reader, const IPC::Socket& socket) const OVERRIDE FINAL;
- void QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socket) const;
+ virtual void Syscall(uint32_t id, IPC::Reader reader, const IPC::Channel& channel) const OVERRIDE FINAL;
+ void QVMSyscall(int index, IPC::Reader& reader, const IPC::Channel& channel) const;
mutable IPC::SharedMemory shmRegion;
diff --git a/src/engine/server/sv_game.cpp b/src/engine/server/sv_game.cpp
index 83d436f..c1852cb 100644
--- a/src/engine/server/sv_game.cpp
+++ b/src/engine/server/sv_game.cpp
@@ -715,32 +715,32 @@ void GameVM::GameMessageRecieved(int clientNum, const char *buffer, int bufferSi
//Com_Error(ERR_DROP, "GameVM::GameMessageRecieved not implemented");
}
-void GameVM::Syscall(uint32_t id, IPC::Reader reader, const IPC::Socket& socket) const
+void GameVM::Syscall(uint32_t id, IPC::Reader reader, const IPC::Channel& channel) const
{
int major = id >> 16;
int minor = id & 0xffff;
if (major == VM::QVM) {
- this->QVMSyscall(minor, reader, socket);
+ this->QVMSyscall(minor, reader, channel);
} else if (major < VM::LAST_COMMON_SYSCALL) {
- services->Syscall(major, minor, std::move(reader), socket);
+ services->Syscall(major, minor, std::move(reader), channel);
} else {
Com_Error(ERR_DROP, "Bad major game syscall number: %d", major);
}
}
-void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socket) const
+void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Channel& channel) const
{
switch (index) {
case G_PRINT:
- IPC::HandleMsg<PrintMsg>(socket, std::move(reader), [this](Str::StringRef text) {
+ IPC::HandleMsg<PrintMsg>(channel, std::move(reader), [this](Str::StringRef text) {
Com_Printf("%s", text.c_str());
});
break;
case G_ERROR:
- IPC::HandleMsg<ErrorMsg>(socket, std::move(reader), [this](Str::StringRef text) {
+ IPC::HandleMsg<ErrorMsg>(channel, std::move(reader), [this](Str::StringRef text) {
Com_Error(ERR_DROP, "%s", text.c_str());
});
break;
@@ -749,26 +749,26 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
Com_Error(ERR_DROP, "trap_Log not implemented");
case G_MILLISECONDS:
- IPC::HandleMsg<MillisecondsMsg>(socket, std::move(reader), [this](int& time) {
+ IPC::HandleMsg<MillisecondsMsg>(channel, std::move(reader), [this](int& time) {
time = Sys_Milliseconds();
});
break;
case G_SEND_CONSOLE_COMMAND:
- IPC::HandleMsg<SendConsoleCommandMsg>(socket, std::move(reader), [this](int when, Str::StringRef text) {
+ IPC::HandleMsg<SendConsoleCommandMsg>(channel, std::move(reader), [this](int when, Str::StringRef text) {
Cbuf_ExecuteText(when, text.c_str());
});
break;
case G_FS_FOPEN_FILE:
- IPC::HandleMsg<FSFOpenFileMsg>(socket, std::move(reader), [this](Str::StringRef filename, bool open, int fsMode, int& success, int& handle) {
+ IPC::HandleMsg<FSFOpenFileMsg>(channel, std::move(reader), [this](Str::StringRef filename, bool open, int fsMode, int& success, int& handle) {
fsMode_t mode = static_cast<fsMode_t>(fsMode);
success = FS_Game_FOpenFileByMode(filename.c_str(), open ? &handle : NULL, mode);
});
break;
case G_FS_READ:
- IPC::HandleMsg<FSReadMsg>(socket, std::move(reader), [this](int handle, int len, std::string& res) {
+ IPC::HandleMsg<FSReadMsg>(channel, std::move(reader), [this](int handle, int len, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
FS_Read(buffer.get(), len, handle);
res.assign(buffer.get(), len);
@@ -776,25 +776,25 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_FS_WRITE:
- IPC::HandleMsg<FSWriteMsg>(socket, std::move(reader), [this](int handle, Str::StringRef text, int& res) {
+ IPC::HandleMsg<FSWriteMsg>(channel, std::move(reader), [this](int handle, Str::StringRef text, int& res) {
res = FS_Write(text.c_str(), text.size(), handle);
});
break;
case G_FS_RENAME:
- IPC::HandleMsg<FSRenameMsg>(socket, std::move(reader), [this](Str::StringRef from, Str::StringRef to) {
+ IPC::HandleMsg<FSRenameMsg>(channel, std::move(reader), [this](Str::StringRef from, Str::StringRef to) {
FS_Rename(from.c_str(), to.c_str());
});
break;
case G_FS_FCLOSE_FILE:
- IPC::HandleMsg<FSFCloseFileMsg>(socket, std::move(reader), [this](int handle) {
+ IPC::HandleMsg<FSFCloseFileMsg>(channel, std::move(reader), [this](int handle) {
FS_FCloseFile(handle);
});
break;
case G_FS_GET_FILE_LIST:
- IPC::HandleMsg<FSGetFileListMsg>(socket, std::move(reader), [this](Str::StringRef path, Str::StringRef extension, int len, int& intRes, std::string& res) {
+ IPC::HandleMsg<FSGetFileListMsg>(channel, std::move(reader), [this](Str::StringRef path, Str::StringRef extension, int len, int& intRes, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
intRes = FS_GetFileList(path.c_str(), extension.c_str(), buffer.get(), len);
res.assign(buffer.get(), len);
@@ -802,115 +802,115 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_FS_FIND_PAK:
- IPC::HandleMsg<FSFindPakMsg>(socket, std::move(reader), [this](Str::StringRef pakName, bool& found) {
+ IPC::HandleMsg<FSFindPakMsg>(channel, std::move(reader), [this](Str::StringRef pakName, bool& found) {
found = FS::FindPak(pakName);
});
break;
case G_LOCATE_GAME_DATA1:
- IPC::HandleMsg<LocateGameDataMsg1>(socket, std::move(reader), [this](IPC::SharedMemory shm, int numEntities, int entitySize, int playerSize) {
+ IPC::HandleMsg<LocateGameDataMsg1>(channel, std::move(reader), [this](IPC::SharedMemory shm, int numEntities, int entitySize, int playerSize) {
shmRegion = std::move(shm);
SV_LocateGameData(shmRegion, numEntities, entitySize, playerSize);
});
break;
case G_LOCATE_GAME_DATA2:
- IPC::HandleMsg<LocateGameDataMsg2>(socket, std::move(reader), [this](int numEntities, int entitySize, int playerSize) {
+ IPC::HandleMsg<LocateGameDataMsg2>(channel, std::move(reader), [this](int numEntities, int entitySize, int playerSize) {
SV_LocateGameData(shmRegion, numEntities, entitySize, playerSize);
});
break;
case G_LINK_ENTITY:
- IPC::HandleMsg<LinkEntityMsg>(socket, std::move(reader), [this](int entityNum) {
+ IPC::HandleMsg<LinkEntityMsg>(channel, std::move(reader), [this](int entityNum) {
SV_LinkEntity(SV_GentityNum(entityNum));
});
break;
case G_UNLINK_ENTITY:
- IPC::HandleMsg<UnlinkEntityMsg>(socket, std::move(reader), [this](int entityNum) {
+ IPC::HandleMsg<UnlinkEntityMsg>(channel, std::move(reader), [this](int entityNum) {
SV_UnlinkEntity(SV_GentityNum(entityNum));
});
break;
case G_ENTITIES_IN_BOX:
- IPC::HandleMsg<EntitiesInBoxMsg>(socket, std::move(reader), [this](std::array<float, 3> mins, std::array<float, 3> maxs, int len, std::vector<int>& res) {
+ IPC::HandleMsg<EntitiesInBoxMsg>(channel, std::move(reader), [this](std::array<float, 3> mins, std::array<float, 3> maxs, int len, std::vector<int>& res) {
res.resize(len); //reserve doesn't guarantee that data() will return an array long enough
len = SV_AreaEntities(mins.data(), maxs.data(), res.data(), len);
});
break;
case G_ENTITY_CONTACT:
- IPC::HandleMsg<EntityContactMsg>(socket, std::move(reader), [this](std::array<float, 3> mins, std::array<float, 3> maxs, int entityNum, int& res) {
+ IPC::HandleMsg<EntityContactMsg>(channel, std::move(reader), [this](std::array<float, 3> mins, std::array<float, 3> maxs, int entityNum, int& res) {
const sharedEntity_t* ent = SV_GentityNum(entityNum);
res = SV_EntityContact(mins.data(), maxs.data(), ent, TT_AABB);
});
break;
case G_TRACE:
- IPC::HandleMsg<TraceMsg>(socket, std::move(reader), [this](std::array<float, 3> start, std::array<float, 3> mins, std::array<float, 3> maxs, std::array<float, 3> end, int passEntityNum, int contentMask, trace_t& res) {
+ IPC::HandleMsg<TraceMsg>(channel, std::move(reader), [this](std::array<float, 3> start, std::array<float, 3> mins, std::array<float, 3> maxs, std::array<float, 3> end, int passEntityNum, int contentMask, trace_t& res) {
SV_Trace(&res, start.data(), mins.data(), maxs.data(), end.data(), passEntityNum, contentMask, TT_AABB);
});
break;
case G_POINT_CONTENTS:
- IPC::HandleMsg<PointContentsMsg>(socket, std::move(reader), [this](std::array<float, 3> p, int passEntityNum, int& res) {
+ IPC::HandleMsg<PointContentsMsg>(channel, std::move(reader), [this](std::array<float, 3> p, int passEntityNum, int& res) {
res = SV_PointContents(p.data(), passEntityNum);
});
break;
case G_SET_BRUSH_MODEL:
- IPC::HandleMsg<SetBrushModelMsg>(socket, std::move(reader), [this](int entityNum, Str::StringRef name) {
+ IPC::HandleMsg<SetBrushModelMsg>(channel, std::move(reader), [this](int entityNum, Str::StringRef name) {
sharedEntity_t* ent = SV_GentityNum(entityNum);
SV_SetBrushModel(ent, name.c_str());
});
break;
case G_IN_PVS:
- IPC::HandleMsg<InPVSMsg>(socket, std::move(reader), [this](std::array<float, 3> p1, std::array<float, 3> p2, bool& res) {
+ IPC::HandleMsg<InPVSMsg>(channel, std::move(reader), [this](std::array<float, 3> p1, std::array<float, 3> p2, bool& res) {
res = SV_inPVS(p1.data(), p2.data());
});
break;
case G_IN_PVS_IGNORE_PORTALS:
- IPC::HandleMsg<InPVSIgnorePortalsMsg>(socket, std::move(reader), [this](std::array<float, 3> p1, std::array<float, 3> p2, bool& res) {
+ IPC::HandleMsg<InPVSIgnorePortalsMsg>(channel, std::move(reader), [this](std::array<float, 3> p1, std::array<float, 3> p2, bool& res) {
res = SV_inPVSIgnorePortals(p1.data(), p2.data());
});
break;
case G_ADJUST_AREA_PORTAL_STATE:
- IPC::HandleMsg<AdjustAreaPortalStateMsg>(socket, std::move(reader), [this](int entityNum, bool open) {
+ IPC::HandleMsg<AdjustAreaPortalStateMsg>(channel, std::move(reader), [this](int entityNum, bool open) {
sharedEntity_t* ent = SV_GentityNum(entityNum);
SV_AdjustAreaPortalState(ent, open);
});
break;
case G_AREAS_CONNECTED:
- IPC::HandleMsg<AreasConnectedMsg>(socket, std::move(reader), [this](int area1, int area2, bool& res) {
+ IPC::HandleMsg<AreasConnectedMsg>(channel, std::move(reader), [this](int area1, int area2, bool& res) {
res = CM_AreasConnected(area1, area2);
});
break;
case G_DROP_CLIENT:
- IPC::HandleMsg<DropClientMsg>(socket, std::move(reader), [this](int clientNum, Str::StringRef reason) {
+ IPC::HandleMsg<DropClientMsg>(channel, std::move(reader), [this](int clientNum, Str::StringRef reason) {
SV_GameDropClient(clientNum, reason.c_str());
});
break;
case G_SEND_SERVER_COMMAND:
- IPC::HandleMsg<SendServerCommandMsg>(socket, std::move(reader), [this](int clientNum, Str::StringRef text) {
+ IPC::HandleMsg<SendServerCommandMsg>(channel, std::move(reader), [this](int clientNum, Str::StringRef text) {
SV_GameSendServerCommand(clientNum, text.c_str());
});
break;
case G_SET_CONFIGSTRING:
- IPC::HandleMsg<SetConfigStringMsg>(socket, std::move(reader), [this](int index, Str::StringRef val) {
+ IPC::HandleMsg<SetConfigStringMsg>(channel, std::move(reader), [this](int index, Str::StringRef val) {
SV_SetConfigstring(index, val.c_str());
});
break;
case G_GET_CONFIGSTRING:
- IPC::HandleMsg<GetConfigStringMsg>(socket, std::move(reader), [this](int index, int len, std::string& res) {
+ IPC::HandleMsg<GetConfigStringMsg>(channel, std::move(reader), [this](int index, int len, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
SV_GetConfigstring(index, buffer.get(), len);
res.assign(buffer.get(), len);
@@ -918,19 +918,19 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_SET_CONFIGSTRING_RESTRICTIONS:
- IPC::HandleMsg<SetConfigStringRestrictionsMsg>(socket, std::move(reader), [this]() {
+ IPC::HandleMsg<SetConfigStringRestrictionsMsg>(channel, std::move(reader), [this]() {
Com_Printf("SV_SetConfigstringRestrictions not implemented\n");
});
break;
case G_SET_USERINFO:
- IPC::HandleMsg<SetUserinfoMsg>(socket, std::move(reader), [this](int index, Str::StringRef val) {
+ IPC::HandleMsg<SetUserinfoMsg>(channel, std::move(reader), [this](int index, Str::StringRef val) {
SV_SetUserinfo(index, val.c_str());
});
break;
case G_GET_USERINFO:
- IPC::HandleMsg<GetUserinfoMsg>(socket, std::move(reader), [this](int index, int len, std::string& res) {
+ IPC::HandleMsg<GetUserinfoMsg>(channel, std::move(reader), [this](int index, int len, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
SV_GetUserinfo(index, buffer.get(), len);
res.assign(buffer.get(), len);
@@ -938,7 +938,7 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_GET_SERVERINFO:
- IPC::HandleMsg<GetServerinfoMsg>(socket, std::move(reader), [this](int len, std::string& res) {
+ IPC::HandleMsg<GetServerinfoMsg>(channel, std::move(reader), [this](int len, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
SV_GetServerinfo(buffer.get(), len);
res.assign(buffer.get(), len);
@@ -946,50 +946,50 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_GET_USERCMD:
- IPC::HandleMsg<GetUsercmdMsg>(socket, std::move(reader), [this](int index, usercmd_t& cmd) {
+ IPC::HandleMsg<GetUsercmdMsg>(channel, std::move(reader), [this](int index, usercmd_t& cmd) {
SV_GetUsercmd(index, &cmd);
});
break;
case G_GET_ENTITY_TOKEN:
- IPC::HandleMsg<GetEntityTokenMsg>(socket, std::move(reader), [this](bool& boolRes, std::string& res) {
+ IPC::HandleMsg<GetEntityTokenMsg>(channel, std::move(reader), [this](bool& boolRes, std::string& res) {
res = COM_Parse(&sv.entityParsePoint);
boolRes = sv.entityParsePoint or res.size() > 0;
});
break;
case G_SEND_GAME_STAT:
- IPC::HandleMsg<SendGameStatMsg>(socket, std::move(reader), [this](Str::StringRef text) {
+ IPC::HandleMsg<SendGameStatMsg>(channel, std::move(reader), [this](Str::StringRef text) {
SV_MasterGameStat(text.c_str());
});
break;
case G_GET_TAG:
- IPC::HandleMsg<GetTagMsg>(socket, std::move(reader), [this](int clientNum, int tagFileNumber, Str::StringRef tagName, int& res, orientation_t& orientation) {
+ IPC::HandleMsg<GetTagMsg>(channel, std::move(reader), [this](int clientNum, int tagFileNumber, Str::StringRef tagName, int& res, orientation_t& orientation) {
res = SV_GetTag(clientNum, tagFileNumber, tagName.c_str(), &orientation);
});
break;
case G_REGISTER_TAG:
- IPC::HandleMsg<RegisterTagMsg>(socket, std::move(reader), [this](Str::StringRef tagFileName, int& res) {
+ IPC::HandleMsg<RegisterTagMsg>(channel, std::move(reader), [this](Str::StringRef tagFileName, int& res) {
res = SV_LoadTag(tagFileName.c_str());
});
break;
case G_SEND_MESSAGE:
- IPC::HandleMsg<SendMessageMsg>(socket, std::move(reader), [this](int clientNum, int len, std::vector<char> message) {
+ IPC::HandleMsg<SendMessageMsg>(channel, std::move(reader), [this](int clientNum, int len, std::vector<char> message) {
SV_SendBinaryMessage(clientNum, message.data(), len);
});
break;
case G_MESSAGE_STATUS:
- IPC::HandleMsg<MessageStatusMsg>(socket, std::move(reader), [this](int index, int& status) {
+ IPC::HandleMsg<MessageStatusMsg>(channel, std::move(reader), [this](int index, int& status) {
status = SV_BinaryMessageStatus(index);
});
break;
case G_RSA_GENMSG:
- IPC::HandleMsg<RSAGenMsgMsg>(socket, std::move(reader), [this](Str::StringRef pubkey, int& res, std::string& cleartext, std::string& encrypted) {
+ IPC::HandleMsg<RSAGenMsgMsg>(channel, std::move(reader), [this](Str::StringRef pubkey, int& res, std::string& cleartext, std::string& encrypted) {
char cleartextBuffer[RSA_STRING_LENGTH];
char encryptedBuffer[RSA_STRING_LENGTH];
res = SV_RSAGenMsg(pubkey.c_str(), cleartextBuffer, encryptedBuffer);
@@ -999,7 +999,7 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_GEN_FINGERPRINT:
- IPC::HandleMsg<GenFingerprintMsg>(socket, std::move(reader), [this](int keylen, const std::vector<char>& key, int len, std::string& res) {
+ IPC::HandleMsg<GenFingerprintMsg>(channel, std::move(reader), [this](int keylen, const std::vector<char>& key, int len, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
Com_MD5Buffer(key.data(), keylen, buffer.get(), len);
res.assign(buffer.get(), len);
@@ -1007,7 +1007,7 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_GET_PLAYER_PUBKEY:
- IPC::HandleMsg<GetPlayerPubkeyMsg>(socket, std::move(reader), [this](int clientNum, int len, std::string& pubkey) {
+ IPC::HandleMsg<GetPlayerPubkeyMsg>(channel, std::move(reader), [this](int clientNum, int len, std::string& pubkey) {
std::unique_ptr<char[]> buffer(new char[len]);
SV_GetPlayerPubkey(clientNum, buffer.get(), len);
pubkey.assign(buffer.get());
@@ -1015,13 +1015,13 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_GM_TIME:
- IPC::HandleMsg<GMTimeMsg>(socket, std::move(reader), [this](int& res, qtime_t& time) {
+ IPC::HandleMsg<GMTimeMsg>(channel, std::move(reader), [this](int& res, qtime_t& time) {
res = Com_GMTime(&time);
});
break;
case G_GET_TIME_STRING:
- IPC::HandleMsg<GetTimeStringMsg>(socket, std::move(reader), [this](int len, Str::StringRef format, const qtime_t& time, std::string& res) {
+ IPC::HandleMsg<GetTimeStringMsg>(channel, std::move(reader), [this](int len, Str::StringRef format, const qtime_t& time, std::string& res) {
std::unique_ptr<char[]> buffer(new char[len]);
SV_GetTimeString(buffer.get(), len, format.c_str(), &time);
res.assign(buffer.get(), len);
@@ -1029,31 +1029,31 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case G_PARSE_ADD_GLOBAL_DEFINE:
- IPC::HandleMsg<ParseAddGlobalDefineMsg>(socket, std::move(reader), [this](Str::StringRef define, int& res) {
+ IPC::HandleMsg<ParseAddGlobalDefineMsg>(channel, std::move(reader), [this](Str::StringRef define, int& res) {
res = Parse_AddGlobalDefine(define.c_str());
});
break;
case G_PARSE_LOAD_SOURCE:
- IPC::HandleMsg<ParseLoadSourceMsg>(socket, std::move(reader), [this](Str::StringRef name, int& res) {
+ IPC::HandleMsg<ParseLoadSourceMsg>(channel, std::move(reader), [this](Str::StringRef name, int& res) {
res = Parse_LoadSourceHandle(name.c_str());
});
break;
case G_PARSE_FREE_SOURCE:
- IPC::HandleMsg<ParseFreeSourceMsg>(socket, std::move(reader), [this](int source, int& res) {
+ IPC::HandleMsg<ParseFreeSourceMsg>(channel, std::move(reader), [this](int source, int& res) {
res = Parse_FreeSourceHandle(source);
});
break;
case G_PARSE_READ_TOKEN:
- IPC::HandleMsg<ParseReadTokenMsg>(socket, std::move(reader), [this](int source, int& res, pc_token_t& token) {
+ IPC::HandleMsg<ParseReadTokenMsg>(channel, std::move(reader), [this](int source, int& res, pc_token_t& token) {
res = Parse_ReadTokenHandle(source, &token);
});
break;
case G_PARSE_SOURCE_FILE_AND_LINE:
- IPC::HandleMsg<ParseSourceFileAndLineMsg>(socket, std::move(reader), [this](int source, int& res, std::string& file, int& line) {
+ IPC::HandleMsg<ParseSourceFileAndLineMsg>(channel, std::move(reader), [this](int source, int& res, std::string& file, int& line) {
char buffer[128] = {0};
res = Parse_SourceFileAndLine(source, buffer, &line);
file = buffer;
@@ -1061,19 +1061,19 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case BOT_ALLOCATE_CLIENT:
- IPC::HandleMsg<BotAllocateClientMsg>(socket, std::move(reader), [this](int input, int& output) {
+ IPC::HandleMsg<BotAllocateClientMsg>(channel, std::move(reader), [this](int input, int& output) {
output = SV_BotAllocateClient(input);
});
break;
case BOT_FREE_CLIENT:
- IPC::HandleMsg<BotFreeClientMsg>(socket, std::move(reader), [this](int input) {
+ IPC::HandleMsg<BotFreeClientMsg>(channel, std::move(reader), [this](int input) {
SV_BotFreeClient(input);
});
break;
case BOT_GET_CONSOLE_MESSAGE:
- IPC::HandleMsg<BotGetConsoleMessageMsg>(socket, std::move(reader), [this](int client, int len, int& res, std::string& message) {
+ IPC::HandleMsg<BotGetConsoleMessageMsg>(channel, std::move(reader), [this](int client, int len, int& res, std::string& message) {
std::unique_ptr<char[]> buffer(new char[len]);
res = SV_BotGetConsoleMessage(client, buffer.get(), len);
message.assign(buffer.get(), len);
@@ -1081,7 +1081,7 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case BOT_NAV_SETUP:
- IPC::HandleMsg<BotNavSetupMsg>(socket, std::move(reader), [this](botClass_t botClass, int& res, int& handle) {
+ IPC::HandleMsg<BotNavSetupMsg>(channel, std::move(reader), [this](botClass_t botClass, int& res, int& handle) {
res = BotSetupNav(&botClass, &handle);
});
break;
@@ -1091,61 +1091,61 @@ void GameVM::QVMSyscall(int index, IPC::Reader& reader, const IPC::Socket& socke
break;
case BOT_SET_NAVMESH:
- IPC::HandleMsg<BotSetNavmeshMsg>(socket, std::move(reader), [this](int clientNum, int navHandle) {
+ IPC::HandleMsg<BotSetNavmeshMsg>(channel, std::move(reader), [this](int clientNum, int navHandle) {
BotSetNavMesh(clientNum, navHandle);
});
break;
case BOT_FIND_ROUTE:
- IPC::HandleMsg<BotFindRouteMsg>(socket, std::move(reader), [this](int clientNum, botRouteTarget_t target, bool allowPartial, int& res) {
+ IPC::HandleMsg<BotFindRouteMsg>(channel, std::move(reader), [this](int clientNum, botRouteTarget_t target, bool allowPartial, int& res) {
res = BotFindRouteExt(clientNum, &target, allowPartial);
});
break;
case BOT_UPDATE_PATH:
- IPC::HandleMsg<BotUpdatePathMsg>(socket, std::move(reader), [this](int clientNum, botRouteTarget_t target, botNavCmd_t& cmd) {
+ IPC::HandleMsg<BotUpdatePathMsg>(channel, std::move(reader), [this](int clientNum, botRouteTarget_t target, botNavCmd_t& cmd) {
BotUpdateCorridor(clientNum, &target, &cmd);
});
break;
case BOT_NAV_RAYCAST:
- IPC::HandleMsg<BotNavRaycastMsg>(socket, std::move(reader), [this](int clientNum, std::array<float, 3> start, std::array<float, 3> end, int& res, botTrace_t& botTrace) {
+ IPC::HandleMsg<BotNavRaycastMsg>(channel, std::move(reader), [this](int clientNum, std::array<float, 3> start, std::array<float, 3> end, int& res, botTrace_t& botTrace) {
res = BotNavTrace(clientNum, &botTrace, start.data(), end.data());
});
break;
case BOT_NAV_RANDOMPOINT:
- IPC::HandleMsg<BotNavRandomPointMsg>(socket, std::move(reader), [this](int clientNum, std::array<float, 3>& point) {
+ IPC::HandleMsg<BotNavRandomPointMsg>(channel, std::move(reader), [this](int clientNum, std::array<float, 3>& point) {
BotFindRandomPoint(clientNum, point.data());
});
break;
case BOT_NAV_RANDOMPOINTRADIUS:
- IPC::HandleMsg<BotNavRandomPointRadiusMsg>(socket, std::move(reader), [this](int clientNum, std::array<float, 3> origin, float radius, int res, std::array<float, 3>& point) {
+ IPC::HandleMsg<BotNavRandomPointRadiusMsg>(channel, std::move(reader), [this](int clientNum, std::array<float, 3> origin, float radius, int res, std::array<float, 3>& point) {
res = BotFindRandomPointInRadius(clientNum, origin.data(), point.data(), radius);
});
break;
case BOT_ENABLE_AREA:
- IPC::HandleMsg<BotEnableAreaMsg>(socket, std::move(reader), [this](std::array<float, 3> origin, std::array<float, 3> mins, std::array<float, 3> maxs) {
+ IPC::HandleMsg<BotEnableAreaMsg>(channel, std::move(reader), [this](std::array<float, 3> origin, std::array<float, 3> mins, std::array<float, 3> maxs) {
BotEnableArea(origin.data(), mins.data(), maxs.data());
});
break;
case BOT_DISABLE_AREA:
- IPC::HandleMsg<BotDisableAreaMsg>(socket, std::move(reader), [this](std::array<float, 3> origin, std::array<float, 3> mins, std::array<float, 3> maxs) {
+ IPC::HandleMsg<BotDisableAreaMsg>(channel, std::move(reader), [this](std::array<float, 3> origin, std::array<float, 3> mins, std::array<float, 3> maxs) {
BotDisableArea(origin.data(), mins.data(), maxs.data());
});
break;
case BOT_ADD_OBSTACLE:
- IPC::HandleMsg<BotAddObstacleMsg>(socket, std::move(reader), [this](std::array<float, 3> mins, std::array<float, 3> maxs, int& handle) {
+ IPC::HandleMsg<BotAddObstacleMsg>(channel, std::move(reader), [this](std::array<float, 3> mins, std::array<float, 3> maxs, int& handle) {
BotAddObstacle(mins.data(), maxs.data(), &handle);
});
break;
case BOT_REMOVE_OBSTACLE:
- IPC::HandleMsg<BotRemoveObstacleMsg>(socket, std::move(reader), [this](int handle) {
+ IPC::HandleMsg<BotRemoveObstacleMsg>(channel, std::move(reader), [this](int handle) {
BotRemoveObstacle(handle);
});
break;
diff --git a/src/gamelogic/game/g_api.cpp b/src/gamelogic/game/g_api.cpp
index 9a2f2ca..bdf363e 100644
--- a/src/gamelogic/game/g_api.cpp
+++ b/src/gamelogic/game/g_api.cpp
@@ -26,27 +26,27 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "../shared/CommonProxies.h"
// This really should go in the common code
-static IPC::Socket GetRootSocket(int argc, char** argv)
+static IPC::Channel GetRootChannel(int argc, char** argv)
{
- const char* socket;
+ const char* channel;
if (argc == 1) {
- socket = getenv("ROOT_SOCKET");
- if (!socket) {
+ channel = getenv("ROOT_SOCKET");
+ if (!channel) {
fprintf(stderr, "Environment variable ROOT_SOCKET not found\n");
VM::Exit();
}
} else {
- socket = argv[1];
+ channel = argv[1];
}
char* end;
- IPC::OSHandleType h = (IPC::OSHandleType)strtol(socket, &end, 10);
- if (socket == end || *end != '\0') {
+ IPC::OSHandleType h = (IPC::OSHandleType)strtol(channel, &end, 10);
+ if (channel == end || *end != '\0') {
fprintf(stderr, "Environment variable ROOT_SOCKET does not contain a valid handle\n");
VM::Exit();
}
- return IPC::Socket::FromHandle(h);
+ return IPC::Channel::FromHandle(h);
}
class ExitException{};
@@ -55,19 +55,19 @@ void VM::Exit() {
throw ExitException();
}
-IPC::Socket VM::rootSocket;
+IPC::Channel VM::rootChannel;
static IPC::SharedMemory shmRegion;
DLLEXPORT int main(int argc, char** argv)
{
try {
- VM::rootSocket = GetRootSocket(argc, argv);
+ VM::rootChannel = GetRootChannel(argc, argv);
// Send syscall ABI version, also acts as a sign that the module loaded
IPC::Writer writer;
writer.Write<uint32_t>(GAME_API_VERSION);
- VM::rootSocket.SendMsg(writer);
+ VM::rootChannel.SendMsg(writer);
// Initialize VM proxies
VM::InitializeProxies();
@@ -80,7 +80,7 @@ DLLEXPORT int main(int argc, char** argv)
// Start main loop
while (true) {
- IPC::Reader reader = VM::rootSocket.RecvMsg();
+ IPC::Reader reader = VM::rootChannel.RecvMsg();
uint32_t id = reader.Read<uint32_t>();
VM::VMMain(id, std::move(reader));
}
@@ -96,19 +96,19 @@ void VM::VMMain(uint32_t id, IPC::Reader reader)
if (major == VM::QVM) {
switch (minor) {
case GAME_INIT:
- IPC::HandleMsg<GameInitMsg>(VM::rootSocket, std::move(reader), [](int levelTime, int randomSeed, bool restart) {
+ IPC::HandleMsg<GameInitMsg>(VM::rootChannel, std::move(reader), [](int levelTime, int randomSeed, bool restart) {
G_InitGame(levelTime, randomSeed, restart);
});
break;
case GAME_SHUTDOWN:
- IPC::HandleMsg<GameShutdownMsg>(VM::rootSocket, std::move(reader), [](bool restart) {
+ IPC::HandleMsg<GameShutdownMsg>(VM::rootChannel, std::move(reader), [](bool restart) {
G_ShutdownGame(restart);
});
break;
case GAME_CLIENT_CONNECT:
- IPC::HandleMsg<GameClientConnectMsg>(VM::rootSocket, std::move(reader), [](int clientNum, bool firstTime, int isBot, bool& denied, std::string& reason) {
+ IPC::HandleMsg<GameClientConnectMsg>(VM::rootChannel, std::move(reader), [](int clientNum, bool firstTime, int isBot, bool& denied, std::string& reason) {
const char* deniedStr = isBot ? ClientBotConnect(clientNum, firstTime, TEAM_NONE) : ClientConnect(clientNum, firstTime);
denied = deniedStr != nullptr;
if (denied)
@@ -117,31 +117,31 @@ void VM::VMMain(uint32_t id, IPC::Reader reader)
break;
case GAME_CLIENT_THINK:
- IPC::HandleMsg<GameClientThinkMsg>(VM::rootSocket, std::move(reader), [](int clientNum) {
+ IPC::HandleMsg<GameClientThinkMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientThink(clientNum);
});
break;
case GAME_CLIENT_USERINFO_CHANGED:
- IPC::HandleMsg<GameClientUserinfoChangedMsg>(VM::rootSocket, std::move(reader), [](int clientNum) {
+ IPC::HandleMsg<GameClientUserinfoChangedMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientUserinfoChanged(clientNum, qfalse);
});
break;
case GAME_CLIENT_DISCONNECT:
- IPC::HandleMsg<GameClientDisconnectMsg>(VM::rootSocket, std::move(reader), [](int clientNum) {
+ IPC::HandleMsg<GameClientDisconnectMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientDisconnect(clientNum);
});
break;
case GAME_CLIENT_BEGIN:
- IPC::HandleMsg<GameClientBeginMsg>(VM::rootSocket, std::move(reader), [](int clientNum) {
+ IPC::HandleMsg<GameClientBeginMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientBegin(clientNum);
});
break;
case GAME_CLIENT_COMMAND:
- IPC::HandleMsg<GameClientCommandMsg>(VM::rootSocket, std::move(reader), [](int clientNum, std::string command) {
+ IPC::HandleMsg<GameClientCommandMsg>(VM::rootChannel, std::move(reader), [](int clientNum, std::string command) {
Cmd::PushArgs(command);
ClientCommand(clientNum);
Cmd::PopArgs();
@@ -149,7 +149,7 @@ void VM::VMMain(uint32_t id, IPC::Reader reader)
break;
case GAME_RUN_FRAME:
- IPC::HandleMsg<GameRunFrameMsg>(VM::rootSocket, std::move(reader), [](int levelTime) {
+ IPC::HandleMsg<GameRunFrameMsg>(VM::rootChannel, std::move(reader), [](int levelTime) {
G_RunFrame(levelTime);
});
break;
@@ -170,7 +170,7 @@ void VM::VMMain(uint32_t id, IPC::Reader reader)
G_Error("VMMain(): unknown game command %i", minor);
}
} else if (major < VM::LAST_COMMON_SYSCALL) {
- VM::HandleCommonSyscall(major, minor, std::move(reader), VM::rootSocket);
+ VM::HandleCommonSyscall(major, minor, std::move(reader), VM::rootChannel);
} else {
G_Error("unhandled VM major syscall number %i", major);
}
diff --git a/src/gamelogic/shared/CommonProxies.cpp b/src/gamelogic/shared/CommonProxies.cpp
index 362b683..09860c5 100644
--- a/src/gamelogic/shared/CommonProxies.cpp
+++ b/src/gamelogic/shared/CommonProxies.cpp
@@ -122,8 +122,8 @@ namespace Cmd {
// Implementation of the engine syscalls
- void ExecuteSyscall(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<VM::ExecuteMsg>(socket, std::move(reader), [](Str::StringRef command){
+ void ExecuteSyscall(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<VM::ExecuteMsg>(channel, std::move(reader), [](Str::StringRef command){
Cmd::Args args(command);
auto map = GetCommandMap();
@@ -137,8 +137,8 @@ namespace Cmd {
});
}
- void CompleteSyscall(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<VM::CompleteMsg>(socket, std::move(reader), [](int argNum, Str::StringRef command, Str::StringRef prefix, Cmd::CompletionResult& res) {
+ void CompleteSyscall(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<VM::CompleteMsg>(channel, std::move(reader), [](int argNum, Str::StringRef command, Str::StringRef prefix, Cmd::CompletionResult& res) {
Cmd::Args args(command);
auto map = GetCommandMap();
@@ -152,14 +152,14 @@ namespace Cmd {
});
}
- void HandleSyscall(int minor, IPC::Reader& reader, const IPC::Socket& socket) {
+ void HandleSyscall(int minor, IPC::Reader& reader, const IPC::Channel& channel) {
switch (minor) {
case VM::EXECUTE:
- ExecuteSyscall(reader, socket);
+ ExecuteSyscall(reader, channel);
break;
case VM::COMPLETE:
- CompleteSyscall(reader, socket);
+ CompleteSyscall(reader, channel);
break;
default:
@@ -289,8 +289,8 @@ namespace Cvar{
// Syscalls called by the engine
- void CallOnValueChangedSyscall(IPC::Reader& reader, const IPC::Socket& socket) {
- IPC::HandleMsg<VM::OnValueChangedMsg>(socket, std::move(reader), [](Str::StringRef name, Str::StringRef value, bool& success, std::string& description) {
+ void CallOnValueChangedSyscall(IPC::Reader& reader, const IPC::Channel& channel) {
+ IPC::HandleMsg<VM::OnValueChangedMsg>(channel, std::move(reader), [](Str::StringRef name, Str::StringRef value, bool& success, std::string& description) {
auto map = GetCvarMap();
auto it = map.find(name);
@@ -307,10 +307,10 @@ namespace Cvar{
});
}
- void HandleSyscall(int minor, IPC::Reader& reader, const IPC::Socket& socket) {
+ void HandleSyscall(int minor, IPC::Reader& reader, const IPC::Channel& channel) {
switch (minor) {
case VM::ON_VALUE_CHANGED:
- CallOnValueChangedSyscall(reader, socket);
+ CallOnValueChangedSyscall(reader, channel);
break;
default:
@@ -411,14 +411,14 @@ namespace VM {
Cvar::InitializeProxy();
}
- void HandleCommonSyscall(int major, int minor, IPC::Reader reader, const IPC::Socket& socket) {
+ void HandleCommonSyscall(int major, int minor, IPC::Reader reader, const IPC::Channel& channel) {
switch (major) {
case VM::COMMAND:
- Cmd::HandleSyscall(minor, reader, socket);
+ Cmd::HandleSyscall(minor, reader, channel);
break;
case VM::CVAR:
- Cvar::HandleSyscall(minor, reader, socket);
+ Cvar::HandleSyscall(minor, reader, channel);
break;
default:
diff --git a/src/gamelogic/shared/CommonProxies.h b/src/gamelogic/shared/CommonProxies.h
index 94b0aab..80b0fa7 100644
--- a/src/gamelogic/shared/CommonProxies.h
+++ b/src/gamelogic/shared/CommonProxies.h
@@ -41,7 +41,7 @@ namespace Cmd {
namespace VM {
void InitializeProxies();
- void HandleCommonSyscall(int major, int minor, IPC::Reader reader, const IPC::Socket& socket);
+ void HandleCommonSyscall(int major, int minor, IPC::Reader reader, const IPC::Channel& channel);
}
diff --git a/src/gamelogic/shared/VMMain.h b/src/gamelogic/shared/VMMain.h
index 9aae7f8..b533936 100644
--- a/src/gamelogic/shared/VMMain.h
+++ b/src/gamelogic/shared/VMMain.h
@@ -32,8 +32,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace VM {
- // Root socket used to communicate with the engine
- extern IPC::Socket rootSocket;
+ // Root channel used to communicate with the engine
+ extern IPC::Channel rootChannel;
// Main handler for incoming messages from the engine
void VMMain(uint32_t id, IPC::Reader reader);
@@ -42,7 +42,7 @@ namespace VM {
// Send a message to the engine
template<typename Msg, typename... Args> void SendMsg(Args&&... args) {
- IPC::SendMsg<Msg>(rootSocket, VMMain, std::forward<Args>(args)...);
+ IPC::SendMsg<Msg>(rootChannel, VMMain, std::forward<Args>(args)...);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment