MAINT: Rename Murmur.ice to MumbleServer.ice

author: Robert Adam <dev@robert-adam.de> 2022-09-08 14:48:40 +0300
committer: Robert Adam <dev@robert-adam.de> 2022-09-10 18:28:34 +0300
commit: b81b06001db4c7b76dc8ee3fc25b900452869336 (patch)
tree: 83ea9e337fda98991e38a83ac5b0dfd51760045f
parent: 18526924909720ca8947e74cb975501dc0681ffe (diff)
10 files changed, 564 insertions, 556 deletions
diff --git a/auxiliary_files/CMakeLists.txt b/auxiliary_files/CMakeLists.txt
index 13ceb8619..1eb3121c4 100644
--- a/auxiliary_files/CMakeLists.txt
+++ b/auxiliary_files/CMakeLists.txt
@@ -116,7 +116,7 @@ if(server)
 		install(FILES "${CMAKE_CURRENT_BINARY_DIR}/mumble-server.service" DESTINATION "${SYSTEMD_SERVICE_DIR}" COMPONENT mumble_server)
 		install(FILES "${CMAKE_CURRENT_BINARY_DIR}/mumble-server-user-wrapper" DESTINATION "${MUMBLE_INSTALL_EXECUTABLEDIR}" COMPONENT mumble_server)
 		install(FILES "config_files/mumble-server.conf" DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/dbus-1/system.d" COMPONENT mumble_server)
-		install(FILES "${CMAKE_SOURCE_DIR}/src/murmur/Murmur.ice" DESTINATION "${MUMBLE_INSTALL_SYSCONFDIR}" COMPONENT mumble_server)
+		install(FILES "${CMAKE_SOURCE_DIR}/src/murmur/MumbleServer.ice" DESTINATION "${MUMBLE_INSTALL_SYSCONFDIR}" COMPONENT mumble_server)
 	endif()
 endif()
 
diff --git a/docs/dev/ExtendingTheIceInterface.md b/docs/dev/ExtendingTheIceInterface.md
index 754aaf6e1..602d95046 100644
--- a/docs/dev/ExtendingTheIceInterface.md
+++ b/docs/dev/ExtendingTheIceInterface.md
@@ -8,73 +8,58 @@ Note: If not stated otherwise all referenced files live in `src/murmur/`.
 The files involved in extending the Ice interface are
 | **File** | **Description** |
 | -------- | --------------- |
-| `Murmur.ice` | Contains the formal definition of the interface |
-| `Murmur.h` | Contains the C++ interface definition (abstract base classes). This file is automatically generated based on `Murmur.ice` when invoking cmake (via `slice2cpp`).  It lives in `<build directory>/src/murmur`. This file is needed to generate `MurmurIceWrapper.cpp` |
-| `Murmur.cpp` | Contains some boilerplate and Ice-internal implementation code. This file is generated and lives alongside `Murmur.h` |
-| `MurmurI.h` | Contains the definition of the actually implemented API classes (`ServerI` and `MetaI`). These extend the abstract base classes from `Murmur.h` |
-| `MurmurIceWrapper.cpp` | Contains wrapper implementation of the `*I` API classes. This file is auto-generated by the `scripts/generateIceWrapper.py` script |
-| `MurmurIce.h` | Contains the definition of a statically used helper class |
-| `MurmurIce.cpp` | Contains the implementation of that helper class **and** _static_ functions used to actually implement the server-side functionality of the Ice API functions |
-| `RPC.cpp` | Contains the implementations of the `Server` (the Mumble server, _not_ the Ice API type) class's member functions that are required to make certain functionality accessible to the static functions in `MurmurIce.cpp` |
+| `MumbleServer.ice` | Contains the formal definition of the interface |
+| `MumbleServer.h` | Contains the C++ interface definition (abstract base classes). This file is generated based on `MumbleServer.ice` when invoking cmake (via `slice2cpp`). |
+| `MumbleServer.cpp` | Contains some boilerplate and Ice-internal implementation code. This file is automatically generated. |
+| `MumbleServerI.h` | Contains the definition of the actually implemented API classes (`ServerI` and `MetaI`). These extend the abstract base classes from `MumbleServer.h` |
+| `MumbleServerWrapper.cpp` | Contains wrapper implementation of the `*I` API classes. This file is automatically generated. |
+| `MumbleServere.h` | Contains the definition of a statically used helper class |
+| `MumbleServere.cpp` | Contains the implementation of that helper class **and** _static_ functions used to actually implement the server-side functionality of the Ice API functions |
+| `RPC.cpp` | Contains the implementations of the `Server` (the Mumble server, _not_ the Ice API type) class's member functions that are required to make certain functionality accessible to the static functions in `MumbleServerIce.cpp` |
+
+All auto-generated functions will end up in the corresponding directory inside the `build` directory.
 
 
 ## Overview
 
 The steps are
-1. Let cmake invoke `slice2cpp` to generate `Murmur.h` and `Murmur.cpp`
-2. Invoke `generateIceWrapper.py` to generate `MurmurIceWrapper.cpp`
-3. Add new function declarations to `MurmurU.h`
-4. Write impl function in `MurmurIce.cpp`
-5. Potentially write new public API functions (declare in `Server.h` and define in `RPC.cpp`
-
-## Detailed instructions
-
-Before proceeding any further you should run cmake once in order for these files to get generated as they are needed for the next step. Assuming your
-build directory lives directly under the repository's root, you can do this by invoking
-```bash
-cmake ..
-```
+1. Add new function declarations to `MumbleServerI.h`
+2. Write impl function in `MumbleServerIce.cpp`
+3. Potentially write new public API functions (declare in `Server.h` and define in `RPC.cpp`
 
-The next step is the generation of the `MurmurIceWrapper.cpp` file by executing the following command (assuming the call is performed from the
-repository's root and the build directory is called `build`):
-```bash
-$ python3 scripts/generateIceWrapper.py --ice-file src/murmur/Murmur.ice --generated-ice-header build/src/murmur/Murmur.h --out-file src/murmur/MurmurIceWrapper.cpp 
-Using ICE-file at                   "src/murmur/Murmur.ice"
-Using ICE-generated header file at  "build/src/murmur/Murmur.h"
-```
-The paths that are given in the example may have to be adapted in order for it to work on your machine.
+## Details
 
-The `MurmurIceWrapper.cpp` file generates the `*_async` versions of the Ice callbacks that handle the async nature of these callbacks and also
+The `MumbleServerIceWrapper.cpp` file contains the `*_async` versions of the Ice callbacks that handle the async nature of these callbacks and also
 contain the boilerplate for e.g. verification of the caller and things like this. Most importantly though these functions call the `impl_*` functions
-defined in `MurmurIce.cpp`. For instance a function called `updateCertificates` inside the `Server` class will call `impl_Server_updateCertificate`
-which has to be defined as a `static` function inside `MurmurIce.cpp`.
+defined in `MumbleServerIce.cpp`. For instance a function called `updateCertificates` inside the `Server` class will call
+`impl_Server_updateCertificate` which has to be defined as a `static` function inside `MumbleServerIce.cpp`.
 
-The declaration of the async functions generated this way are contained inside `MurmurI.h`. You have to manually add the function's declaration into
-there. The easiest way to do this is to let the script generate the implementation as described above and then copy the function signature from there
-into the `Murmur.h` file (make the declaration `virtual` though).
+The declarations of the async functions generated this way are contained inside `MumbleServerI.h`. You have to manually add the function's declaration
+into there. The easiest way to do this is to let the implementation be auto-generated and then copy the function signature from there into the
+`MumbleServer.h` file (make the declaration `virtual` though).
 
 The impl function's signature is always
 ```cpp
-static void impl_<className>_<functionName>(const ::Murmur::AMD_<className>_<functionName>Ptr cb [, int server_id] [, <function arguments>]) {
+static void impl_<className>_<functionName>(const ::MumbleServer::AMD_<className>_<functionName>Ptr cb [, int server_id] [, <function arguments>]) {
     // Implementation goes here
 
     cb->ice_response([<function return value>]);
 }
 ```
 - `<className>`: Name of the class the function is declared in (e.g. `Server` or `Meta`)
-- `<functionName>`: Name of the function as declared in the `Murmur.ice` file
+- `<functionName>`: Name of the function as declared in the `MumbleServer.ice` file
 - `[, int server_id]`: Only needed when extending the `Server` API class (the brackets are not part of what needs to be written in code)
 - `[, <function arguments>]`: To be replaced by the list of arguments the function takes
 - `[<function return value>]`: To be replaced with the value this function returns or to be removed if the function does not return anything.
 
 
-If you have used non-default types that are declared in `Murmur.ice` (e.g. `IdList`), you can reference them here as `::Murmur::<typeName>` (e.g.
-`::Murmur::IdList`).
+If you have used non-default types that are declared in `MumbleServer.ice` (e.g. `IdList`), you can reference them here as
+`::MumbleServer::<typeName>` (e.g. `::MumbleServer::IdList`).
 
 Error reporting works via the `cb->ice_exception` function and if everything went well, the function must end by calling `cb->ice_response`
 (potentially passing a value to that function that shall be returned to the caller of the function).
 
-In general it is a good idea to have a look at the existing implementation inside `MurmurIce.cpp` and take inspiration from those.
+In general it is a good idea to have a look at the existing implementation inside `MumbleServerIce.cpp` and take inspiration from those.
 
 Note that the implementations make heavy use of macros (e.g. `NEED_SERVER`, `NEED_CHANNEL`, etc.). These will initialize the corresponding variables
 (`server`, `channel`, etc.) based in the parameters fed into the function (In order to obtain the channel, user, etc. you always have to initialize
@@ -91,22 +76,26 @@ public API function in the Mumble `Server` class that has the implementation in
 
 ## Testing Ice interface changes
 
-So far, you've used `Murmur.ice` to modify and generate **server-side** code. The same file can be used to create Ice **clients**, which then interact with the server. A small amount of configuration is required, namely:
+So far, you've used `MumbleServer.ice` to modify and generate **server-side** code. The same file can be used to create Ice **clients**, which then
+interact with the server. A small amount of configuration is required, namely:
 
 | **Setting** | **Example** | **Description** |
 | --- | --- | --- |
-| `host` | `127.0.0.1` | The IP address (or domain) to which Murmur's Ice interface is bound. (Check [`murmur.ini`'s `ice` property  `-h` flag](../../scripts/murmur.ini#L65).) |
+| `host` | `127.0.0.1` | The IP address (or domain) to which MumbleServer's Ice interface is bound. (Check [`murmur.ini`'s `ice` property  `-h` flag](../../scripts/murmur.ini#L65).) |
 | `port` | `6502` | The TCP port on which Ice's interface is listening. (Check [`murmur.ini`'s `ice` property  `-p` flag](../../scripts/murmur.ini#L65).) |
 | `secret` | `ice_pa55word` | A clear-text "password" used to authorize with the Ice server. (This will either be [`icesecretread`](../../scripts/murmur.ini#L79) or [`icesecretwrite`](../../scripts/murmur.ini#L80) from [`murmur.ini`](../../scripts/murmur.ini), with read-only or read-write privileges respectively.) |
-| `slicefile` | `Murmur.ice` | The [`Murmur.ice`](../../src/murmur/Murmur.ice) file, containing any changes you intend to test. (This can be dynamically fetched from the Murmur server, provided it's running, has Ice exposed, and was built with the updated `Murmur.ice` file.) |
+| `slicefile` | `MumbleServer.ice` | The [`MumbleServer.ice`](../../src/murmur/MumbleServer.ice) file, containing any changes you intend to test. (This can be dynamically fetched from the Mumble server, provided it's running, has Ice exposed, and was built with the updated `MumbleServer.ice` file.) |
 
-> :warning: Since Murmur's Ice interface is clear-text, there are security factors to consider. Use a strong-ish, unique secret, not used for any other case.
+> :warning: Since the server's Ice interface is clear-text, there are security factors to consider. Use a strong-ish, unique secret, not used for
+> any other case.
 
-An existing Python Ice client is [`mice.py`](https://github.com/mumble-voip/mumble-scripts/blob/master/Helpers/mice.py), which simply creates necessary Ice objects and then drops you into an interactive Python shell. (Refer to the [Wiki](https://wiki.mumble.info/wiki/Mice) and [Natenom](https://blog.natenom.com/2016/02/an-introduction-on-how-to-manage-your-mumble-server-murmur-through-ice-with-mice/) for longer guides.)
+An existing Python Ice client is [`mice.py`](https://github.com/mumble-voip/mumble-scripts/blob/master/Helpers/mice.py), which simply creates
+necessary Ice objects and then drops you into an interactive Python shell. (Refer to the [Wiki](https://wiki.mumble.info/wiki/Mice) and
+[Natenom](https://blog.natenom.com/2016/02/an-introduction-on-how-to-manage-your-mumble-server-murmur-through-ice-with-mice/) for longer guides.)
 
 ```python
-# Make sure Murmur is running (in a separate terminal)
-# $ ./murmur.x86 ...
+# Make sure the Mumble server is running (in a separate terminal)
+# $ ./mumble-server ...
 
 # Grab mice.py
 $ wget --quiet https://raw.githubusercontent.com/mumble-voip/mumble-scripts/master/Helpers/mice.py
@@ -117,7 +106,7 @@ host = "127.0.0.1"
 port = 6502
 secret = "ice_pa55word"
 prxstr = "Meta:tcp -h {} -p {} -t 1000".format(host, port)
-slicefile = "Murmur.ice"
+slicefile = "MumbleServer.ice"
 EOF
 
 
@@ -129,7 +118,7 @@ Import ice... Done
 Trying to retrieve slice dynamically from server... Success
 Import dynamically compiled murmur class... Done
 Establish ice connection... [protected]... Done
-Murmur object accessible via 'murmur' or 'm'
+MumbleServer object accessible via 'murmur' or 'm'
 1 booted servers in 'sl', 's' contains 's/1 -t -e 1.0:tcp -h 127.0.0.1 -p 6502 -t 60000'
 --- Reached interactive mode ---
 
@@ -155,4 +144,6 @@ In [5]: [(user.session, user.name) for user in s.getUsers().values()]
 Out[5]: [(7L, 'Bob')]
 ```
 
-> :information_source: Refer to [the Wiki for additional 3rd-party applications](https://wiki.mumble.info/wiki/3rd_Party_Applications) which leverage Murmur's Ice interface.
+> :information_source: Refer to [the Wiki for additional 3rd-party applications](https://wiki.mumble.info/wiki/3rd_Party_Applications) which leverage
+> the server's Ice interface.
+
diff --git a/installer/ServerInstaller.cs b/installer/ServerInstaller.cs
index a18fa3827..e9b4ac5c5 100644
--- a/installer/ServerInstaller.cs
+++ b/installer/ServerInstaller.cs
@@ -18,7 +18,7 @@ public class ServerInstaller : MumbleInstall {
 		string upgradeGuid = "03E9476F-0F75-4661-BFC9-A9DAEB23D3A0";
 		string[] binaries = {
 			"mumble-server.exe",
-			"Murmur.ice"
+			"MumbleServer.ice"
 		};
 
 		string[] licenses = {
diff --git a/scripts/generateIceWrapper.py b/scripts/generateIceWrapper.py
index 4e839d2d1..e6cb78672 100755
--- a/scripts/generateIceWrapper.py
+++ b/scripts/generateIceWrapper.py
@@ -36,7 +36,7 @@ def create_disclaimerComment():
     return "// This file was auto-generated by scripts/generateIceWrapper.py on " + datetime.now().strftime("%Y-%m-%d") + " -- DO NOT EDIT MANUALLY!\n"
 
 def generateFunction(className, functionName, wrapArgs, callArgs):
-    function = "void ::Murmur::" + className + "I::" + functionName + "_async(" + (", ".join(wrapArgs)) + ") {\n"
+    function = "void ::MumbleServer::" + className + "I::" + functionName + "_async(" + (", ".join(wrapArgs)) + ") {\n"
     function += "\t// qWarning() << \"" + functionName + "\" << meta->mp.qsIceSecretRead.isNull() << meta->mp.qsIceSecretRead.isEmpty();\n"
     function += "#ifndef ACCESS_" + className + "_" + functionName + "_ALL\n"
     function += "#\tifdef ACCESS_" + className + "_" + functionName + "_READ\n"
@@ -84,11 +84,11 @@ def main():
     rootDir = os.path.dirname(os.path.dirname(scriptPath))
 
     if args.ice_file is None:
-        # Try to figure out the path to the ice-file (Murmur.ice)
-        args.ice_file = os.path.join(rootDir, "src", "murmur", "Murmur.ice")
+        # Try to figure out the path to the ice-file (MumbleServer.ice)
+        args.ice_file = os.path.join(rootDir, "src", "murmur", "MumbleServer.ice")
     if args.generated_ice_header is None:
         # Try to figure out path to the generated header file (in the build dir)
-        args.generated_ice_header = os.path.join(rootDir, "build", "src", "murmur", "Murmur.h")
+        args.generated_ice_header = os.path.join(rootDir, "build", "src", "murmur", "MumbleServer.h")
 
     if not args.quiet:
         print("Using ICE-file at                   \"%s\"" % args.ice_file)
@@ -185,7 +185,7 @@ def main():
             wrapperContent += generateFunction(targetClass, functionName, wrapArgs, callArgs) + "\n"
 
 
-    wrapperContent += "void ::Murmur::MetaI::getSlice_async(const ::Murmur::AMD_Meta_getSlicePtr &cb, const Ice::Current&) {\n"
+    wrapperContent += "void ::MumbleServer::MetaI::getSlice_async(const ::MumbleServer::AMD_Meta_getSlicePtr &cb, const Ice::Current&) {\n"
     wrapperContent += "\tcb->ice_response(std::string(\"" + iceSpec + "\"));\n"
     wrapperContent += "}\n"
 
diff --git a/src/murmur/CMakeLists.txt b/src/murmur/CMakeLists.txt
index 5310b31a5..eaa0da036 100644
--- a/src/murmur/CMakeLists.txt
+++ b/src/murmur/CMakeLists.txt
@@ -10,7 +10,7 @@ set(MURMUR_PLIST "${CMAKE_CURRENT_BINARY_DIR}/murmur.plist")
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/murmur.plist.in" "${MURMUR_PLIST}")
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/murmur.rc.in" "${MURMUR_RC}")
 
-set(ICE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Murmur.ice")
+set(ICE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/MumbleServer.ice")
 
 include(qt-utils)
 
@@ -235,18 +235,18 @@ if(ice)
 	)
 
 	add_custom_target(generate_murmur_ice_wrapper
-		DEPENDS "MurmurIceWrapper.cpp" 
+		DEPENDS "MumbleServerIceWrapper.cpp" 
 	)
 	add_dependencies(mumble-server generate_murmur_ice_wrapper)
 	add_custom_command(
-		OUTPUT "MurmurIceWrapper.cpp"
+		OUTPUT "MumbleServerIceWrapper.cpp"
 		COMMAND ${PYTHON_INTERPRETER}
 		ARGS "${CMAKE_SOURCE_DIR}/scripts/generateIceWrapper.py" -i "${ICE_FILE}"
-			-g "${ICE_FILE_NAME}.h" -o "MurmurIceWrapper.cpp" -q
+			-g "${ICE_FILE_NAME}.h" -o "MumbleServerIceWrapper.cpp" -q
 		DEPENDS ${ICE_GENERATED_FILES}
-		COMMENT "Generating MurmurIceWrapper"
+		COMMENT "Generating MumbleServerIceWrapper"
 	)
-	# Even though the file is a .cpp, it is still being included in MurmurIce.cpp
+	# Even though the file is a .cpp, it is still being included in MumbleServerIce.cpp
 	target_include_directories(mumble-server PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
 
 	# We explicitly tell CMake not to call any autogen tools (e.g. MOC) for the generated files.
@@ -255,8 +255,8 @@ if(ice)
 
 	target_sources(mumble-server
 		PRIVATE
-			"MurmurIce.cpp"
-			"MurmurIce.h"
+			"MumbleServerIce.cpp"
+			"MumbleServerIce.h"
 			${ICE_GENERATED_FILES}
 	)
 	target_compile_definitions(mumble-server
diff --git a/src/murmur/Murmur.ice b/src/murmur/MumbleServer.ice
index 60d388458..3f7d8ccca 100644
--- a/src/murmur/Murmur.ice
+++ b/src/murmur/MumbleServer.ice
@@ -13,7 +13,7 @@
 
 #include <Ice/SliceChecksumDict.ice>
 
-module Murmur
+module MumbleServer
 {
 
 	/** A network address in IPv6 format.
diff --git a/src/murmur/MumbleServerI.h b/src/murmur/MumbleServerI.h
new file mode 100644
index 000000000..e1ddb2d3c
--- /dev/null
+++ b/src/murmur/MumbleServerI.h
@@ -0,0 +1,200 @@
+// Copyright 2008-2022 The Mumble Developers. All rights reserved.
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file at the root of the
+// Mumble source tree or at <https://www.mumble.info/LICENSE>.
+
+#ifndef MUMBLE_MURMUR_MURMURI_H_
+#define MUMBLE_MURMUR_MURMURI_H_
+
+#include <MumbleServer.h>
+
+namespace MumbleServer {
+
+class ServerI : virtual public Server {
+public:
+	virtual void isRunning_async(const ::MumbleServer::AMD_Server_isRunningPtr &, const Ice::Current &);
+
+	virtual void start_async(const ::MumbleServer::AMD_Server_startPtr &, const Ice::Current &);
+
+	virtual void stop_async(const ::MumbleServer::AMD_Server_stopPtr &, const Ice::Current &);
+
+	virtual void delete_async(const ::MumbleServer::AMD_Server_deletePtr &, const Ice::Current &);
+
+	virtual void addCallback_async(const ::MumbleServer::AMD_Server_addCallbackPtr &,
+								   const ::MumbleServer::ServerCallbackPrx &, const ::Ice::Current &);
+	virtual void removeCallback_async(const ::MumbleServer::AMD_Server_removeCallbackPtr &,
+									  const ::MumbleServer::ServerCallbackPrx &, const ::Ice::Current &);
+
+	virtual void setAuthenticator_async(const ::MumbleServer::AMD_Server_setAuthenticatorPtr &,
+										const ::MumbleServer::ServerAuthenticatorPrx &, const ::Ice::Current &);
+
+	virtual void id_async(const ::MumbleServer::AMD_Server_idPtr &, const Ice::Current &);
+
+	virtual void getConf_async(const ::MumbleServer::AMD_Server_getConfPtr &, const ::std::string &,
+							   const Ice::Current &);
+
+	virtual void getAllConf_async(const ::MumbleServer::AMD_Server_getAllConfPtr &, const Ice::Current &);
+
+	virtual void setConf_async(const ::MumbleServer::AMD_Server_setConfPtr &, const ::std::string &,
+							   const ::std::string &, const Ice::Current &);
+
+	virtual void setSuperuserPassword_async(const ::MumbleServer::AMD_Server_setSuperuserPasswordPtr &,
+											const ::std::string &, const Ice::Current &);
+
+	virtual void getLog_async(const ::MumbleServer::AMD_Server_getLogPtr &, ::Ice::Int, ::Ice::Int,
+							  const Ice::Current &);
+
+	virtual void getLogLen_async(const ::MumbleServer::AMD_Server_getLogLenPtr &, const Ice::Current &);
+
+	virtual void getUsers_async(const ::MumbleServer::AMD_Server_getUsersPtr &, const Ice::Current &);
+
+	virtual void getChannels_async(const ::MumbleServer::AMD_Server_getChannelsPtr &, const Ice::Current &);
+
+	virtual void getTree_async(const ::MumbleServer::AMD_Server_getTreePtr &, const Ice::Current &);
+
+	virtual void getCertificateList_async(const ::MumbleServer::AMD_Server_getCertificateListPtr &, ::Ice::Int,
+										  const ::Ice::Current &);
+
+	virtual void getBans_async(const ::MumbleServer::AMD_Server_getBansPtr &, const Ice::Current &);
+
+	virtual void setBans_async(const ::MumbleServer::AMD_Server_setBansPtr &, const ::MumbleServer::BanList &,
+							   const Ice::Current &);
+
+	virtual void kickUser_async(const ::MumbleServer::AMD_Server_kickUserPtr &, ::Ice::Int, const ::std::string &,
+								const Ice::Current &);
+
+	virtual void sendMessage_async(const ::MumbleServer::AMD_Server_sendMessagePtr &, ::Ice::Int, const ::std::string &,
+								   const Ice::Current &);
+
+	virtual void hasPermission_async(const ::MumbleServer::AMD_Server_hasPermissionPtr &, ::Ice::Int, ::Ice::Int,
+									 ::Ice::Int, const ::Ice::Current &);
+	virtual void effectivePermissions_async(const ::MumbleServer::AMD_Server_effectivePermissionsPtr &, ::Ice::Int,
+											::Ice::Int, const ::Ice::Current &);
+
+	virtual void addContextCallback_async(const ::MumbleServer::AMD_Server_addContextCallbackPtr &, ::Ice::Int,
+										  const ::std::string &, const ::std::string &,
+										  const ::MumbleServer::ServerContextCallbackPrx &, int,
+										  const ::Ice::Current &);
+	virtual void removeContextCallback_async(const ::MumbleServer::AMD_Server_removeContextCallbackPtr &,
+											 const ::MumbleServer::ServerContextCallbackPrx &, const ::Ice::Current &);
+
+	virtual void getState_async(const ::MumbleServer::AMD_Server_getStatePtr &, ::Ice::Int, const Ice::Current &);
+
+	virtual void setState_async(const ::MumbleServer::AMD_Server_setStatePtr &, const ::MumbleServer::User &,
+								const Ice::Current &);
+
+	virtual void getChannelState_async(const ::MumbleServer::AMD_Server_getChannelStatePtr &, ::Ice::Int,
+									   const Ice::Current &);
+
+	virtual void setChannelState_async(const ::MumbleServer::AMD_Server_setChannelStatePtr &,
+									   const ::MumbleServer::Channel &, const Ice::Current &);
+
+	virtual void removeChannel_async(const ::MumbleServer::AMD_Server_removeChannelPtr &, ::Ice::Int,
+									 const Ice::Current &);
+
+	virtual void addChannel_async(const ::MumbleServer::AMD_Server_addChannelPtr &, const ::std::string &, ::Ice::Int,
+								  const Ice::Current &);
+
+	virtual void sendMessageChannel_async(const ::MumbleServer::AMD_Server_sendMessageChannelPtr &, ::Ice::Int, bool,
+										  const ::std::string &, const Ice::Current &);
+
+	virtual void getACL_async(const ::MumbleServer::AMD_Server_getACLPtr &, ::Ice::Int, const Ice::Current &);
+
+	virtual void setACL_async(const ::MumbleServer::AMD_Server_setACLPtr &, ::Ice::Int, const ::MumbleServer::ACLList &,
+							  const ::MumbleServer::GroupList &, bool, const Ice::Current &);
+
+	virtual void removeUserFromGroup_async(const ::MumbleServer::AMD_Server_removeUserFromGroupPtr &, ::Ice::Int,
+										   ::Ice::Int, const ::std::string &, const ::Ice::Current &);
+
+	virtual void addUserToGroup_async(const ::MumbleServer::AMD_Server_addUserToGroupPtr &, ::Ice::Int, ::Ice::Int,
+									  const ::std::string &, const ::Ice::Current &);
+
+	virtual void redirectWhisperGroup_async(const ::MumbleServer::AMD_Server_redirectWhisperGroupPtr &, ::Ice::Int,
+											const ::std::string &, const ::std::string &, const ::Ice::Current &);
+
+	virtual void getUserNames_async(const ::MumbleServer::AMD_Server_getUserNamesPtr &, const ::MumbleServer::IdList &,
+									const Ice::Current &);
+
+	virtual void getUserIds_async(const ::MumbleServer::AMD_Server_getUserIdsPtr &, const ::MumbleServer::NameList &,
+								  const Ice::Current &);
+
+	virtual void registerUser_async(const ::MumbleServer::AMD_Server_registerUserPtr &,
+									const ::MumbleServer::UserInfoMap &, const Ice::Current &);
+
+	virtual void unregisterUser_async(const ::MumbleServer::AMD_Server_unregisterUserPtr &, ::Ice::Int,
+									  const Ice::Current &);
+
+	virtual void updateRegistration_async(const ::MumbleServer::AMD_Server_updateRegistrationPtr &, Ice::Int,
+										  const ::MumbleServer::UserInfoMap &, const Ice::Current &);
+
+	virtual void getRegistration_async(const ::MumbleServer::AMD_Server_getRegistrationPtr &, ::Ice::Int,
+									   const Ice::Current &);
+
+	virtual void getRegisteredUsers_async(const ::MumbleServer::AMD_Server_getRegisteredUsersPtr &,
+										  const ::std::string &, const Ice::Current &);
+
+	virtual void verifyPassword_async(const ::MumbleServer::AMD_Server_verifyPasswordPtr &, const ::std::string &,
+									  const ::std::string &, const Ice::Current &);
+
+	virtual void getTexture_async(const ::MumbleServer::AMD_Server_getTexturePtr &, ::Ice::Int, const Ice::Current &);
+
+	virtual void setTexture_async(const ::MumbleServer::AMD_Server_setTexturePtr &, ::Ice::Int,
+								  const ::MumbleServer::Texture &, const Ice::Current &);
+
+	virtual void getUptime_async(const ::MumbleServer::AMD_Server_getUptimePtr &, const Ice::Current &);
+
+	virtual void updateCertificate_async(const ::MumbleServer::AMD_Server_updateCertificatePtr &, const std::string &,
+										 const std::string &, const std::string &, const Ice::Current &);
+
+	virtual void startListening_async(const ::MumbleServer::AMD_Server_startListeningPtr &, ::Ice::Int, ::Ice::Int,
+									  const Ice::Current &);
+
+	virtual void stopListening_async(const ::MumbleServer::AMD_Server_stopListeningPtr &, ::Ice::Int, ::Ice::Int,
+									 const Ice::Current &);
+
+	virtual void isListening_async(const ::MumbleServer::AMD_Server_isListeningPtr &, ::Ice::Int, ::Ice::Int,
+								   const Ice::Current &);
+
+	virtual void getListeningChannels_async(const ::MumbleServer::AMD_Server_getListeningChannelsPtr &, ::Ice::Int,
+											const Ice::Current &);
+
+	virtual void getListeningUsers_async(const ::MumbleServer::AMD_Server_getListeningUsersPtr &, ::Ice::Int,
+										 const Ice::Current &);
+
+	virtual void sendWelcomeMessage_async(const ::MumbleServer::AMD_Server_sendWelcomeMessagePtr &,
+										  const ::MumbleServer::IdList &p1, const ::Ice::Current &current);
+
+	virtual void ice_ping(const Ice::Current &) const;
+};
+
+class MetaI : virtual public Meta {
+public:
+	virtual void getSliceChecksums_async(const ::MumbleServer::AMD_Meta_getSliceChecksumsPtr &, const ::Ice::Current &);
+
+	virtual void getServer_async(const ::MumbleServer::AMD_Meta_getServerPtr &, ::Ice::Int, const Ice::Current &);
+
+	virtual void newServer_async(const ::MumbleServer::AMD_Meta_newServerPtr &, const Ice::Current &);
+
+	virtual void getBootedServers_async(const ::MumbleServer::AMD_Meta_getBootedServersPtr &, const Ice::Current &);
+
+	virtual void getAllServers_async(const ::MumbleServer::AMD_Meta_getAllServersPtr &, const Ice::Current &);
+
+	virtual void getDefaultConf_async(const ::MumbleServer::AMD_Meta_getDefaultConfPtr &, const Ice::Current &);
+
+	virtual void getVersion_async(const ::MumbleServer::AMD_Meta_getVersionPtr &, const Ice::Current &);
+
+
+	virtual void addCallback_async(const ::MumbleServer::AMD_Meta_addCallbackPtr &,
+								   const ::MumbleServer::MetaCallbackPrx &, const ::Ice::Current & = ::Ice::Current());
+	virtual void removeCallback_async(const ::MumbleServer::AMD_Meta_removeCallbackPtr &,
+									  const ::MumbleServer::MetaCallbackPrx &,
+									  const ::Ice::Current & = ::Ice::Current());
+
+	virtual void getUptime_async(const ::MumbleServer::AMD_Meta_getUptimePtr &, const Ice::Current &);
+
+	virtual void getSlice_async(const ::MumbleServer::AMD_Meta_getSlicePtr &, const Ice::Current &);
+};
+
+} // namespace MumbleServer
+
+#endif
diff --git a/src/murmur/MurmurIce.cpp b/src/murmur/MumbleServerIce.cpp
index 928033f91..69a098b4c 100644
--- a/src/murmur/MurmurIce.cpp
+++ b/src/murmur/MumbleServerIce.cpp
@@ -3,13 +3,13 @@
 // that can be found in the LICENSE file at the root of the
 // Mumble source tree or at <https://www.mumble.info/LICENSE>.
 
-#include "MurmurIce.h"
+#include "MumbleServerIce.h"
 
 #include "Ban.h"
 #include "Channel.h"
 #include "Group.h"
 #include "Meta.h"
-#include "MurmurI.h"
+#include "MumbleServer.h"
 #include "QtUtils.h"
 #include "Server.h"
 #include "ServerDB.h"
@@ -30,9 +30,9 @@
 #include <limits>
 
 using namespace std;
-using namespace Murmur;
+using namespace MumbleServer;
 
-static MurmurIce *mi = nullptr;
+static MumbleServerIce *mi = nullptr;
 static Ice::ObjectPtr iopServer;
 static Ice::PropertiesPtr ippProperties;
 
@@ -41,7 +41,7 @@ void IceParse(int &argc, char *argv[]) {
 }
 
 void IceStart() {
-	mi = new MurmurIce();
+	mi = new MumbleServerIce();
 }
 
 void IceStop() {
@@ -90,12 +90,12 @@ static std::string iceBase64(const std::string &s) {
 	return std::string(ba64.data(), static_cast< size_t >(ba64.size()));
 }
 
-static void logToLog(const ServerDB::LogRecord &r, Murmur::LogEntry &le) {
+static void logToLog(const ServerDB::LogRecord &r, ::MumbleServer::LogEntry &le) {
 	le.timestamp = r.first;
 	le.txt       = iceString(r.second);
 }
 
-static void userToUser(const ::User *p, Murmur::User &mp) {
+static void userToUser(const ::User *p, ::MumbleServer::User &mp) {
 	mp.session         = p->uiSession;
 	mp.userid          = p->iId;
 	mp.name            = iceString(p->qsName);
@@ -130,7 +130,7 @@ static void userToUser(const ::User *p, Murmur::User &mp) {
 	mp.tcponly = u->aiUdpFlag.load() == 0;
 #endif
 
-	::Murmur::NetAddress addr(16, 0);
+	::MumbleServer::NetAddress addr(16, 0);
 	const Q_IPV6ADDR &a = u->haAddress.qip6;
 	for (int i = 0; i < 16; ++i)
 		addr[i] = a[i];
@@ -138,7 +138,7 @@ static void userToUser(const ::User *p, Murmur::User &mp) {
 	mp.address = addr;
 }
 
-static void channelToChannel(const ::Channel *c, Murmur::Channel &mc) {
+static void channelToChannel(const ::Channel *c, ::MumbleServer::Channel &mc) {
 	mc.id          = c->iId;
 	mc.name        = iceString(c->qsName);
 	mc.parent      = c->cParent ? c->cParent->iId : -1;
@@ -150,7 +150,7 @@ static void channelToChannel(const ::Channel *c, Murmur::Channel &mc) {
 	mc.temporary = c->bTemporary;
 }
 
-static void ACLtoACL(const ::ChanACL *acl, Murmur::ACL &ma) {
+static void ACLtoACL(const ::ChanACL *acl, ::MumbleServer::ACL &ma) {
 	ma.applyHere = acl->bApplyHere;
 	ma.applySubs = acl->bApplySubs;
 	ma.inherited = false;
@@ -160,7 +160,7 @@ static void ACLtoACL(const ::ChanACL *acl, Murmur::ACL &ma) {
 	ma.deny      = acl->pDeny;
 }
 
-static void groupToGroup(const ::Group *g, Murmur::Group &mg) {
+static void groupToGroup(const ::Group *g, ::MumbleServer::Group &mg) {
 	mg.name        = iceString(g->qsName);
 	mg.inherit     = g->bInherit;
 	mg.inheritable = g->bInheritable;
@@ -169,8 +169,8 @@ static void groupToGroup(const ::Group *g, Murmur::Group &mg) {
 	mg.members.clear();
 }
 
-static void banToBan(const ::Ban &b, Murmur::Ban &mb) {
-	::Murmur::NetAddress addr(16, 0);
+static void banToBan(const ::Ban &b, ::MumbleServer::Ban &mb) {
+	::MumbleServer::NetAddress addr(16, 0);
 	const Q_IPV6ADDR &a = b.haAddress.qip6;
 	for (int i = 0; i < 16; ++i)
 		addr[i] = a[i];
@@ -184,7 +184,7 @@ static void banToBan(const ::Ban &b, Murmur::Ban &mb) {
 	mb.duration = b.iDuration;
 }
 
-static void banToBan(const ::Murmur::Ban &mb, ::Ban &b) {
+static void banToBan(const ::MumbleServer::Ban &mb, ::Ban &b) {
 	if (mb.address.size() != 16)
 		for (int i = 0; i < 16; ++i)
 			b.haAddress.qip6[i] = 0;
@@ -199,19 +199,19 @@ static void banToBan(const ::Murmur::Ban &mb, ::Ban &b) {
 	b.iDuration  = mb.duration;
 }
 
-static void infoToInfo(const QMap< int, QString > &info, Murmur::UserInfoMap &im) {
+static void infoToInfo(const QMap< int, QString > &info, ::MumbleServer::UserInfoMap &im) {
 	QMap< int, QString >::const_iterator i;
 	for (i = info.constBegin(); i != info.constEnd(); ++i)
-		im[static_cast< Murmur::UserInfo >(i.key())] = iceString(i.value());
+		im[static_cast<::MumbleServer::UserInfo >(i.key())] = iceString(i.value());
 }
 
-static void infoToInfo(const Murmur::UserInfoMap &im, QMap< int, QString > &info) {
-	Murmur::UserInfoMap::const_iterator i;
+static void infoToInfo(const ::MumbleServer::UserInfoMap &im, QMap< int, QString > &info) {
+	::MumbleServer::UserInfoMap::const_iterator i;
 	for (i = im.begin(); i != im.end(); ++i)
 		info.insert((*i).first, u8((*i).second));
 }
 
-static void textmessageToTextmessage(const ::TextMessage &tm, Murmur::TextMessage &tmdst) {
+static void textmessageToTextmessage(const ::TextMessage &tm, ::MumbleServer::TextMessage &tmdst) {
 	tmdst.text = iceString(tm.qsText);
 
 	foreach (unsigned int i, tm.qlSessions)
@@ -231,7 +231,7 @@ public:
 	virtual void deactivate(const std::string &){};
 };
 
-MurmurIce::MurmurIce() {
+MumbleServerIce::MumbleServerIce() {
 	count = 0;
 
 	if (meta->mp.qsIceEndpoint.isEmpty())
@@ -262,7 +262,7 @@ MurmurIce::MurmurIce() {
 			if (impl)
 				impl->put("secret", iceString(meta->mp.qsIceSecretWrite));
 		}
-		adapter   = communicator->createObjectAdapterWithEndpoints("Murmur", qPrintable(meta->mp.qsIceEndpoint));
+		adapter   = communicator->createObjectAdapterWithEndpoints("Mumble Server", qPrintable(meta->mp.qsIceEndpoint));
 		MetaPtr m = new MetaI;
 #if ICE_INT_VERSION >= 30700
 		MetaPrx mprx = MetaPrx::uncheckedCast(adapter->add(m, Ice::stringToIdentity("Meta")));
@@ -275,68 +275,68 @@ MurmurIce::MurmurIce() {
 
 		adapter->activate();
 		foreach (const Ice::EndpointPtr ep, mprx->ice_getEndpoints()) {
-			qWarning("MurmurIce: Endpoint \"%s\" running", qPrintable(u8(ep->toString())));
+			qWarning("MumbleServerIce: Endpoint \"%s\" running", qPrintable(u8(ep->toString())));
 		}
 
 		meta->connectListener(this);
 	} catch (Ice::Exception &e) {
 #if ICE_INT_VERSION >= 30700
-		qCritical("MurmurIce: Initialization failed: %s", qPrintable(u8(e.ice_id())));
+		qCritical("MumbleServerIce: Initialization failed: %s", qPrintable(u8(e.ice_id())));
 #else
-		qCritical("MurmurIce: Initialization failed: %s", qPrintable(u8(e.ice_name())));
+		qCritical("MumbleServerIce: Initialization failed: %s", qPrintable(u8(e.ice_name())));
 #endif
 	}
 }
 
-MurmurIce::~MurmurIce() {
+MumbleServerIce::~MumbleServerIce() {
 	if (communicator) {
 		communicator->shutdown();
 		communicator->waitForShutdown();
 		communicator->destroy();
 		communicator = nullptr;
-		qWarning("MurmurIce: Shutdown complete");
+		qWarning("MumbleServerIce: Shutdown complete");
 	}
 	iopServer = nullptr;
 }
 
-void MurmurIce::customEvent(QEvent *evt) {
+void MumbleServerIce::customEvent(QEvent *evt) {
 	if (evt->type() == EXEC_QEVENT)
 		static_cast< ExecEvent * >(evt)->execute();
 }
 
-void MurmurIce::badMetaProxy(const ::Murmur::MetaCallbackPrx &prx) {
+void MumbleServerIce::badMetaProxy(const ::MumbleServer::MetaCallbackPrx &prx) {
 	qCritical("Ice MetaCallback %s failed", qPrintable(QString::fromStdString(communicator->proxyToString(prx))));
 	removeMetaCallback(prx);
 }
 
-void MurmurIce::badServerProxy(const ::Murmur::ServerCallbackPrx &prx, const ::Server *server) {
+void MumbleServerIce::badServerProxy(const ::MumbleServer::ServerCallbackPrx &prx, const ::Server *server) {
 	server->log(QString("Ice ServerCallback %1 failed").arg(QString::fromStdString(communicator->proxyToString(prx))));
 	removeServerCallback(server, prx);
 }
 
-void MurmurIce::badAuthenticator(::Server *server) {
+void MumbleServerIce::badAuthenticator(::Server *server) {
 	server->disconnectAuthenticator(this);
-	const ::Murmur::ServerAuthenticatorPrx &prx = qmServerAuthenticator.value(server->iServerNum);
+	const ::MumbleServer::ServerAuthenticatorPrx &prx = qmServerAuthenticator.value(server->iServerNum);
 	server->log(QString("Ice Authenticator %1 failed").arg(QString::fromStdString(communicator->proxyToString(prx))));
 	removeServerAuthenticator(server);
 	removeServerUpdatingAuthenticator(server);
 }
 
-void MurmurIce::addMetaCallback(const ::Murmur::MetaCallbackPrx &prx) {
+void MumbleServerIce::addMetaCallback(const ::MumbleServer::MetaCallbackPrx &prx) {
 	if (!qlMetaCallbacks.contains(prx)) {
 		qWarning("Added Ice MetaCallback %s", qPrintable(QString::fromStdString(communicator->proxyToString(prx))));
 		qlMetaCallbacks.append(prx);
 	}
 }
 
-void MurmurIce::removeMetaCallback(const ::Murmur::MetaCallbackPrx &prx) {
+void MumbleServerIce::removeMetaCallback(const ::MumbleServer::MetaCallbackPrx &prx) {
 	if (qlMetaCallbacks.removeAll(prx)) {
 		qWarning("Removed Ice MetaCallback %s", qPrintable(QString::fromStdString(communicator->proxyToString(prx))));
 	}
 }
 
-void MurmurIce::addServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx) {
-	QList<::Murmur::ServerCallbackPrx > &cbList = qmServerCallbacks[server->iServerNum];
+void MumbleServerIce::addServerCallback(const ::Server *server, const ::MumbleServer::ServerCallbackPrx &prx) {
+	QList<::MumbleServer::ServerCallbackPrx > &cbList = qmServerCallbacks[server->iServerNum];
 
 	if (!cbList.contains(prx)) {
 		server->log(
@@ -345,23 +345,23 @@ void MurmurIce::addServerCallback(const ::Server *server, const ::Murmur::Server
 	}
 }
 
-void MurmurIce::removeServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx) {
+void MumbleServerIce::removeServerCallback(const ::Server *server, const ::MumbleServer::ServerCallbackPrx &prx) {
 	if (qmServerCallbacks[server->iServerNum].removeAll(prx)) {
 		server->log(
 			QString("Removed Ice ServerCallback %1").arg(QString::fromStdString(communicator->proxyToString(prx))));
 	}
 }
 
-void MurmurIce::removeServerCallbacks(const ::Server *server) {
+void MumbleServerIce::removeServerCallbacks(const ::Server *server) {
 	if (qmServerCallbacks.contains(server->iServerNum)) {
 		server->log(QString("Removed all Ice ServerCallbacks"));
 		qmServerCallbacks.remove(server->iServerNum);
 	}
 }
 
-void MurmurIce::addServerContextCallback(const ::Server *server, int session_id, const QString &action,
-										 const ::Murmur::ServerContextCallbackPrx &prx) {
-	QMap< QString, ::Murmur::ServerContextCallbackPrx > &callbacks =
+void MumbleServerIce::addServerContextCallback(const ::Server *server, int session_id, const QString &action,
+											   const ::MumbleServer::ServerContextCallbackPrx &prx) {
+	QMap< QString, ::MumbleServer::ServerContextCallbackPrx > &callbacks =
 		qmServerContextCallbacks[server->iServerNum][session_id];
 
 	if (!callbacks.contains(action) || callbacks[action] != prx) {
@@ -373,18 +373,19 @@ void MurmurIce::addServerContextCallback(const ::Server *server, int session_id,
 	}
 }
 
-const QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > >
-	MurmurIce::getServerContextCallbacks(const ::Server *server) const {
+const QMap< int, QMap< QString, ::MumbleServer::ServerContextCallbackPrx > >
+	MumbleServerIce::getServerContextCallbacks(const ::Server *server) const {
 	return qmServerContextCallbacks[server->iServerNum];
 }
 
-void MurmurIce::removeServerContextCallback(const ::Server *server, int session_id, const QString &action) {
+void MumbleServerIce::removeServerContextCallback(const ::Server *server, int session_id, const QString &action) {
 	if (qmServerContextCallbacks[server->iServerNum][session_id].remove(action)) {
 		server->log(QString("Removed Ice ServerContextCallback for session %1, action %2").arg(session_id).arg(action));
 	}
 }
 
-void MurmurIce::setServerAuthenticator(const ::Server *server, const ::Murmur::ServerAuthenticatorPrx &prx) {
+void MumbleServerIce::setServerAuthenticator(const ::Server *server,
+											 const ::MumbleServer::ServerAuthenticatorPrx &prx) {
 	if (prx != qmServerAuthenticator[server->iServerNum]) {
 		server->log(
 			QString("Set Ice Authenticator to %1").arg(QString::fromStdString(communicator->proxyToString(prx))));
@@ -392,19 +393,19 @@ void MurmurIce::setServerAuthenticator(const ::Server *server, const ::Murmur::S
 	}
 }
 
-const ::Murmur::ServerAuthenticatorPrx MurmurIce::getServerAuthenticator(const ::Server *server) const {
+const ::MumbleServer::ServerAuthenticatorPrx MumbleServerIce::getServerAuthenticator(const ::Server *server) const {
 	return qmServerAuthenticator[server->iServerNum];
 }
 
-void MurmurIce::removeServerAuthenticator(const ::Server *server) {
+void MumbleServerIce::removeServerAuthenticator(const ::Server *server) {
 	if (qmServerAuthenticator.remove(server->iServerNum)) {
 		server->log(QString("Removed Ice Authenticator %1")
 						.arg(QString::fromStdString(communicator->proxyToString(getServerAuthenticator(server)))));
 	}
 }
 
-void MurmurIce::setServerUpdatingAuthenticator(const ::Server *server,
-											   const ::Murmur::ServerUpdatingAuthenticatorPrx &prx) {
+void MumbleServerIce::setServerUpdatingAuthenticator(const ::Server *server,
+													 const ::MumbleServer::ServerUpdatingAuthenticatorPrx &prx) {
 	if (prx != qmServerUpdatingAuthenticator[server->iServerNum]) {
 		server->log(QString("Set Ice UpdatingAuthenticator to %1")
 						.arg(QString::fromStdString(communicator->proxyToString(prx))));
@@ -412,11 +413,12 @@ void MurmurIce::setServerUpdatingAuthenticator(const ::Server *server,
 	}
 }
 
-const ::Murmur::ServerUpdatingAuthenticatorPrx MurmurIce::getServerUpdatingAuthenticator(const ::Server *server) const {
+const ::MumbleServer::ServerUpdatingAuthenticatorPrx
+	MumbleServerIce::getServerUpdatingAuthenticator(const ::Server *server) const {
 	return qmServerUpdatingAuthenticator[server->iServerNum];
 }
 
-void MurmurIce::removeServerUpdatingAuthenticator(const ::Server *server) {
+void MumbleServerIce::removeServerUpdatingAuthenticator(const ::Server *server) {
 	if (qmServerUpdatingAuthenticator.contains(server->iServerNum)) {
 		server->log(
 			QString("Removed Ice UpdatingAuthenticator %1")
@@ -433,17 +435,17 @@ static ServerPrx idToProxy(int id, const Ice::ObjectAdapterPtr &adapter) {
 	return ServerPrx::uncheckedCast(adapter->createProxy(ident));
 }
 
-void MurmurIce::started(::Server *s) {
+void MumbleServerIce::started(::Server *s) {
 	s->connectListener(mi);
 	connect(s, SIGNAL(contextAction(const User *, const QString &, unsigned int, int)), this,
 			SLOT(contextAction(const User *, const QString &, unsigned int, int)));
 
-	const QList<::Murmur::MetaCallbackPrx > &qlList = qlMetaCallbacks;
+	const QList<::MumbleServer::MetaCallbackPrx > &qlList = qlMetaCallbacks;
 
 	if (qlList.isEmpty())
 		return;
 
-	foreach (const ::Murmur::MetaCallbackPrx &prx, qlList) {
+	foreach (const ::MumbleServer::MetaCallbackPrx &prx, qlList) {
 		try {
 			prx->started(idToProxy(s->iServerNum, adapter));
 		} catch (...) {
@@ -452,17 +454,17 @@ void MurmurIce::started(::Server *s) {
 	}
 }
 
-void MurmurIce::stopped(::Server *s) {
+void MumbleServerIce::stopped(::Server *s) {
 	removeServerCallbacks(s);
 	removeServerAuthenticator(s);
 	removeServerUpdatingAuthenticator(s);
 
-	const QList<::Murmur::MetaCallbackPrx > &qmList = qlMetaCallbacks;
+	const QList<::MumbleServer::MetaCallbackPrx > &qmList = qlMetaCallbacks;
 
 	if (qmList.isEmpty())
 		return;
 
-	foreach (const ::Murmur::MetaCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::MetaCallbackPrx &prx, qmList) {
 		try {
 			prx->stopped(idToProxy(s->iServerNum, adapter));
 		} catch (...) {
@@ -471,18 +473,18 @@ void MurmurIce::stopped(::Server *s) {
 	}
 }
 
-void MurmurIce::userConnected(const ::User *p) {
+void MumbleServerIce::userConnected(const ::User *p) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::User mp;
+	::MumbleServer::User mp;
 	userToUser(p, mp);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->userConnected(mp);
 		} catch (...) {
@@ -491,20 +493,20 @@ void MurmurIce::userConnected(const ::User *p) {
 	}
 }
 
-void MurmurIce::userDisconnected(const ::User *p) {
+void MumbleServerIce::userDisconnected(const ::User *p) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
 	qmServerContextCallbacks[s->iServerNum].remove(p->uiSession);
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::User mp;
+	::MumbleServer::User mp;
 	userToUser(p, mp);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->userDisconnected(mp);
 		} catch (...) {
@@ -513,18 +515,18 @@ void MurmurIce::userDisconnected(const ::User *p) {
 	}
 }
 
-void MurmurIce::userStateChanged(const ::User *p) {
+void MumbleServerIce::userStateChanged(const ::User *p) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::User mp;
+	::MumbleServer::User mp;
 	userToUser(p, mp);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->userStateChanged(mp);
 		} catch (...) {
@@ -533,21 +535,21 @@ void MurmurIce::userStateChanged(const ::User *p) {
 	}
 }
 
-void MurmurIce::userTextMessage(const ::User *p, const ::TextMessage &message) {
+void MumbleServerIce::userTextMessage(const ::User *p, const ::TextMessage &message) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::User mp;
+	::MumbleServer::User mp;
 	userToUser(p, mp);
 
-	::Murmur::TextMessage textMessage;
+	::MumbleServer::TextMessage textMessage;
 	textmessageToTextmessage(message, textMessage);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->userTextMessage(mp, textMessage);
 		} catch (...) {
@@ -556,18 +558,18 @@ void MurmurIce::userTextMessage(const ::User *p, const ::TextMessage &message) {
 	}
 }
 
-void MurmurIce::channelCreated(const ::Channel *c) {
+void MumbleServerIce::channelCreated(const ::Channel *c) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::Channel mc;
+	::MumbleServer::Channel mc;
 	channelToChannel(c, mc);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->channelCreated(mc);
 		} catch (...) {
@@ -576,18 +578,18 @@ void MurmurIce::channelCreated(const ::Channel *c) {
 	}
 }
 
-void MurmurIce::channelRemoved(const ::Channel *c) {
+void MumbleServerIce::channelRemoved(const ::Channel *c) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::Channel mc;
+	::MumbleServer::Channel mc;
 	channelToChannel(c, mc);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->channelRemoved(mc);
 		} catch (...) {
@@ -596,18 +598,18 @@ void MurmurIce::channelRemoved(const ::Channel *c) {
 	}
 }
 
-void MurmurIce::channelStateChanged(const ::Channel *c) {
+void MumbleServerIce::channelStateChanged(const ::Channel *c) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
+	const QList<::MumbleServer::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
 
 	if (qmList.isEmpty())
 		return;
 
-	::Murmur::Channel mc;
+	::MumbleServer::Channel mc;
 	channelToChannel(c, mc);
 
-	foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
+	foreach (const ::MumbleServer::ServerCallbackPrx &prx, qmList) {
 		try {
 			prx->channelStateChanged(mc);
 		} catch (...) {
@@ -616,24 +618,25 @@ void MurmurIce::channelStateChanged(const ::Channel *c) {
 	}
 }
 
-void MurmurIce::contextAction(const ::User *pSrc, const QString &action, unsigned int session, int iChannel) {
+void MumbleServerIce::contextAction(const ::User *pSrc, const QString &action, unsigned int session, int iChannel) {
 	::Server *s = qobject_cast<::Server * >(sender());
 
-	QMap< int, QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > > &qmAll = qmServerContextCallbacks;
+	QMap< int, QMap< int, QMap< QString, ::MumbleServer::ServerContextCallbackPrx > > > &qmAll =
+		qmServerContextCallbacks;
 	if (!qmAll.contains(s->iServerNum))
 		return;
 
-	QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > &qmServer = qmAll[s->iServerNum];
+	QMap< int, QMap< QString, ::MumbleServer::ServerContextCallbackPrx > > &qmServer = qmAll[s->iServerNum];
 	if (!qmServer.contains(pSrc->uiSession))
 		return;
 
-	QMap< QString, ::Murmur::ServerContextCallbackPrx > &qmUser = qmServer[pSrc->uiSession];
+	QMap< QString, ::MumbleServer::ServerContextCallbackPrx > &qmUser = qmServer[pSrc->uiSession];
 	if (!qmUser.contains(action))
 		return;
 
-	const ::Murmur::ServerContextCallbackPrx &prx = qmUser[action];
+	const ::MumbleServer::ServerContextCallbackPrx &prx = qmUser[action];
 
-	::Murmur::User mp;
+	::MumbleServer::User mp;
 	userToUser(pSrc, mp);
 
 	try {
@@ -655,7 +658,7 @@ void MurmurIce::contextAction(const ::User *pSrc, const QString &action, unsigne
 	}
 }
 
-void MurmurIce::idToNameSlot(QString &name, int id) {
+void MumbleServerIce::idToNameSlot(QString &name, int id) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerAuthenticatorPrx prx = getServerAuthenticator(server);
@@ -665,12 +668,12 @@ void MurmurIce::idToNameSlot(QString &name, int id) {
 		badAuthenticator(server);
 	}
 }
-void MurmurIce::idToTextureSlot(QByteArray &qba, int id) {
+void MumbleServerIce::idToTextureSlot(QByteArray &qba, int id) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerAuthenticatorPrx prx = getServerAuthenticator(server);
 	try {
-		const ::Murmur::Texture &tex = prx->idToTexture(id);
+		const ::MumbleServer::Texture &tex = prx->idToTexture(id);
 
 		qba.resize(static_cast< int >(tex.size()));
 		char *ptr = qba.data();
@@ -681,7 +684,7 @@ void MurmurIce::idToTextureSlot(QByteArray &qba, int id) {
 	}
 }
 
-void MurmurIce::nameToIdSlot(int &id, const QString &name) {
+void MumbleServerIce::nameToIdSlot(int &id, const QString &name) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerAuthenticatorPrx prx = getServerAuthenticator(server);
@@ -692,18 +695,19 @@ void MurmurIce::nameToIdSlot(int &id, const QString &name) {
 	}
 }
 
-void MurmurIce::authenticateSlot(int &res, QString &uname, int sessionId, const QList< QSslCertificate > &certlist,
-								 const QString &certhash, bool certstrong, const QString &pw) {
+void MumbleServerIce::authenticateSlot(int &res, QString &uname, int sessionId,
+									   const QList< QSslCertificate > &certlist, const QString &certhash,
+									   bool certstrong, const QString &pw) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerAuthenticatorPrx prx = getServerAuthenticator(server);
 	::std::string newname;
-	::Murmur::GroupNameList groups;
-	::Murmur::CertificateList certs;
+	::MumbleServer::GroupNameList groups;
+	::MumbleServer::CertificateList certs;
 
 	certs.resize(certlist.size());
 	for (int i = 0; i < certlist.size(); ++i) {
-		::Murmur::CertificateDer der;
+		::MumbleServer::CertificateDer der;
 		QByteArray qba = certlist.at(i).toDer();
 		der.resize(qba.size());
 		const char *ptr = qba.constData();
@@ -728,14 +732,14 @@ void MurmurIce::authenticateSlot(int &res, QString &uname, int sessionId, const
 	}
 }
 
-void MurmurIce::registerUserSlot(int &res, const QMap< int, QString > &info) {
+void MumbleServerIce::registerUserSlot(int &res, const QMap< int, QString > &info) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerUpdatingAuthenticatorPrx prx = getServerUpdatingAuthenticator(server);
 	if (!prx)
 		return;
 
-	::Murmur::UserInfoMap im;
+	::MumbleServer::UserInfoMap im;
 
 	infoToInfo(info, im);
 	try {
@@ -745,7 +749,7 @@ void MurmurIce::registerUserSlot(int &res, const QMap< int, QString > &info) {
 	}
 }
 
-void MurmurIce::unregisterUserSlot(int &res, int id) {
+void MumbleServerIce::unregisterUserSlot(int &res, int id) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerUpdatingAuthenticatorPrx prx = getServerUpdatingAuthenticator(server);
@@ -758,14 +762,14 @@ void MurmurIce::unregisterUserSlot(int &res, int id) {
 	}
 }
 
-void MurmurIce::getRegistrationSlot(int &res, int id, QMap< int, QString > &info) {
+void MumbleServerIce::getRegistrationSlot(int &res, int id, QMap< int, QString > &info) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerUpdatingAuthenticatorPrx prx = getServerUpdatingAuthenticator(server);
 	if (!prx)
 		return;
 
-	Murmur::UserInfoMap im;
+	::MumbleServer::UserInfoMap im;
 	try {
 		if (prx->getInfo(id, im)) {
 			res = 1;
@@ -777,14 +781,14 @@ void MurmurIce::getRegistrationSlot(int &res, int id, QMap< int, QString > &info
 	}
 }
 
-void MurmurIce::getRegisteredUsersSlot(const QString &filter, QMap< int, QString > &m) {
+void MumbleServerIce::getRegisteredUsersSlot(const QString &filter, QMap< int, QString > &m) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerUpdatingAuthenticatorPrx prx = getServerUpdatingAuthenticator(server);
 	if (!prx)
 		return;
 
-	::Murmur::NameMap lst;
+	::MumbleServer::NameMap lst;
 
 	try {
 		lst = prx->getRegisteredUsers(iceString(filter));
@@ -792,19 +796,19 @@ void MurmurIce::getRegisteredUsersSlot(const QString &filter, QMap< int, QString
 		badAuthenticator(server);
 		return;
 	}
-	::Murmur::NameMap::const_iterator i;
+	::MumbleServer::NameMap::const_iterator i;
 	for (i = lst.begin(); i != lst.end(); ++i)
 		m.insert((*i).first, u8((*i).second));
 }
 
-void MurmurIce::setInfoSlot(int &res, int id, const QMap< int, QString > &info) {
+void MumbleServerIce::setInfoSlot(int &res, int id, const QMap< int, QString > &info) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerUpdatingAuthenticatorPrx prx = getServerUpdatingAuthenticator(server);
 	if (!prx)
 		return;
 
-	Murmur::UserInfoMap im;
+	MumbleServer::UserInfoMap im;
 	infoToInfo(info, im);
 
 	try {
@@ -814,14 +818,14 @@ void MurmurIce::setInfoSlot(int &res, int id, const QMap< int, QString > &info)
 	}
 }
 
-void MurmurIce::setTextureSlot(int &res, int id, const QByteArray &texture) {
+void MumbleServerIce::setTextureSlot(int &res, int id, const QByteArray &texture) {
 	::Server *server = qobject_cast<::Server * >(sender());
 
 	const ServerUpdatingAuthenticatorPrx prx = getServerUpdatingAuthenticator(server);
 	if (!prx)
 		return;
 
-	::Murmur::Texture tex;
+	::MumbleServer::Texture tex;
 	tex.resize(texture.size());
 	const char *ptr = texture.constData();
 	for (int i = 0; i < texture.size(); ++i)
@@ -854,18 +858,18 @@ Ice::ObjectPtr ServerLocator::locate(const Ice::Current &, Ice::LocalObjectPtr &
 		return;                                     \
 	}
 
-#define NEED_PLAYER                                             \
-	ServerUser *user = server->qhUsers.value(session);          \
-	if (!user) {                                                \
-		cb->ice_exception(::Murmur::InvalidSessionException()); \
-		return;                                                 \
+#define NEED_PLAYER                                                   \
+	ServerUser *user = server->qhUsers.value(session);                \
+	if (!user) {                                                      \
+		cb->ice_exception(::MumbleServer::InvalidSessionException()); \
+		return;                                                       \
 	}
 
-#define NEED_CHANNEL_VAR(x, y)                                  \
-	x = server->qhChannels.value(y);                            \
-	if (!x) {                                                   \
-		cb->ice_exception(::Murmur::InvalidChannelException()); \
-		return;                                                 \
+#define NEED_CHANNEL_VAR(x, y)                                        \
+	x = server->qhChannels.value(y);                                  \
+	if (!x) {                                                         \
+		cb->ice_exception(::MumbleServer::InvalidChannelException()); \
+		return;                                                       \
 	}
 
 #define NEED_CHANNEL    \
@@ -880,12 +884,12 @@ void ServerI::ice_ping(const Ice::Current &current) const {
 }
 
 #define ACCESS_Server_isRunning_READ
-static void impl_Server_isRunning(const ::Murmur::AMD_Server_isRunningPtr cb, int server_id) {
+static void impl_Server_isRunning(const ::MumbleServer::AMD_Server_isRunningPtr cb, int server_id) {
 	NEED_SERVER_EXISTS;
 	cb->ice_response(server != nullptr);
 }
 
-static void impl_Server_start(const ::Murmur::AMD_Server_startPtr cb, int server_id) {
+static void impl_Server_start(const ::MumbleServer::AMD_Server_startPtr cb, int server_id) {
 	NEED_SERVER_EXISTS;
 	if (server)
 		cb->ice_exception(ServerBootedException());
@@ -895,13 +899,13 @@ static void impl_Server_start(const ::Murmur::AMD_Server_startPtr cb, int server
 		cb->ice_response();
 }
 
-static void impl_Server_stop(const ::Murmur::AMD_Server_stopPtr cb, int server_id) {
+static void impl_Server_stop(const ::MumbleServer::AMD_Server_stopPtr cb, int server_id) {
 	NEED_SERVER;
 	meta->kill(server_id);
 	cb->ice_response();
 }
 
-static void impl_Server_delete(const ::Murmur::AMD_Server_deletePtr cb, int server_id) {
+static void impl_Server_delete(const ::MumbleServer::AMD_Server_deletePtr cb, int server_id) {
 	NEED_SERVER_EXISTS;
 	if (server) {
 		cb->ice_exception(ServerBootedException());
@@ -911,13 +915,13 @@ static void impl_Server_delete(const ::Murmur::AMD_Server_deletePtr cb, int serv
 	cb->ice_response();
 }
 
-static void impl_Server_addCallback(const Murmur::AMD_Server_addCallbackPtr cb, int server_id,
-									const Murmur::ServerCallbackPrx &cbptr) {
+static void impl_Server_addCallback(const MumbleServer::AMD_Server_addCallbackPtr cb, int server_id,
+									const MumbleServer::ServerCallbackPrx &cbptr) {
 	NEED_SERVER;
 
 	try {
-		const Murmur::ServerCallbackPrx &oneway =
-			Murmur::ServerCallbackPrx::checkedCast(cbptr->ice_oneway()->ice_connectionCached(false));
+		const MumbleServer::ServerCallbackPrx &oneway =
+			MumbleServer::ServerCallbackPrx::checkedCast(cbptr->ice_oneway()->ice_connectionCached(false));
 		mi->addServerCallback(server, oneway);
 		cb->ice_response();
 	} catch (...) {
@@ -925,13 +929,13 @@ static void impl_Server_addCallback(const Murmur::AMD_Server_addCallbackPtr cb,
 	}
 }
 
-static void impl_Server_removeCallback(const Murmur::AMD_Server_removeCallbackPtr cb, int server_id,
-									   const Murmur::ServerCallbackPrx &cbptr) {
+static void impl_Server_removeCallback(const MumbleServer::AMD_Server_removeCallbackPtr cb, int server_id,
+									   const MumbleServer::ServerCallbackPrx &cbptr) {
 	NEED_SERVER;
 
 	try {
-		const Murmur::ServerCallbackPrx &oneway =
-			Murmur::ServerCallbackPrx::uncheckedCast(cbptr->ice_oneway()->ice_connectionCached(false));
+		const MumbleServer::ServerCallbackPrx &oneway =
+			MumbleServer::ServerCallbackPrx::uncheckedCast(cbptr->ice_oneway()->ice_connectionCached(false));
 		mi->removeServerCallback(server, oneway);
 		cb->ice_response();
 	} catch (...) {
@@ -939,19 +943,19 @@ static void impl_Server_removeCallback(const Murmur::AMD_Server_removeCallbackPt
 	}
 }
 
-static void impl_Server_setAuthenticator(const ::Murmur::AMD_Server_setAuthenticatorPtr &cb, int server_id,
-										 const ::Murmur::ServerAuthenticatorPrx &aptr) {
+static void impl_Server_setAuthenticator(const ::MumbleServer::AMD_Server_setAuthenticatorPtr &cb, int server_id,
+										 const ::MumbleServer::ServerAuthenticatorPrx &aptr) {
 	NEED_SERVER;
 
 	if (mi->getServerAuthenticator(server))
 		server->disconnectAuthenticator(mi);
 
-	::Murmur::ServerAuthenticatorPrx prx;
+	::MumbleServer::ServerAuthenticatorPrx prx;
 
 	try {
-		prx = ::Murmur::ServerAuthenticatorPrx::checkedCast(aptr->ice_connectionCached(false)->ice_timeout(5000));
-		const ::Murmur::ServerUpdatingAuthenticatorPrx uprx =
-			::Murmur::ServerUpdatingAuthenticatorPrx::checkedCast(prx);
+		prx = ::MumbleServer::ServerAuthenticatorPrx::checkedCast(aptr->ice_connectionCached(false)->ice_timeout(5000));
+		const ::MumbleServer::ServerUpdatingAuthenticatorPrx uprx =
+			::MumbleServer::ServerUpdatingAuthenticatorPrx::checkedCast(prx);
 
 		mi->setServerAuthenticator(server, prx);
 		if (uprx)
@@ -968,13 +972,14 @@ static void impl_Server_setAuthenticator(const ::Murmur::AMD_Server_setAuthentic
 }
 
 #define ACCESS_Server_id_READ
-static void impl_Server_id(const ::Murmur::AMD_Server_idPtr cb, int server_id) {
+static void impl_Server_id(const ::MumbleServer::AMD_Server_idPtr cb, int server_id) {
 	NEED_SERVER_EXISTS;
 	cb->ice_response(server_id);
 }
 
 #define ACCESS_Server_getConf_READ
-static void impl_Server_getConf(const ::Murmur::AMD_Server_getConfPtr cb, int server_id, const ::std::string &key) {
+static void impl_Server_getConf(const ::MumbleServer::AMD_Server_getConfPtr cb, int server_id,
+								const ::std::string &key) {
 	NEED_SERVER_EXISTS;
 	if (key == "key" || key == "passphrase")
 		cb->ice_exception(WriteOnlyException());
@@ -983,10 +988,10 @@ static void impl_Server_getConf(const ::Murmur::AMD_Server_getConfPtr cb, int se
 }
 
 #define ACCESS_Server_getAllConf_READ
-static void impl_Server_getAllConf(const ::Murmur::AMD_Server_getAllConfPtr cb, int server_id) {
+static void impl_Server_getAllConf(const ::MumbleServer::AMD_Server_getAllConfPtr cb, int server_id) {
 	NEED_SERVER_EXISTS;
 
-	::Murmur::ConfigMap cm;
+	::MumbleServer::ConfigMap cm;
 
 	QMap< QString, QString > values = ServerDB::getAllConf(server_id);
 	QMap< QString, QString >::const_iterator i;
@@ -998,7 +1003,7 @@ static void impl_Server_getAllConf(const ::Murmur::AMD_Server_getAllConfPtr cb,
 	cb->ice_response(cm);
 }
 
-static void impl_Server_setConf(const ::Murmur::AMD_Server_setConfPtr cb, int server_id, const ::std::string &key,
+static void impl_Server_setConf(const ::MumbleServer::AMD_Server_setConfPtr cb, int server_id, const ::std::string &key,
 								const ::std::string &value) {
 	NEED_SERVER_EXISTS;
 	QString k = u8(key);
@@ -1011,7 +1016,7 @@ static void impl_Server_setConf(const ::Murmur::AMD_Server_setConfPtr cb, int se
 	cb->ice_response();
 }
 
-static void impl_Server_setSuperuserPassword(const ::Murmur::AMD_Server_setSuperuserPasswordPtr cb, int server_id,
+static void impl_Server_setSuperuserPassword(const ::MumbleServer::AMD_Server_setSuperuserPasswordPtr cb, int server_id,
 											 const ::std::string &pw) {
 	NEED_SERVER_EXISTS;
 	ServerDB::setSUPW(server_id, u8(pw));
@@ -1019,14 +1024,15 @@ static void impl_Server_setSuperuserPassword(const ::Murmur::AMD_Server_setSuper
 }
 
 #define ACCESS_Server_getLog_READ
-static void impl_Server_getLog(const ::Murmur::AMD_Server_getLogPtr cb, int server_id, ::Ice::Int min, ::Ice::Int max) {
+static void impl_Server_getLog(const ::MumbleServer::AMD_Server_getLogPtr cb, int server_id, ::Ice::Int min,
+							   ::Ice::Int max) {
 	NEED_SERVER_EXISTS;
 
-	::Murmur::LogList ll;
+	::MumbleServer::LogList ll;
 
 	QList< ServerDB::LogRecord > dblog = ServerDB::getLog(server_id, min, max);
 	foreach (const ServerDB::LogRecord &e, dblog) {
-		::Murmur::LogEntry le;
+		::MumbleServer::LogEntry le;
 		logToLog(e, le);
 		ll.push_back(le);
 	}
@@ -1034,7 +1040,7 @@ static void impl_Server_getLog(const ::Murmur::AMD_Server_getLogPtr cb, int serv
 }
 
 #define ACCESS_Server_getLogLen_READ
-static void impl_Server_getLogLen(const ::Murmur::AMD_Server_getLogLenPtr cb, int server_id) {
+static void impl_Server_getLogLen(const ::MumbleServer::AMD_Server_getLogLenPtr cb, int server_id) {
 	NEED_SERVER_EXISTS;
 
 	int len = ServerDB::getLogLen(server_id);
@@ -1042,11 +1048,11 @@ static void impl_Server_getLogLen(const ::Murmur::AMD_Server_getLogLenPtr cb, in
 }
 
 #define ACCESS_Server_getUsers_READ
-static void impl_Server_getUsers(const ::Murmur::AMD_Server_getUsersPtr cb, int server_id) {
+static void impl_Server_getUsers(const ::MumbleServer::AMD_Server_getUsersPtr cb, int server_id) {
 	NEED_SERVER;
-	::Murmur::UserMap pm;
+	::MumbleServer::UserMap pm;
 	foreach (const ::User *p, server->qhUsers) {
-		::Murmur::User mp;
+		::MumbleServer::User mp;
 		if (static_cast< const ServerUser * >(p)->sState == ::ServerUser::Authenticated) {
 			userToUser(p, mp);
 			pm[p->uiSession] = mp;
@@ -1056,11 +1062,11 @@ static void impl_Server_getUsers(const ::Murmur::AMD_Server_getUsersPtr cb, int
 }
 
 #define ACCESS_Server_getChannels_READ
-static void impl_Server_getChannels(const ::Murmur::AMD_Server_getChannelsPtr cb, int server_id) {
+static void impl_Server_getChannels(const ::MumbleServer::AMD_Server_getChannelsPtr cb, int server_id) {
 	NEED_SERVER;
-	::Murmur::ChannelMap cm;
+	::MumbleServer::ChannelMap cm;
 	foreach (const ::Channel *c, server->qhChannels) {
-		::Murmur::Channel mc;
+		::MumbleServer::Channel mc;
 		channelToChannel(c, mc);
 		cm[c->iId] = mc;
 	}
@@ -1082,7 +1088,7 @@ TreePtr recurseTree(const ::Channel *c) {
 	std::sort(users.begin(), users.end(), userSort);
 
 	foreach (const ::User *p, users) {
-		::Murmur::User mp;
+		::MumbleServer::User mp;
 		userToUser(p, mp);
 		t->users.push_back(mp);
 	}
@@ -1096,24 +1102,24 @@ TreePtr recurseTree(const ::Channel *c) {
 }
 
 #define ACCESS_Server_getTree_READ
-static void impl_Server_getTree(const ::Murmur::AMD_Server_getTreePtr cb, int server_id) {
+static void impl_Server_getTree(const ::MumbleServer::AMD_Server_getTreePtr cb, int server_id) {
 	NEED_SERVER;
 	cb->ice_response(recurseTree(server->qhChannels.value(0)));
 }
 
 #define ACCESS_Server_getCertificateList_READ
-static void impl_Server_getCertificateList(const ::Murmur::AMD_Server_getCertificateListPtr cb, int server_id,
+static void impl_Server_getCertificateList(const ::MumbleServer::AMD_Server_getCertificateListPtr cb, int server_id,
 										   ::Ice::Int session) {
 	NEED_SERVER;
 	NEED_PLAYER;
 
-	::Murmur::CertificateList certs;
+	::MumbleServer::CertificateList certs;
 
 	const QList< QSslCertificate > &certlist = user->peerCertificateChain();
 
 	certs.resize(certlist.size());
 	for (int i = 0; i < certlist.size(); ++i) {
-		::Murmur::CertificateDer der;
+		::MumbleServer::CertificateDer der;
 		QByteArray qba = certlist.at(i).toDer();
 		der.resize(qba.size());
 		const char *ptr = qba.constData();
@@ -1125,24 +1131,24 @@ static void impl_Server_getCertificateList(const ::Murmur::AMD_Server_getCertifi
 }
 
 #define ACCESS_Server_getBans_READ
-static void impl_Server_getBans(const ::Murmur::AMD_Server_getBansPtr cb, int server_id) {
+static void impl_Server_getBans(const ::MumbleServer::AMD_Server_getBansPtr cb, int server_id) {
 	NEED_SERVER;
-	::Murmur::BanList bl;
+	::MumbleServer::BanList bl;
 	foreach (const ::Ban &ban, server->qlBans) {
-		::Murmur::Ban mb;
+		::MumbleServer::Ban mb;
 		banToBan(ban, mb);
 		bl.push_back(mb);
 	}
 	cb->ice_response(bl);
 }
 
-static void impl_Server_setBans(const ::Murmur::AMD_Server_setBansPtr cb, int server_id,
-								const ::Murmur::BanList &bans) {
+static void impl_Server_setBans(const ::MumbleServer::AMD_Server_setBansPtr cb, int server_id,
+								const ::MumbleServer::BanList &bans) {
 	NEED_SERVER;
 	{
 		QWriteLocker wl(&server->qrwlVoiceThread);
 		server->qlBans.clear();
-		foreach (const ::Murmur::Ban &mb, bans) {
+		foreach (const ::MumbleServer::Ban &mb, bans) {
 			::Ban ban;
 			banToBan(mb, ban);
 			server->qlBans << ban;
@@ -1154,7 +1160,7 @@ static void impl_Server_setBans(const ::Murmur::AMD_Server_setBansPtr cb, int se
 	cb->ice_response();
 }
 
-static void impl_Server_kickUser(const ::Murmur::AMD_Server_kickUserPtr cb, int server_id, ::Ice::Int session,
+static void impl_Server_kickUser(const ::MumbleServer::AMD_Server_kickUserPtr cb, int server_id, ::Ice::Int session,
 								 const ::std::string &reason) {
 	NEED_SERVER;
 	NEED_PLAYER;
@@ -1167,8 +1173,8 @@ static void impl_Server_kickUser(const ::Murmur::AMD_Server_kickUserPtr cb, int
 	cb->ice_response();
 }
 
-static void impl_Server_sendMessage(const ::Murmur::AMD_Server_sendMessagePtr cb, int server_id, ::Ice::Int session,
-									const ::std::string &text) {
+static void impl_Server_sendMessage(const ::MumbleServer::AMD_Server_sendMessagePtr cb, int server_id,
+									::Ice::Int session, const ::std::string &text) {
 	NEED_SERVER;
 	NEED_PLAYER;
 
@@ -1177,8 +1183,8 @@ static void impl_Server_sendMessage(const ::Murmur::AMD_Server_sendMessagePtr cb
 }
 
 #define ACCESS_Server_hasPermission_READ
-static void impl_Server_hasPermission(const ::Murmur::AMD_Server_hasPermissionPtr cb, int server_id, ::Ice::Int session,
-									  ::Ice::Int channelid, ::Ice::Int perm) {
+static void impl_Server_hasPermission(const ::MumbleServer::AMD_Server_hasPermissionPtr cb, int server_id,
+									  ::Ice::Int session, ::Ice::Int channelid, ::Ice::Int perm) {
 	NEED_SERVER;
 	NEED_PLAYER;
 	NEED_CHANNEL;
@@ -1186,7 +1192,7 @@ static void impl_Server_hasPermission(const ::Murmur::AMD_Server_hasPermissionPt
 }
 
 #define ACCESS_Server_effectivePermissions_READ
-static void impl_Server_effectivePermissions(const ::Murmur::AMD_Server_effectivePermissionsPtr cb, int server_id,
+static void impl_Server_effectivePermissions(const ::MumbleServer::AMD_Server_effectivePermissionsPtr cb, int server_id,
 											 ::Ice::Int session, ::Ice::Int channelid) {
 	NEED_SERVER;
 	NEED_PLAYER;
@@ -1194,13 +1200,14 @@ static void impl_Server_effectivePermissions(const ::Murmur::AMD_Server_effectiv
 	cb->ice_response(server->effectivePermissions(user, channel));
 }
 
-static void impl_Server_addContextCallback(const Murmur::AMD_Server_addContextCallbackPtr cb, int server_id,
+static void impl_Server_addContextCallback(const MumbleServer::AMD_Server_addContextCallbackPtr cb, int server_id,
 										   ::Ice::Int session, const ::std::string &action, const ::std::string &text,
-										   const ::Murmur::ServerContextCallbackPrx &cbptr, int ctx) {
+										   const ::MumbleServer::ServerContextCallbackPrx &cbptr, int ctx) {
 	NEED_SERVER;
 	NEED_PLAYER;
 
-	const QMap< QString, ::Murmur::ServerContextCallbackPrx > &qmPrx = mi->getServerContextCallbacks(server)[session];
+	const QMap< QString, ::MumbleServer::ServerContextCallbackPrx > &qmPrx =
+		mi->getServerContextCallbacks(server)[session];
 
 	if (!(ctx
 		  & (MumbleProto::ContextActionModify_Context_Server | MumbleProto::ContextActionModify_Context_Channel
@@ -1210,7 +1217,7 @@ static void impl_Server_addContextCallback(const Murmur::AMD_Server_addContextCa
 	}
 
 	try {
-		const Murmur::ServerContextCallbackPrx &oneway = Murmur::ServerContextCallbackPrx::checkedCast(
+		const MumbleServer::ServerContextCallbackPrx &oneway = MumbleServer::ServerContextCallbackPrx::checkedCast(
 			cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
 		if (qmPrx.contains(u8(action))) {
 			// Since the server has no notion of the ctx part of the context action
@@ -1235,20 +1242,20 @@ static void impl_Server_addContextCallback(const Murmur::AMD_Server_addContextCa
 	server->sendMessage(user, mpcam);
 }
 
-static void impl_Server_removeContextCallback(const Murmur::AMD_Server_removeContextCallbackPtr cb, int server_id,
-											  const Murmur::ServerContextCallbackPrx &cbptr) {
+static void impl_Server_removeContextCallback(const MumbleServer::AMD_Server_removeContextCallbackPtr cb, int server_id,
+											  const MumbleServer::ServerContextCallbackPrx &cbptr) {
 	NEED_SERVER;
 
-	const QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > &qmPrx =
+	const QMap< int, QMap< QString, ::MumbleServer::ServerContextCallbackPrx > > &qmPrx =
 		mi->getServerContextCallbacks(server);
 
 	try {
-		const Murmur::ServerContextCallbackPrx &oneway = Murmur::ServerContextCallbackPrx::uncheckedCast(
+		const MumbleServer::ServerContextCallbackPrx &oneway = MumbleServer::ServerContextCallbackPrx::uncheckedCast(
 			cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
 
 		foreach (int session, qmPrx.keys()) {
-			ServerUser *user                                              = server->qhUsers.value(session);
-			const QMap< QString, ::Murmur::ServerContextCallbackPrx > &qm = qmPrx[session];
+			ServerUser *user                                                    = server->qhUsers.value(session);
+			const QMap< QString, ::MumbleServer::ServerContextCallbackPrx > &qm = qmPrx[session];
 			foreach (const QString &act, qm.keys(oneway)) {
 				mi->removeServerContextCallback(server, session, act);
 
@@ -1269,17 +1276,17 @@ static void impl_Server_removeContextCallback(const Murmur::AMD_Server_removeCon
 }
 
 #define ACCESS_Server_getState_READ
-static void impl_Server_getState(const ::Murmur::AMD_Server_getStatePtr cb, int server_id, ::Ice::Int session) {
+static void impl_Server_getState(const ::MumbleServer::AMD_Server_getStatePtr cb, int server_id, ::Ice::Int session) {
 	NEED_SERVER;
 	NEED_PLAYER;
 
-	::Murmur::User mp;
+	::MumbleServer::User mp;
 	userToUser(user, mp);
 	cb->ice_response(mp);
 }
 
-static void impl_Server_setState(const ::Murmur::AMD_Server_setStatePtr cb, int server_id,
-								 const ::Murmur::User &state) {
+static void impl_Server_setState(const ::MumbleServer::AMD_Server_setStatePtr cb, int server_id,
+								 const ::MumbleServer::User &state) {
 	int session = state.session;
 	::Channel *channel;
 	NEED_SERVER;
@@ -1291,7 +1298,7 @@ static void impl_Server_setState(const ::Murmur::AMD_Server_setStatePtr cb, int
 	cb->ice_response();
 }
 
-static void impl_Server_sendMessageChannel(const ::Murmur::AMD_Server_sendMessageChannelPtr cb, int server_id,
+static void impl_Server_sendMessageChannel(const ::MumbleServer::AMD_Server_sendMessageChannelPtr cb, int server_id,
 										   ::Ice::Int channelid, bool tree, const ::std::string &text) {
 	NEED_SERVER;
 	NEED_CHANNEL;
@@ -1301,18 +1308,18 @@ static void impl_Server_sendMessageChannel(const ::Murmur::AMD_Server_sendMessag
 }
 
 #define ACCESS_Server_getChannelState_READ
-static void impl_Server_getChannelState(const ::Murmur::AMD_Server_getChannelStatePtr cb, int server_id,
+static void impl_Server_getChannelState(const ::MumbleServer::AMD_Server_getChannelStatePtr cb, int server_id,
 										::Ice::Int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
 
-	::Murmur::Channel mc;
+	::MumbleServer::Channel mc;
 	channelToChannel(channel, mc);
 	cb->ice_response(mc);
 }
 
-static void impl_Server_setChannelState(const ::Murmur::AMD_Server_setChannelStatePtr cb, int server_id,
-										const ::Murmur::Channel &state) {
+static void impl_Server_setChannelState(const ::MumbleServer::AMD_Server_setChannelStatePtr cb, int server_id,
+										const ::MumbleServer::Channel &state) {
 	int channelid = state.id;
 	NEED_SERVER;
 	NEED_CHANNEL;
@@ -1331,37 +1338,37 @@ static void impl_Server_setChannelState(const ::Murmur::AMD_Server_setChannelSta
 	}
 
 	if (!server->canNest(np, channel)) {
-		cb->ice_exception(::Murmur::NestingLimitException());
+		cb->ice_exception(::MumbleServer::NestingLimitException());
 		return;
 	}
 
 	if (!server->setChannelState(channel, np, qsName, newset, u8(state.description), state.position))
-		cb->ice_exception(::Murmur::InvalidChannelException());
+		cb->ice_exception(::MumbleServer::InvalidChannelException());
 	else
 		cb->ice_response();
 }
 
-static void impl_Server_removeChannel(const ::Murmur::AMD_Server_removeChannelPtr cb, int server_id,
+static void impl_Server_removeChannel(const ::MumbleServer::AMD_Server_removeChannelPtr cb, int server_id,
 									  ::Ice::Int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
 
 	if (!channel->cParent) {
-		cb->ice_exception(::Murmur::InvalidChannelException());
+		cb->ice_exception(::MumbleServer::InvalidChannelException());
 	} else {
 		server->removeChannel(channel);
 		cb->ice_response();
 	}
 }
 
-static void impl_Server_addChannel(const ::Murmur::AMD_Server_addChannelPtr cb, int server_id,
+static void impl_Server_addChannel(const ::MumbleServer::AMD_Server_addChannelPtr cb, int server_id,
 								   const ::std::string &name, ::Ice::Int parent) {
 	NEED_SERVER;
 	::Channel *p, *nc;
 	NEED_CHANNEL_VAR(p, parent);
 
 	if (!server->canNest(p)) {
-		cb->ice_exception(::Murmur::NestingLimitException());
+		cb->ice_exception(::MumbleServer::NestingLimitException());
 		return;
 	}
 
@@ -1382,12 +1389,12 @@ static void impl_Server_addChannel(const ::Murmur::AMD_Server_addChannelPtr cb,
 }
 
 #define ACCESS_Server_getACL_READ
-static void impl_Server_getACL(const ::Murmur::AMD_Server_getACLPtr cb, int server_id, ::Ice::Int channelid) {
+static void impl_Server_getACL(const ::MumbleServer::AMD_Server_getACLPtr cb, int server_id, ::Ice::Int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
 
-	::Murmur::ACLList acls;
-	::Murmur::GroupList groups;
+	::MumbleServer::ACLList acls;
+	::MumbleServer::GroupList groups;
 
 	QStack<::Channel * > chans;
 	::Channel *p;
@@ -1407,7 +1414,7 @@ static void impl_Server_getACL(const ::Murmur::AMD_Server_getACLPtr cb, int serv
 		p = chans.pop();
 		foreach (acl, p->qlACL) {
 			if ((p == channel) || (acl->bApplySubs)) {
-				::Murmur::ACL ma;
+				::MumbleServer::ACL ma;
 				ACLtoACL(acl, ma);
 				if (p != channel)
 					ma.inherited = true;
@@ -1423,7 +1430,7 @@ static void impl_Server_getACL(const ::Murmur::AMD_Server_getACLPtr cb, int serv
 		::Group *pg = p ? ::Group::getGroup(p, name) : nullptr;
 		if (!g && !pg)
 			continue;
-		::Murmur::Group mg;
+		::MumbleServer::Group mg;
 		groupToGroup(g ? g : pg, mg);
 		QSet< int > members;
 		if (pg)
@@ -1448,8 +1455,9 @@ static void impl_Server_getACL(const ::Murmur::AMD_Server_getACLPtr cb, int serv
 	cb->ice_response(acls, groups, inherit);
 }
 
-static void impl_Server_setACL(const ::Murmur::AMD_Server_setACLPtr cb, int server_id, ::Ice::Int channelid,
-							   const ::Murmur::ACLList &acls, const ::Murmur::GroupList &groups, bool inherit) {
+static void impl_Server_setACL(const ::MumbleServer::AMD_Server_setACLPtr cb, int server_id, ::Ice::Int channelid,
+							   const ::MumbleServer::ACLList &acls, const ::MumbleServer::GroupList &groups,
+							   bool inherit) {
 	NEED_SERVER;
 	NEED_CHANNEL;
 
@@ -1471,7 +1479,7 @@ static void impl_Server_setACL(const ::Murmur::AMD_Server_setACLPtr cb, int serv
 		channel->qlACL.clear();
 
 		channel->bInheritACL = inherit;
-		foreach (const ::Murmur::Group &gi, groups) {
+		foreach (const ::MumbleServer::Group &gi, groups) {
 			QString name    = u8(gi.name);
 			g               = new ::Group(channel, name);
 			g->bInherit     = gi.inherit;
@@ -1489,7 +1497,7 @@ static void impl_Server_setACL(const ::Murmur::AMD_Server_setACLPtr cb, int serv
 #endif
 			g->qsTemporary = hOldTemp.value(name);
 		}
-		foreach (const ::Murmur::ACL &ai, acls) {
+		foreach (const ::MumbleServer::ACL &ai, acls) {
 			acl             = new ChanACL(channel);
 			acl->bApplyHere = ai.applyHere;
 			acl->bApplySubs = ai.applySubs;
@@ -1506,19 +1514,19 @@ static void impl_Server_setACL(const ::Murmur::AMD_Server_setACLPtr cb, int serv
 }
 
 #define ACCESS_Server_getUserNames_READ
-static void impl_Server_getUserNames(const ::Murmur::AMD_Server_getUserNamesPtr cb, int server_id,
-									 const ::Murmur::IdList &ids) {
+static void impl_Server_getUserNames(const ::MumbleServer::AMD_Server_getUserNamesPtr cb, int server_id,
+									 const ::MumbleServer::IdList &ids) {
 	NEED_SERVER;
-	::Murmur::NameMap nm;
+	::MumbleServer::NameMap nm;
 	foreach (int userid, ids) { nm[userid] = iceString(server->getUserName(userid)); }
 	cb->ice_response(nm);
 }
 
 #define ACCESS_Server_getUserIds_READ
-static void impl_Server_getUserIds(const ::Murmur::AMD_Server_getUserIdsPtr cb, int server_id,
-								   const ::Murmur::NameList &names) {
+static void impl_Server_getUserIds(const ::MumbleServer::AMD_Server_getUserIdsPtr cb, int server_id,
+								   const ::MumbleServer::NameList &names) {
 	NEED_SERVER;
-	::Murmur::IdMap im;
+	::MumbleServer::IdMap im;
 	foreach (const string &n, names) {
 		QString name = u8(n);
 		im[n]        = server->getUserID(name);
@@ -1526,8 +1534,8 @@ static void impl_Server_getUserIds(const ::Murmur::AMD_Server_getUserIdsPtr cb,
 	cb->ice_response(im);
 }
 
-static void impl_Server_registerUser(const ::Murmur::AMD_Server_registerUserPtr cb, int server_id,
-									 const ::Murmur::UserInfoMap &im) {
+static void impl_Server_registerUser(const ::MumbleServer::AMD_Server_registerUserPtr cb, int server_id,
+									 const ::MumbleServer::UserInfoMap &im) {
 	NEED_SERVER;
 
 	QMap< int, QString > info;
@@ -1541,7 +1549,7 @@ static void impl_Server_registerUser(const ::Murmur::AMD_Server_registerUserPtr
 		cb->ice_response(userid);
 }
 
-static void impl_Server_unregisterUser(const ::Murmur::AMD_Server_unregisterUserPtr cb, int server_id,
+static void impl_Server_unregisterUser(const ::MumbleServer::AMD_Server_unregisterUserPtr cb, int server_id,
 									   ::Ice::Int userid) {
 	NEED_SERVER;
 
@@ -1554,8 +1562,8 @@ static void impl_Server_unregisterUser(const ::Murmur::AMD_Server_unregisterUser
 	}
 }
 
-static void impl_Server_updateRegistration(const ::Murmur::AMD_Server_updateRegistrationPtr cb, int server_id, int id,
-										   const ::Murmur::UserInfoMap &im) {
+static void impl_Server_updateRegistration(const ::MumbleServer::AMD_Server_updateRegistrationPtr cb, int server_id,
+										   int id, const ::MumbleServer::UserInfoMap &im) {
 	NEED_SERVER;
 
 	if (!server->isUserId(id)) {
@@ -1583,7 +1591,7 @@ static void impl_Server_updateRegistration(const ::Murmur::AMD_Server_updateRegi
 }
 
 #define ACCESS_Server_getRegistration_READ
-static void impl_Server_getRegistration(const ::Murmur::AMD_Server_getRegistrationPtr cb, int server_id,
+static void impl_Server_getRegistration(const ::MumbleServer::AMD_Server_getRegistrationPtr cb, int server_id,
 										::Ice::Int userid) {
 	NEED_SERVER;
 
@@ -1594,16 +1602,16 @@ static void impl_Server_getRegistration(const ::Murmur::AMD_Server_getRegistrati
 		return;
 	}
 
-	Murmur::UserInfoMap im;
+	MumbleServer::UserInfoMap im;
 	infoToInfo(info, im);
 	cb->ice_response(im);
 }
 
 #define ACCESS_Server_getRegisteredUsers_READ
-static void impl_Server_getRegisteredUsers(const ::Murmur::AMD_Server_getRegisteredUsersPtr cb, int server_id,
+static void impl_Server_getRegisteredUsers(const ::MumbleServer::AMD_Server_getRegisteredUsersPtr cb, int server_id,
 										   const ::std::string &filter) {
 	NEED_SERVER;
-	Murmur::NameMap rpl;
+	MumbleServer::NameMap rpl;
 
 	const QMap< int, QString > l = server->getRegisteredUsers(u8(filter));
 	QMap< int, QString >::const_iterator i;
@@ -1615,7 +1623,7 @@ static void impl_Server_getRegisteredUsers(const ::Murmur::AMD_Server_getRegiste
 }
 
 #define ACCESS_Server_verifyPassword_READ
-static void impl_Server_verifyPassword(const ::Murmur::AMD_Server_verifyPasswordPtr cb, int server_id,
+static void impl_Server_verifyPassword(const ::MumbleServer::AMD_Server_verifyPasswordPtr cb, int server_id,
 									   const ::std::string &name, const ::std::string &pw) {
 	NEED_SERVER;
 	QString uname = u8(name);
@@ -1623,7 +1631,8 @@ static void impl_Server_verifyPassword(const ::Murmur::AMD_Server_verifyPassword
 }
 
 #define ACCESS_Server_getTexture_READ
-static void impl_Server_getTexture(const ::Murmur::AMD_Server_getTexturePtr cb, int server_id, ::Ice::Int userid) {
+static void impl_Server_getTexture(const ::MumbleServer::AMD_Server_getTexturePtr cb, int server_id,
+								   ::Ice::Int userid) {
 	NEED_SERVER;
 
 	if (!server->isUserId(userid)) {
@@ -1633,7 +1642,7 @@ static void impl_Server_getTexture(const ::Murmur::AMD_Server_getTexturePtr cb,
 
 	const QByteArray &qba = server->getUserTexture(userid);
 
-	::Murmur::Texture tex;
+	::MumbleServer::Texture tex;
 	tex.resize(qba.size());
 	const char *ptr = qba.constData();
 	for (int i = 0; i < qba.size(); ++i)
@@ -1642,8 +1651,8 @@ static void impl_Server_getTexture(const ::Murmur::AMD_Server_getTexturePtr cb,
 	cb->ice_response(tex);
 }
 
-static void impl_Server_setTexture(const ::Murmur::AMD_Server_setTexturePtr cb, int server_id, ::Ice::Int userid,
-								   const ::Murmur::Texture &tex) {
+static void impl_Server_setTexture(const ::MumbleServer::AMD_Server_setTexturePtr cb, int server_id, ::Ice::Int userid,
+								   const ::MumbleServer::Texture &tex) {
 	NEED_SERVER;
 
 	if (!server->isUserId(userid)) {
@@ -1678,12 +1687,12 @@ static void impl_Server_setTexture(const ::Murmur::AMD_Server_setTexturePtr cb,
 }
 
 #define ACCESS_Server_getUptime_READ
-static void impl_Server_getUptime(const ::Murmur::AMD_Server_getUptimePtr cb, int server_id) {
+static void impl_Server_getUptime(const ::MumbleServer::AMD_Server_getUptimePtr cb, int server_id) {
 	NEED_SERVER;
 	cb->ice_response(static_cast< int >(server->tUptime.elapsed() / 1000000LL));
 }
 
-static void impl_Server_updateCertificate(const ::Murmur::AMD_Server_updateCertificatePtr cb, int server_id,
+static void impl_Server_updateCertificate(const ::MumbleServer::AMD_Server_updateCertificatePtr cb, int server_id,
 										  const ::std::string &certificate, const ::std::string &privateKey,
 										  const ::std::string &passphrase) {
 	NEED_SERVER;
@@ -1730,8 +1739,8 @@ static void impl_Server_updateCertificate(const ::Murmur::AMD_Server_updateCerti
 	cb->ice_response();
 }
 
-static void impl_Server_startListening(const ::Murmur::AMD_Server_startListeningPtr cb, int server_id, int session,
-									   int channelid) {
+static void impl_Server_startListening(const ::MumbleServer::AMD_Server_startListeningPtr cb, int server_id,
+									   int session, int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
 	NEED_PLAYER;
@@ -1741,7 +1750,7 @@ static void impl_Server_startListening(const ::Murmur::AMD_Server_startListening
 	cb->ice_response();
 }
 
-static void impl_Server_stopListening(const ::Murmur::AMD_Server_stopListeningPtr cb, int server_id, int session,
+static void impl_Server_stopListening(const ::MumbleServer::AMD_Server_stopListeningPtr cb, int server_id, int session,
 									  int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
@@ -1752,7 +1761,7 @@ static void impl_Server_stopListening(const ::Murmur::AMD_Server_stopListeningPt
 	cb->ice_response();
 }
 
-static void impl_Server_isListening(const ::Murmur::AMD_Server_isListeningPtr cb, int server_id, int session,
+static void impl_Server_isListening(const ::MumbleServer::AMD_Server_isListeningPtr cb, int server_id, int session,
 									int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
@@ -1761,12 +1770,12 @@ static void impl_Server_isListening(const ::Murmur::AMD_Server_isListeningPtr cb
 	cb->ice_response(server->m_channelListenerManager.isListening(user->uiSession, channel->iId));
 }
 
-static void impl_Server_getListeningChannels(const ::Murmur::AMD_Server_getListeningChannelsPtr cb, int server_id,
+static void impl_Server_getListeningChannels(const ::MumbleServer::AMD_Server_getListeningChannelsPtr cb, int server_id,
 											 int session) {
 	NEED_SERVER;
 	NEED_PLAYER;
 
-	::Murmur::IntList channelIDs;
+	::MumbleServer::IntList channelIDs;
 	foreach (int currentChannelID, server->m_channelListenerManager.getListenedChannelsForUser(user->uiSession)) {
 		channelIDs.push_back(currentChannelID);
 	}
@@ -1774,12 +1783,12 @@ static void impl_Server_getListeningChannels(const ::Murmur::AMD_Server_getListe
 	cb->ice_response(channelIDs);
 }
 
-static void impl_Server_getListeningUsers(const ::Murmur::AMD_Server_getListeningUsersPtr cb, int server_id,
+static void impl_Server_getListeningUsers(const ::MumbleServer::AMD_Server_getListeningUsersPtr cb, int server_id,
 										  int channelid) {
 	NEED_SERVER;
 	NEED_CHANNEL;
 
-	::Murmur::IntList userSessions;
+	::MumbleServer::IntList userSessions;
 	foreach (unsigned int currentSession, server->m_channelListenerManager.getListenersForChannel(channel->iId)) {
 		userSessions.push_back(currentSession);
 	}
@@ -1787,8 +1796,8 @@ static void impl_Server_getListeningUsers(const ::Murmur::AMD_Server_getListenin
 	cb->ice_response(userSessions);
 }
 
-static void impl_Server_sendWelcomeMessage(const ::Murmur::AMD_Server_sendWelcomeMessagePtr cb, int server_id,
-										   ::Murmur::IdList receiverUserIDs) {
+static void impl_Server_sendWelcomeMessage(const ::MumbleServer::AMD_Server_sendWelcomeMessagePtr cb, int server_id,
+										   ::MumbleServer::IdList receiverUserIDs) {
 	NEED_SERVER;
 
 	for (unsigned int session : receiverUserIDs) {
@@ -1800,7 +1809,7 @@ static void impl_Server_sendWelcomeMessage(const ::Murmur::AMD_Server_sendWelcom
 	cb->ice_response();
 }
 
-static void impl_Server_addUserToGroup(const ::Murmur::AMD_Server_addUserToGroupPtr cb, int server_id,
+static void impl_Server_addUserToGroup(const ::MumbleServer::AMD_Server_addUserToGroupPtr cb, int server_id,
 									   ::Ice::Int channelid, ::Ice::Int session, const ::std::string &group) {
 	NEED_SERVER;
 	NEED_PLAYER;
@@ -1827,7 +1836,7 @@ static void impl_Server_addUserToGroup(const ::Murmur::AMD_Server_addUserToGroup
 	cb->ice_response();
 }
 
-static void impl_Server_removeUserFromGroup(const ::Murmur::AMD_Server_removeUserFromGroupPtr cb, int server_id,
+static void impl_Server_removeUserFromGroup(const ::MumbleServer::AMD_Server_removeUserFromGroupPtr cb, int server_id,
 											::Ice::Int channelid, ::Ice::Int session, const ::std::string &group) {
 	NEED_SERVER;
 	NEED_PLAYER;
@@ -1854,7 +1863,7 @@ static void impl_Server_removeUserFromGroup(const ::Murmur::AMD_Server_removeUse
 	cb->ice_response();
 }
 
-static void impl_Server_redirectWhisperGroup(const ::Murmur::AMD_Server_redirectWhisperGroupPtr cb, int server_id,
+static void impl_Server_redirectWhisperGroup(const ::MumbleServer::AMD_Server_redirectWhisperGroupPtr cb, int server_id,
 											 ::Ice::Int session, const ::std::string &source,
 											 const ::std::string &target) {
 	NEED_SERVER;
@@ -1878,12 +1887,13 @@ static void impl_Server_redirectWhisperGroup(const ::Murmur::AMD_Server_redirect
 }
 
 #define ACCESS_Meta_getSliceChecksums_ALL
-static void impl_Meta_getSliceChecksums(const ::Murmur::AMD_Meta_getSliceChecksumsPtr cb, const Ice::ObjectAdapterPtr) {
+static void impl_Meta_getSliceChecksums(const ::MumbleServer::AMD_Meta_getSliceChecksumsPtr cb,
+										const Ice::ObjectAdapterPtr) {
 	cb->ice_response(::Ice::sliceChecksums());
 }
 
 #define ACCESS_Meta_getServer_READ
-static void impl_Meta_getServer(const ::Murmur::AMD_Meta_getServerPtr cb, const Ice::ObjectAdapterPtr adapter,
+static void impl_Meta_getServer(const ::MumbleServer::AMD_Meta_getServerPtr cb, const Ice::ObjectAdapterPtr adapter,
 								::Ice::Int id) {
 	QList< int > server_list = ServerDB::getAllServers();
 	if (!server_list.contains(id))
@@ -1892,13 +1902,14 @@ static void impl_Meta_getServer(const ::Murmur::AMD_Meta_getServerPtr cb, const
 		cb->ice_response(idToProxy(id, adapter));
 }
 
-static void impl_Meta_newServer(const ::Murmur::AMD_Meta_newServerPtr cb, const Ice::ObjectAdapterPtr adapter) {
+static void impl_Meta_newServer(const ::MumbleServer::AMD_Meta_newServerPtr cb, const Ice::ObjectAdapterPtr adapter) {
 	cb->ice_response(idToProxy(ServerDB::addServer(), adapter));
 }
 
 #define ACCESS_Meta_getAllServers_READ
-static void impl_Meta_getAllServers(const ::Murmur::AMD_Meta_getAllServersPtr cb, const Ice::ObjectAdapterPtr adapter) {
-	::Murmur::ServerList sl;
+static void impl_Meta_getAllServers(const ::MumbleServer::AMD_Meta_getAllServersPtr cb,
+									const Ice::ObjectAdapterPtr adapter) {
+	::MumbleServer::ServerList sl;
 
 	foreach (int id, ServerDB::getAllServers())
 		sl.push_back(idToProxy(id, adapter));
@@ -1906,8 +1917,8 @@ static void impl_Meta_getAllServers(const ::Murmur::AMD_Meta_getAllServersPtr cb
 }
 
 #define ACCESS_Meta_getDefaultConf_READ
-static void impl_Meta_getDefaultConf(const ::Murmur::AMD_Meta_getDefaultConfPtr cb, const Ice::ObjectAdapterPtr) {
-	::Murmur::ConfigMap cm;
+static void impl_Meta_getDefaultConf(const ::MumbleServer::AMD_Meta_getDefaultConfPtr cb, const Ice::ObjectAdapterPtr) {
+	::MumbleServer::ConfigMap cm;
 	QMap< QString, QString >::const_iterator i;
 	for (i = meta->mp.qmConfig.constBegin(); i != meta->mp.qmConfig.constEnd(); ++i) {
 		if (i.key() == "key" || i.key() == "passphrase")
@@ -1918,9 +1929,9 @@ static void impl_Meta_getDefaultConf(const ::Murmur::AMD_Meta_getDefaultConfPtr
 }
 
 #define ACCESS_Meta_getBootedServers_READ
-static void impl_Meta_getBootedServers(const ::Murmur::AMD_Meta_getBootedServersPtr cb,
+static void impl_Meta_getBootedServers(const ::MumbleServer::AMD_Meta_getBootedServersPtr cb,
 									   const Ice::ObjectAdapterPtr adapter) {
-	::Murmur::ServerList sl;
+	::MumbleServer::ServerList sl;
 
 	foreach (int id, meta->qhServers.keys())
 		sl.push_back(idToProxy(id, adapter));
@@ -1928,18 +1939,18 @@ static void impl_Meta_getBootedServers(const ::Murmur::AMD_Meta_getBootedServers
 }
 
 #define ACCESS_Meta_getVersion_ALL
-static void impl_Meta_getVersion(const ::Murmur::AMD_Meta_getVersionPtr cb, const Ice::ObjectAdapterPtr) {
+static void impl_Meta_getVersion(const ::MumbleServer::AMD_Meta_getVersionPtr cb, const Ice::ObjectAdapterPtr) {
 	Version::component_t major, minor, patch;
 	QString txt;
 	::Meta::getVersion(major, minor, patch, txt);
 	cb->ice_response(major, minor, patch, iceString(txt));
 }
 
-static void impl_Meta_addCallback(const Murmur::AMD_Meta_addCallbackPtr cb, const Ice::ObjectAdapterPtr,
-								  const Murmur::MetaCallbackPrx &cbptr) {
+static void impl_Meta_addCallback(const MumbleServer::AMD_Meta_addCallbackPtr cb, const Ice::ObjectAdapterPtr,
+								  const MumbleServer::MetaCallbackPrx &cbptr) {
 	try {
-		const Murmur::MetaCallbackPrx &oneway =
-			Murmur::MetaCallbackPrx::checkedCast(cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
+		const MumbleServer::MetaCallbackPrx &oneway = MumbleServer::MetaCallbackPrx::checkedCast(
+			cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
 		mi->addMetaCallback(oneway);
 		cb->ice_response();
 	} catch (...) {
@@ -1947,11 +1958,11 @@ static void impl_Meta_addCallback(const Murmur::AMD_Meta_addCallbackPtr cb, cons
 	}
 }
 
-static void impl_Meta_removeCallback(const Murmur::AMD_Meta_removeCallbackPtr cb, const Ice::ObjectAdapterPtr,
-									 const Murmur::MetaCallbackPrx &cbptr) {
+static void impl_Meta_removeCallback(const MumbleServer::AMD_Meta_removeCallbackPtr cb, const Ice::ObjectAdapterPtr,
+									 const MumbleServer::MetaCallbackPrx &cbptr) {
 	try {
-		const Murmur::MetaCallbackPrx &oneway =
-			Murmur::MetaCallbackPrx::uncheckedCast(cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
+		const MumbleServer::MetaCallbackPrx &oneway = MumbleServer::MetaCallbackPrx::uncheckedCast(
+			cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
 		mi->removeMetaCallback(oneway);
 		cb->ice_response();
 	} catch (...) {
@@ -1960,11 +1971,11 @@ static void impl_Meta_removeCallback(const Murmur::AMD_Meta_removeCallbackPtr cb
 }
 
 #define ACCESS_Meta_getUptime_ALL
-static void impl_Meta_getUptime(const ::Murmur::AMD_Meta_getUptimePtr cb, const Ice::ObjectAdapterPtr) {
+static void impl_Meta_getUptime(const ::MumbleServer::AMD_Meta_getUptimePtr cb, const Ice::ObjectAdapterPtr) {
 	cb->ice_response(static_cast< int >(meta->tUptime.elapsed() / 1000000LL));
 }
 
-#include "MurmurIceWrapper.cpp"
+#include "MumbleServerIceWrapper.cpp"
 
 #undef FIND_SERVER
 #undef NEED_SERVER_EXISTS
diff --git a/src/murmur/MurmurIce.h b/src/murmur/MumbleServerIce.h
index 80c954cd7..d8e6e520e 100644
--- a/src/murmur/MurmurIce.h
+++ b/src/murmur/MumbleServerIce.h
@@ -3,32 +3,31 @@
 // that can be found in the LICENSE file at the root of the
 // Mumble source tree or at <https://www.mumble.info/LICENSE>.
 
-#ifdef USE_ICE
-#	ifndef MUMBLE_MURMUR_MURMURICE_H_
-#		define MUMBLE_MURMUR_MURMURICE_H_
+#ifndef MUMBLE_MURMUR_MURMURICE_H_
+#define MUMBLE_MURMUR_MURMURICE_H_
 
-#		include <QtCore/QtGlobal>
+#include <QtCore/QtGlobal>
 
-#		if defined(Q_OS_WIN) && !defined(WIN32_LEAN_AND_MEAN)
+#if defined(Q_OS_WIN) && !defined(WIN32_LEAN_AND_MEAN)
 // To prevent <windows.h> (included by Ice) from including <winsock.h>.
-#			define WIN32_LEAN_AND_MEAN
-#		endif
+#	define WIN32_LEAN_AND_MEAN
+#endif
 
-#		include <QtCore/QList>
-#		include <QtCore/QMap>
-#		include <QtCore/QMutex>
-#		include <QtCore/QObject>
-#		include <QtCore/QWaitCondition>
-#		include <QtNetwork/QSslCertificate>
+#include <QtCore/QList>
+#include <QtCore/QMap>
+#include <QtCore/QMutex>
+#include <QtCore/QObject>
+#include <QtCore/QWaitCondition>
+#include <QtNetwork/QSslCertificate>
 
-#		include "MurmurI.h"
+#include "MumbleServerI.h"
 
 class Channel;
 class Server;
 class User;
 struct TextMessage;
 
-class MurmurIce : public QObject {
+class MumbleServerIce : public QObject {
 	friend class MurmurLocker;
 	Q_OBJECT;
 
@@ -37,36 +36,37 @@ protected:
 	QMutex qmEvent;
 	QWaitCondition qwcEvent;
 	void customEvent(QEvent *evt);
-	void badMetaProxy(const ::Murmur::MetaCallbackPrx &prx);
-	void badServerProxy(const ::Murmur::ServerCallbackPrx &prx, const ::Server *server);
+	void badMetaProxy(const ::MumbleServer::MetaCallbackPrx &prx);
+	void badServerProxy(const ::MumbleServer::ServerCallbackPrx &prx, const ::Server *server);
 	void badAuthenticator(::Server *);
-	QList<::Murmur::MetaCallbackPrx > qlMetaCallbacks;
-	QMap< int, QList<::Murmur::ServerCallbackPrx > > qmServerCallbacks;
-	QMap< int, QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > > qmServerContextCallbacks;
-	QMap< int, ::Murmur::ServerAuthenticatorPrx > qmServerAuthenticator;
-	QMap< int, ::Murmur::ServerUpdatingAuthenticatorPrx > qmServerUpdatingAuthenticator;
+	QList<::MumbleServer::MetaCallbackPrx > qlMetaCallbacks;
+	QMap< int, QList<::MumbleServer::ServerCallbackPrx > > qmServerCallbacks;
+	QMap< int, QMap< int, QMap< QString, ::MumbleServer::ServerContextCallbackPrx > > > qmServerContextCallbacks;
+	QMap< int, ::MumbleServer::ServerAuthenticatorPrx > qmServerAuthenticator;
+	QMap< int, ::MumbleServer::ServerUpdatingAuthenticatorPrx > qmServerUpdatingAuthenticator;
 
 public:
 	Ice::CommunicatorPtr communicator;
 	Ice::ObjectAdapterPtr adapter;
-	MurmurIce();
-	~MurmurIce();
+	MumbleServerIce();
+	~MumbleServerIce();
 
-	void addMetaCallback(const ::Murmur::MetaCallbackPrx &prx);
-	void removeMetaCallback(const ::Murmur::MetaCallbackPrx &prx);
-	void addServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx);
-	void removeServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx);
+	void addMetaCallback(const ::MumbleServer::MetaCallbackPrx &prx);
+	void removeMetaCallback(const ::MumbleServer::MetaCallbackPrx &prx);
+	void addServerCallback(const ::Server *server, const ::MumbleServer::ServerCallbackPrx &prx);
+	void removeServerCallback(const ::Server *server, const ::MumbleServer::ServerCallbackPrx &prx);
 	void removeServerCallbacks(const ::Server *server);
 	void addServerContextCallback(const ::Server *server, int session_id, const QString &action,
-								  const ::Murmur::ServerContextCallbackPrx &prx);
-	const QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > >
+								  const ::MumbleServer::ServerContextCallbackPrx &prx);
+	const QMap< int, QMap< QString, ::MumbleServer::ServerContextCallbackPrx > >
 		getServerContextCallbacks(const ::Server *server) const;
 	void removeServerContextCallback(const ::Server *server, int session_id, const QString &action);
-	void setServerAuthenticator(const ::Server *server, const ::Murmur::ServerAuthenticatorPrx &prx);
-	const ::Murmur::ServerAuthenticatorPrx getServerAuthenticator(const ::Server *server) const;
+	void setServerAuthenticator(const ::Server *server, const ::MumbleServer::ServerAuthenticatorPrx &prx);
+	const ::MumbleServer::ServerAuthenticatorPrx getServerAuthenticator(const ::Server *server) const;
 	void removeServerAuthenticator(const ::Server *server);
-	void setServerUpdatingAuthenticator(const ::Server *server, const ::Murmur::ServerUpdatingAuthenticatorPrx &prx);
-	const ::Murmur::ServerUpdatingAuthenticatorPrx getServerUpdatingAuthenticator(const ::Server *server) const;
+	void setServerUpdatingAuthenticator(const ::Server *server,
+										const ::MumbleServer::ServerUpdatingAuthenticatorPrx &prx);
+	const ::MumbleServer::ServerUpdatingAuthenticatorPrx getServerUpdatingAuthenticator(const ::Server *server) const;
 	void removeServerUpdatingAuthenticator(const ::Server *server);
 
 public slots:
@@ -96,5 +96,4 @@ public slots:
 
 	void contextAction(const User *, const QString &, unsigned int, int);
 };
-#	endif
 #endif
diff --git a/src/murmur/MurmurI.h b/src/murmur/MurmurI.h
deleted file mode 100644
index 0990362ec..000000000
--- a/src/murmur/MurmurI.h
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright 2008-2022 The Mumble Developers. All rights reserved.
-// Use of this source code is governed by a BSD-style license
-// that can be found in the LICENSE file at the root of the
-// Mumble source tree or at <https://www.mumble.info/LICENSE>.
-
-#ifndef MUMBLE_MURMUR_MURMURI_H_
-#define MUMBLE_MURMUR_MURMURI_H_
-
-#include <Murmur.h>
-
-namespace Murmur {
-
-class ServerI : virtual public Server {
-public:
-	virtual void isRunning_async(const ::Murmur::AMD_Server_isRunningPtr &, const Ice::Current &);
-
-	virtual void start_async(const ::Murmur::AMD_Server_startPtr &, const Ice::Current &);
-
-	virtual void stop_async(const ::Murmur::AMD_Server_stopPtr &, const Ice::Current &);
-
-	virtual void delete_async(const ::Murmur::AMD_Server_deletePtr &, const Ice::Current &);
-
-	virtual void addCallback_async(const ::Murmur::AMD_Server_addCallbackPtr &, const ::Murmur::ServerCallbackPrx &,
-								   const ::Ice::Current &);
-	virtual void removeCallback_async(const ::Murmur::AMD_Server_removeCallbackPtr &,
-									  const ::Murmur::ServerCallbackPrx &, const ::Ice::Current &);
-
-	virtual void setAuthenticator_async(const ::Murmur::AMD_Server_setAuthenticatorPtr &,
-										const ::Murmur::ServerAuthenticatorPrx &, const ::Ice::Current &);
-
-	virtual void id_async(const ::Murmur::AMD_Server_idPtr &, const Ice::Current &);
-
-	virtual void getConf_async(const ::Murmur::AMD_Server_getConfPtr &, const ::std::string &, const Ice::Current &);
-
-	virtual void getAllConf_async(const ::Murmur::AMD_Server_getAllConfPtr &, const Ice::Current &);
-
-	virtual void setConf_async(const ::Murmur::AMD_Server_setConfPtr &, const ::std::string &, const ::std::string &,
-							   const Ice::Current &);
-
-	virtual void setSuperuserPassword_async(const ::Murmur::AMD_Server_setSuperuserPasswordPtr &, const ::std::string &,
-											const Ice::Current &);
-
-	virtual void getLog_async(const ::Murmur::AMD_Server_getLogPtr &, ::Ice::Int, ::Ice::Int, const Ice::Current &);
-
-	virtual void getLogLen_async(const ::Murmur::AMD_Server_getLogLenPtr &, const Ice::Current &);
-
-	virtual void getUsers_async(const ::Murmur::AMD_Server_getUsersPtr &, const Ice::Current &);
-
-	virtual void getChannels_async(const ::Murmur::AMD_Server_getChannelsPtr &, const Ice::Current &);
-
-	virtual void getTree_async(const ::Murmur::AMD_Server_getTreePtr &, const Ice::Current &);
-
-	virtual void getCertificateList_async(const ::Murmur::AMD_Server_getCertificateListPtr &, ::Ice::Int,
-										  const ::Ice::Current &);
-
-	virtual void getBans_async(const ::Murmur::AMD_Server_getBansPtr &, const Ice::Current &);
-
-	virtual void setBans_async(const ::Murmur::AMD_Server_setBansPtr &, const ::Murmur::BanList &,
-							   const Ice::Current &);
-
-	virtual void kickUser_async(const ::Murmur::AMD_Server_kickUserPtr &, ::Ice::Int, const ::std::string &,
-								const Ice::Current &);
-
-	virtual void sendMessage_async(const ::Murmur::AMD_Server_sendMessagePtr &, ::Ice::Int, const ::std::string &,
-								   const Ice::Current &);
-
-	virtual void hasPermission_async(const ::Murmur::AMD_Server_hasPermissionPtr &, ::Ice::Int, ::Ice::Int, ::Ice::Int,
-									 const ::Ice::Current &);
-	virtual void effectivePermissions_async(const ::Murmur::AMD_Server_effectivePermissionsPtr &, ::Ice::Int,
-											::Ice::Int, const ::Ice::Current &);
-
-	virtual void addContextCallback_async(const ::Murmur::AMD_Server_addContextCallbackPtr &, ::Ice::Int,
-										  const ::std::string &, const ::std::string &,
-										  const ::Murmur::ServerContextCallbackPrx &, int, const ::Ice::Current &);
-	virtual void removeContextCallback_async(const ::Murmur::AMD_Server_removeContextCallbackPtr &,
-											 const ::Murmur::ServerContextCallbackPrx &, const ::Ice::Current &);
-
-	virtual void getState_async(const ::Murmur::AMD_Server_getStatePtr &, ::Ice::Int, const Ice::Current &);
-
-	virtual void setState_async(const ::Murmur::AMD_Server_setStatePtr &, const ::Murmur::User &, const Ice::Current &);
-
-	virtual void getChannelState_async(const ::Murmur::AMD_Server_getChannelStatePtr &, ::Ice::Int,
-									   const Ice::Current &);
-
-	virtual void setChannelState_async(const ::Murmur::AMD_Server_setChannelStatePtr &, const ::Murmur::Channel &,
-									   const Ice::Current &);
-
-	virtual void removeChannel_async(const ::Murmur::AMD_Server_removeChannelPtr &, ::Ice::Int, const Ice::Current &);
-
-	virtual void addChannel_async(const ::Murmur::AMD_Server_addChannelPtr &, const ::std::string &, ::Ice::Int,
-								  const Ice::Current &);
-
-	virtual void sendMessageChannel_async(const ::Murmur::AMD_Server_sendMessageChannelPtr &, ::Ice::Int, bool,
-										  const ::std::string &, const Ice::Current &);
-
-	virtual void getACL_async(const ::Murmur::AMD_Server_getACLPtr &, ::Ice::Int, const Ice::Current &);
-
-	virtual void setACL_async(const ::Murmur::AMD_Server_setACLPtr &, ::Ice::Int, const ::Murmur::ACLList &,
-							  const ::Murmur::GroupList &, bool, const Ice::Current &);
-
-	virtual void removeUserFromGroup_async(const ::Murmur::AMD_Server_removeUserFromGroupPtr &, ::Ice::Int, ::Ice::Int,
-										   const ::std::string &, const ::Ice::Current &);
-
-	virtual void addUserToGroup_async(const ::Murmur::AMD_Server_addUserToGroupPtr &, ::Ice::Int, ::Ice::Int,
-									  const ::std::string &, const ::Ice::Current &);
-
-	virtual void redirectWhisperGroup_async(const ::Murmur::AMD_Server_redirectWhisperGroupPtr &, ::Ice::Int,
-											const ::std::string &, const ::std::string &, const ::Ice::Current &);
-
-	virtual void getUserNames_async(const ::Murmur::AMD_Server_getUserNamesPtr &, const ::Murmur::IdList &,
-									const Ice::Current &);
-
-	virtual void getUserIds_async(const ::Murmur::AMD_Server_getUserIdsPtr &, const ::Murmur::NameList &,
-								  const Ice::Current &);
-
-	virtual void registerUser_async(const ::Murmur::AMD_Server_registerUserPtr &, const Murmur::UserInfoMap &,
-									const Ice::Current &);
-
-	virtual void unregisterUser_async(const ::Murmur::AMD_Server_unregisterUserPtr &, ::Ice::Int, const Ice::Current &);
-
-	virtual void updateRegistration_async(const ::Murmur::AMD_Server_updateRegistrationPtr &, Ice::Int,
-										  const Murmur::UserInfoMap &, const Ice::Current &);
-
-	virtual void getRegistration_async(const ::Murmur::AMD_Server_getRegistrationPtr &, ::Ice::Int,
-									   const Ice::Current &);
-
-	virtual void getRegisteredUsers_async(const ::Murmur::AMD_Server_getRegisteredUsersPtr &, const ::std::string &,
-										  const Ice::Current &);
-
-	virtual void verifyPassword_async(const ::Murmur::AMD_Server_verifyPasswordPtr &, const ::std::string &,
-									  const ::std::string &, const Ice::Current &);
-
-	virtual void getTexture_async(const ::Murmur::AMD_Server_getTexturePtr &, ::Ice::Int, const Ice::Current &);
-
-	virtual void setTexture_async(const ::Murmur::AMD_Server_setTexturePtr &, ::Ice::Int, const ::Murmur::Texture &,
-								  const Ice::Current &);
-
-	virtual void getUptime_async(const ::Murmur::AMD_Server_getUptimePtr &, const Ice::Current &);
-
-	virtual void updateCertificate_async(const ::Murmur::AMD_Server_updateCertificatePtr &, const std::string &,
-										 const std::string &, const std::string &, const Ice::Current &);
-
-	virtual void startListening_async(const ::Murmur::AMD_Server_startListeningPtr &, ::Ice::Int, ::Ice::Int,
-									  const Ice::Current &);
-
-	virtual void stopListening_async(const ::Murmur::AMD_Server_stopListeningPtr &, ::Ice::Int, ::Ice::Int,
-									 const Ice::Current &);
-
-	virtual void isListening_async(const ::Murmur::AMD_Server_isListeningPtr &, ::Ice::Int, ::Ice::Int,
-								   const Ice::Current &);
-
-	virtual void getListeningChannels_async(const ::Murmur::AMD_Server_getListeningChannelsPtr &, ::Ice::Int,
-											const Ice::Current &);
-
-	virtual void getListeningUsers_async(const ::Murmur::AMD_Server_getListeningUsersPtr &, ::Ice::Int,
-										 const Ice::Current &);
-
-	virtual void sendWelcomeMessage_async(const ::Murmur::AMD_Server_sendWelcomeMessagePtr &,
-										  const ::Murmur::IdList &p1, const ::Ice::Current &current);
-
-	virtual void ice_ping(const Ice::Current &) const;
-};
-
-class MetaI : virtual public Meta {
-public:
-	virtual void getSliceChecksums_async(const ::Murmur::AMD_Meta_getSliceChecksumsPtr &, const ::Ice::Current &);
-
-	virtual void getServer_async(const ::Murmur::AMD_Meta_getServerPtr &, ::Ice::Int, const Ice::Current &);
-
-	virtual void newServer_async(const ::Murmur::AMD_Meta_newServerPtr &, const Ice::Current &);
-
-	virtual void getBootedServers_async(const ::Murmur::AMD_Meta_getBootedServersPtr &, const Ice::Current &);
-
-	virtual void getAllServers_async(const ::Murmur::AMD_Meta_getAllServersPtr &, const Ice::Current &);
-
-	virtual void getDefaultConf_async(const ::Murmur::AMD_Meta_getDefaultConfPtr &, const Ice::Current &);
-
-	virtual void getVersion_async(const ::Murmur::AMD_Meta_getVersionPtr &, const Ice::Current &);
-
-
-	virtual void addCallback_async(const ::Murmur::AMD_Meta_addCallbackPtr &, const ::Murmur::MetaCallbackPrx &,
-								   const ::Ice::Current & = ::Ice::Current());
-	virtual void removeCallback_async(const ::Murmur::AMD_Meta_removeCallbackPtr &, const ::Murmur::MetaCallbackPrx &,
-									  const ::Ice::Current & = ::Ice::Current());
-
-	virtual void getUptime_async(const ::Murmur::AMD_Meta_getUptimePtr &, const Ice::Current &);
-
-	virtual void getSlice_async(const ::Murmur::AMD_Meta_getSlicePtr &, const Ice::Current &);
-};
-
-} // namespace Murmur
-
-#endif
author	Robert Adam <dev@robert-adam.de>	2022-09-08 14:48:40 +0300
committer	Robert Adam <dev@robert-adam.de>	2022-09-10 18:28:34 +0300
commit	b81b06001db4c7b76dc8ee3fc25b900452869336 (patch)
tree	83ea9e337fda98991e38a83ac5b0dfd51760045f
parent	18526924909720ca8947e74cb975501dc0681ffe (diff)