1.4.230: murmurd or mumble-server?

[tgurr]

Description

CMake install target installs bin/mumble-server but man1/murmurd.1 and scripts/murmur.service also wants to run bin/murmurd. In previously versions we had bin/murmurd for the server executable.

Steps to reproduce

1. build murmur 1.4.230
2. install
3. be confused about murmurd vs. mumble-server

Mumble version

1.4.230

Mumble component

Server

OS

Linux

Reproducible?

Yes

Additional information

No response

Relevant log output

No response

Screenshots

No response

[Krzmbrzl]

It's supposed to be mumble-server, but apparently we forgot to update the other files ^^

[dvzrv]

This goes even deeper, as e.g. murmur.ini wants murmur.sqlite in unspecified "default locations".

I believe the renaming should not be exposed to the end user this way, as it is far too inconsistent to coherently make sense. I think I will rename the mumble-server executable back to murmurd until this is resolved in the Arch Linux package.

[tgurr]

I will rename the mumble-server executable back to murmurd until this is resolved in the Arch Linux package.

FYI I did exactly the same as well for the Exherbo Linux package which itself also remains under the name murmur for now as it was too much of a hassle to fiddle with all the renaming in all other places apart from the executable.

[yhaenggi]

sane issue here. either fix the logic everywhere or revert this.

[Krzmbrzl]

We will not revert this. If this is causing trouble for you, you are free to create a PR to fix it. Otherwise we'll fix it eventually once we get to it. The priority for this is rather low though (imo)

[carlwgeorge]

How complete will the murmur to mumble-server transition be? Just the binary name, or will it include things like murmur.ini and murmur.service (the file name, not the ExecStart command)? I'm working on updating the Fedora package to 1.4.230 so it would be good to rename it all in the same package update.

[Krzmbrzl]

The transition will only affect the binary and a few mentions in the docs (maybe). Of other things I would be unaware :thinking: And of course our general recommendation for packagers to name the server package mumble-server instead of murmur (maybe make the latter an alias for the former for backwards compatibility).

[carlwgeorge]

Thanks for the quick response. I'll rename the package from murmur to mumble-server, but leave the unit file and config named murmur.

[dvzrv]

In 1.4.274 the sources are still not fully renamed, which means that I'll further stick with murmur for the Arch Linux package.

Please put a higher priority on this issue as it is super painful to package this project this way!

Files that are not renamed and reference murmur/murmurd (there are likely more):

• [ ] https://github.com/mumble-voip/mumble/blob/227d7fcee38d7bfdeac2aa9621f5b525ccdf3836/src/murmur/Murmur.ice
• [ ] https://github.com/mumble-voip/mumble/blob/cc73c7679b08158f91b02272efbb0e3e5dd9c9e4/src/murmur/MurmurRPC.proto
• [ ] https://github.com/mumble-voip/mumble/blob/227d7fcee38d7bfdeac2aa9621f5b525ccdf3836/scripts/murmur.ini
• [ ] https://github.com/mumble-voip/mumble/blob/cc73c7679b08158f91b02272efbb0e3e5dd9c9e4/scripts/murmur.conf
• [ ] https://github.com/mumble-voip/mumble/blob/cc73c7679b08158f91b02272efbb0e3e5dd9c9e4/scripts/murmur.logrotate
• [ ] https://github.com/mumble-voip/mumble/blob/cc73c7679b08158f91b02272efbb0e3e5dd9c9e4/scripts/murmur.service

Files that still reference murmur/murmurd but are renamed (there are likely more):

• [ ] https://github.com/mumble-voip/mumble/blob/cc73c7679b08158f91b02272efbb0e3e5dd9c9e4/scripts/mumble-server-user-wrapper

And of course our general recommendation for packagers to name the server package mumble-server instead of murmur (maybe make the latter an alias for the former for backwards compatibility).

@Krzmbrzl Why is this not done automatically using the build system in the install target though? It makes no sense for downstreams to hack around all of these issues separately. Either you as the upstream want to rename the executable (sub-project?) or not... this limbo is not great to put it mildly. As is, the install target installs a dysfunctional mumble-server-user-wrapper by default and the other files would all not work with mumble-server as they require murmurd as executable.

[Krzmbrzl]

Pull-requests are highly welcome. Otherwise the explanation is as usual: It has not been done yet, because nobody volunteered to spend their time on it.

That's not trying to be sassy, but merely stating the facts. Personally, I have always encountered much more pressing issues than this one to spend my (limited) time on...

I do understand that this can be a bit frustrating for packagers though.

[Krzmbrzl]

Note also that doing this properly is by no means a 5-minutes task:

$ find -type f -not -ipath "./.git/*" -not -ipath "./build/*" -exec grep -iF "murmur" {} /dev/null \;
./3rdPartyLicenses/mumble-old-license-headers/LICENSE.txt:Murmur's PBKDF2 support
./3rdPartyLicenses/mumble-old-license-headers/LICENSE.txt:      src/murmur/PBKDF2.cpp
./3rdPartyLicenses/mumble-old-license-headers/LICENSE.txt:      src/murmur/PBKDF2.h
./3rdparty/tracy/server/tracy_robin_hood.h:    // tried lots of different hashes, let's stick with murmurhash3. It's simple, fast, well tested,
./3rdparty/tracy/server/tracy_xxhash.h:MurmurHash 3a   2.7 GB/s     10       Austin Appleby
./3rdparty/tracy/zstd/common/xxhash.h:MurmurHash 3a   2.7 GB/s     10       Austin Appleby
./3rdparty/qqbonjour/README:Mumble and Murmur build. Because of this, there is no
./installer/ServerInstaller.cs:                 "Murmur.ice"
./installer/ServerInstaller.cs:         menuShortcut.IconFile = @"..\icons\murmur.ico";
./macx/scripts/gendmg.pl:       "Murmur Extras" => [ 363, 416 ],
./macx/scripts/osxdist.py:      name = 'Murmur-OSX-Static-%s' % ver
./macx/scripts/osxdist.py:      shutil.copy(os.path.join(options.binary_dir, 'scripts/murmur.pl'), os.path.join(destdir, 'murmur.pl'))
./macx/scripts/osxdist.py:      shutil.copy(os.path.join(options.binary_dir, 'scripts/murmur.ini.osx'), os.path.join(destdir, 'murmur.ini'))
./macx/scripts/osxdist.py:      shutil.copy(os.path.join(options.binary_dir, 'src/murmur/Murmur.ice'), os.path.join(destdir, 'Murmur.ice'))
./macx/scripts/osxdist.py:      shutil.copy(os.path.join(options.binary_dir, 'murmurd'), os.path.join(destdir, 'murmurd'))
./macx/scripts/osxdist.py:      codesign(os.path.join(destdir, 'murmurd'))
./macx/scripts/osxdist.py:              print('Failed to build Murmur XIP package')
./macx/scripts/osxdist.py:              print('Failed to build Murmur tar.bz2 package')
./macx/scripts/osxdist.py:              print('Failed to sign Murmur tar.bz2 package')
./macx/scripts/osxdist.py:      parser.add_option('', '--server', dest='server', help='Build a Murmur package.', action='store_true', default=False)
./man/mumble-overlay.1:.BR murmurd (1).
./man/mumble-overlay.1:mumble and murmurd were written by The Mumble Developers.
./man/mumble.1:.BR murmurd (1).
./man/mumble.1:mumble and murmurd were written by The Mumble Developers.
./man/mumble-server-user-wrapper.1:Set directory to use. By default, the wrapper script uses $HOME/murmur
./man/mumble-server-user-wrapper.1:Then edit ~/murmur/murmur.ini to set the various configuration settings. The
./man/mumble-server.1:a murmur.ini file and will fall back to builtin defaults if one isn't found.
./man/mumble-server.1:Gracefully reload the TLS settings specified in murmur.ini without interrupting service.
./man/mumble-server.1:from murmur.ini.
./man/mumble-server.1:Virtual servers that have overridden the settings from murmur.ini will not
./man/mumble-server.1:.BR murmur\-user\-wrapper (1).
./scripts/murmur.conf:    <allow own="net.sourceforge.mumble.murmur"/>
./scripts/murmur.conf:    <allow send_destination="net.sourceforge.mumble.murmur"/>
./scripts/murmur.conf:    <allow receive_sender="net.sourceforge.mumble.murmur"/>
./scripts/murmur.logrotate:             start-stop-daemon --quiet --oknodo --stop --signal 1 --exec /usr/sbin/murmurd --user mumble-server --pidfile /var/run/mumble-server/mumble-server.pid
./scripts/php.ini:ice.slice=Murmur.ice
./scripts/server/dbus/ListUsers.cs:             Meta m = bus.GetObject<Meta>("net.sourceforge.mumble.murmur", new ObjectPath("/"));
./scripts/server/dbus/ListUsers.cs:                     Server s = bus.GetObject<Server>("net.sourceforge.mumble.murmur", new ObjectPath(path));
./scripts/server/dbus/ListUsers.cs:[Interface ("net.sourceforge.mumble.Murmur")]
./scripts/server/dbus/dbusauth.pl:# This is a small example script of how to set up murmur to authenticate through
./scripts/server/dbus/dbusauth.pl:# phpBB3. To use it, you'll have to have started murmur with DBus, and use the
./scripts/server/dbus/dbusauth.pl:# with local murmur users. If you're going to use ONLY external
./scripts/server/dbus/dbusauth.pl:  $service = $bus->get_service("net.sourceforge.mumble.murmur");
./scripts/server/dbus/dbusauth.pl:    $service = $bus->get_service("net.sourceforge.mumble.murmur");
./scripts/server/dbus/dbusauth.pl:die "Murmur service not found" if (! $service);
./scripts/server/dbus/murmur.pl:our $servername = "Mumble & Murmur Test Server";
./scripts/server/dbus/murmur.pl:if (open(F, "$home/murmur/.dbus.sh")) {
./scripts/server/dbus/murmur.pl:  $service = $bus->get_service("net.sourceforge.mumble.murmur");
./scripts/server/dbus/murmur.pl:    $service = $bus->get_service("net.sourceforge.mumble.murmur");
./scripts/server/dbus/murmur.pl:die "Murmur service not found" if (! $service);
./scripts/server/dbus/murmur.pl:  or murmur.pl for a personal one.
./scripts/server/dbus/murmur.pl:    $smtp->datasend("Subject: Murmur registration\n");
./scripts/server/dbus/weblist.pl:if (open(F, "$home/murmur/.dbus.sh")) {
./scripts/server/dbus/weblist.pl:  $service = $bus->get_service("net.sourceforge.mumble.murmur");
./scripts/server/dbus/weblist.pl:    $service = $bus->get_service("net.sourceforge.mumble.murmur");
./scripts/server/dbus/weblist.pl:die "Murmur service not found" if (! $service);
./scripts/server/dbus/weblist.pl:# Call a function on the murmur object
./scripts/server/ice/addban.php:  require 'Murmur.php';
./scripts/server/ice/addban.php:  $meta = $base->ice_checkedCast("::Murmur::Meta");
./scripts/server/ice/addban.php:  $ban = new Murmur_Ban();
./scripts/server/ice/glacier/glacier.php:  $meta = $base->ice_checkedCast("::Murmur::Meta");
./scripts/server/ice/icedemo.php:  $meta = $base->ice_checkedCast("::Murmur::Meta");
./scripts/server/ice/icedemo.php:      $reg[Murmur_UserInfo::UserName] = $_REQUEST['newplayer'];
./scripts/server/ice/icedemo.php:         if ($_REQUEST['password']) $reg[Murmur_UserInfo::UserPassword] = $_REQUEST['password']; // This line is added for password at user creation
./scripts/server/ice/icedemo.php:        $user[Murmur_UserInfo::UserEmail] = $_REQUEST['email'];
./scripts/server/ice/icedemo.php:        $user[Murmur_UserInfo::UserPassword] = $_REQUEST['pw'];
./scripts/server/ice/icedemo.php:        echo "<b>Name:</b> ".$user[Murmur_UserInfo::UserName]."<br />\n";
./scripts/server/ice/icedemo.php:        echo "<b>Email:</b> <input type=\"text\" name=\"email\" size=\"30\" maxlength=\"128\" value=\"".htmlspecialchars($user[Murmur_UserInfo::UserEmail])."\" /><br />\n";
./scripts/server/ice/icedemo.php:      echo "<tr><td>$name $id</td><td>".$u[Murmur_UserInfo::UserEmail]."</td><td>";
./scripts/server/ice/icedemo.php:  echo "<h1>Murmur ICE Interface demo</h1>\n";
./scripts/server/ice/idle.php:# Murmur ID #
./scripts/server/ice/idle.php:$murmur = $base->ice_checkedCast('::Murmur::Meta');
./scripts/server/ice/idle.php:$m = $murmur->getServer($mid);
./scripts/server/ice/simpleregister.php:    $meta = $base->ice_checkedCast("::Murmur::Meta");
./scripts/server/ice/weblist.php:# Murmur.php is generated by calling
./scripts/server/ice/weblist.php:# slice2php /path/to/Murmur.ice
./scripts/server/ice/weblist.php:  if (!stream_resolve_include_path('Murmur.php')) {
./scripts/server/ice/weblist.php:               exit('The required file Murmur.php could not be found in the PHP include path(s).');
./scripts/server/ice/weblist.php:  require 'Murmur.php';
./scripts/server/ice/weblist.php:  $meta = $base->ice_checkedCast("::Murmur::Meta");
./scripts/server/ice/mumble-auth.py:#        * murmur + mumble rev 1530 or higher
./scripts/server/ice/mumble-auth.py:slice = "Murmur.ice"
./scripts/server/ice/mumble-auth.py:import Murmur
./scripts/server/ice/mumble-auth.py:class MetaCallbackI(Murmur.MetaCallback):
./scripts/server/ice/mumble-auth.py:        serverR = Murmur.ServerCallbackPrx.uncheckedCast(adapter.addWithUUID(ServerCallbackI(server, current.adapter)))
./scripts/server/ice/mumble-auth.py:class ServerCallbackI(Murmur.ServerCallback):
./scripts/server/ice/mumble-auth.py:        self.contextR=Murmur.ServerContextCallbackPrx.uncheckedCast(adapter.addWithUUID(ServerContextCallbackI(server)))
./scripts/server/ice/mumble-auth.py:                                       self.contextR, Murmur.ContextUser)
./scripts/server/ice/mumble-auth.py:class ServerContextCallbackI(Murmur.ServerContextCallback):
./scripts/server/ice/mumble-auth.py:                except Murmur.InvalidSessionException:
./scripts/server/ice/mumble-auth.py:    def __init__(self, murmur):
./scripts/server/ice/mumble-auth.py:        self.murmur = murmur
./scripts/server/ice/mumble-auth.py:                server = self.murmur.getServer(ids[id][0])
./scripts/server/ice/mumble-auth.py:                    info = {Murmur.UserInfo.UserName:username,
./scripts/server/ice/mumble-auth.py:                            Murmur.UserInfo.UserPassword:password}
./scripts/server/ice/mumble-auth.py:        meta = Murmur.MetaPrx.checkedCast(ice.stringToProxy(proxy))
./scripts/server/ice/mumble-auth.py:        metaR=Murmur.MetaCallbackPrx.uncheckedCast(adapter.addWithUUID(MetaCallbackI()))
./scripts/server/ice/mumble-auth.py:            serverR=Murmur.ServerCallbackPrx.uncheckedCast(adapter.addWithUUID(ServerCallbackI(server, adapter)))
./scripts/server/ice/rubytest.rb:# Download Murmur.ice from
./scripts/server/ice/rubytest.rb:# http://mumble.git.sourceforge.net/git/gitweb.cgi?p=mumble;a=blob_plain;f=src/murmur/Murmur.ice;hb=HEAD
./scripts/server/ice/rubytest.rb:# and run 'slice2rb Murmur.ice'. slice2rb is part of ICE.
./scripts/server/ice/rubytest.rb:# This will generate the necessary 'Murmur.rb' file which needs to be included:
./scripts/server/ice/rubytest.rb:require 'Murmur.rb'
./scripts/server/ice/rubytest.rb:  meta = Murmur::MetaPrx::checkedCast(base)
./scripts/server/ice/testauth.py:Ice.loadSlice('', ['-I' + Ice.getSliceDir(), 'Murmur.ice'])
./scripts/server/ice/testauth.py:import Murmur
./scripts/server/ice/testauth.py:class ServerAuthenticatorI(Murmur.ServerUpdatingAuthenticator):
./scripts/server/ice/testauth.py:      map[Murmur.UserInfo.UserName]=name
./scripts/server/ice/testauth.py:      print "Someone tried to register " + name[Murmur.UserInfo.UserName]
./scripts/server/ice/testauth.py:    meta = Murmur.MetaPrx.checkedCast(ice.stringToProxy('Meta:tcp -h 127.0.0.1 -p 6502'))
./scripts/server/ice/testauth.py:      serverR=Murmur.ServerUpdatingAuthenticatorPrx.uncheckedCast(adapter.addWithUUID(ServerAuthenticatorI(server, adapter)))
./scripts/server/ice/testauth.py:    map[Murmur.UserInfo.UserName] = 'TestUser';
./scripts/server/ice/testcallback.py:Ice.loadSlice('', ['-I' + Ice.getSliceDir(), 'Murmur.ice'])
./scripts/server/ice/testcallback.py:import Murmur
./scripts/server/ice/testcallback.py:class MetaCallbackI(Murmur.MetaCallback):
./scripts/server/ice/testcallback.py:        serverR=Murmur.ServerCallbackPrx.uncheckedCast(adapter.addWithUUID(ServerCallbackI(server, current.adapter)))
./scripts/server/ice/testcallback.py:class ServerCallbackI(Murmur.ServerCallback):
./scripts/server/ice/testcallback.py:      self.contextR=Murmur.ServerContextCallbackPrx.uncheckedCast(adapter.addWithUUID(ServerContextCallbackI(server)))
./scripts/server/ice/testcallback.py:      self.server.addContextCallback(p.session, "flubber", "Power up the T", self.contextR, Murmur.ContextChannel | Murmur.ContextUser)
./scripts/server/ice/testcallback.py:      if (self.server.hasPermission(p.session, 0, Murmur.PermissionWrite)):
./scripts/server/ice/testcallback.py:class ServerContextCallbackI(Murmur.ServerContextCallback):
./scripts/server/ice/testcallback.py:    meta = Murmur.MetaPrx.checkedCast(ice.stringToProxy('Meta:tcp -h 127.0.0.1 -p 6502'))
./scripts/server/ice/testcallback.py:    metaR=Murmur.MetaCallbackPrx.uncheckedCast(adapter.addWithUUID(MetaCallbackI()))
./scripts/server/ice/testcallback.py:      serverR=Murmur.ServerCallbackPrx.uncheckedCast(adapter.addWithUUID(ServerCallbackI(server, adapter)))
./scripts/server/ice/testdynamic.py:  Ice.loadSlice('', ['-I' + Ice.getSliceDir(), 'Murmur.ice'])
./scripts/server/ice/testdynamic.py:import Murmur
./scripts/server/ice/testdynamic.py:meta = Murmur.MetaPrx.checkedCast(proxy)
./scripts/murmur.service:ExecStart=/usr/bin/murmurd -fg -ini /etc/murmur.ini
./scripts/mumble-server-user-wrapper:DIR=$HOME/murmur
./scripts/mumble-server-user-wrapper:   if pkill -U $UID -u $EUID -o -x -f "/usr/sbin/murmurd -ini $DIR/murmur.ini"; then
./scripts/mumble-server-user-wrapper:           echo "Murmur process not found; not terminated"
./scripts/mumble-server-user-wrapper:if [ ! -f $DIR/murmur.ini ]; then
./scripts/mumble-server-user-wrapper:  echo "Creating $DIR/murmur.ini"
./scripts/mumble-server-user-wrapper:  if [ -f $SYSDIR/murmur.ini ]; then
./scripts/mumble-server-user-wrapper:    cp $SYSDIR/murmur.ini $DIR
./scripts/mumble-server-user-wrapper:  elif [ -f $SYSDIR/murmur.ini.gz ]; then
./scripts/mumble-server-user-wrapper:    gzip -cd $SYSDIR/murmur.ini.gz > $DIR/murmur.ini
./scripts/mumble-server-user-wrapper:    echo "Could not find template for murmur.ini in $SYSDIR."
./scripts/mumble-server-user-wrapper:  echo "$DIR/murmur.ini already exists, initialization failed."
./scripts/mumble-server-user-wrapper:  echo "Initialization done. Please edit $DIR/murmur.ini"
./scripts/mumble-server-user-wrapper:   /usr/sbin/murmurd -ini $DIR/murmur.ini -supw $SETPW
./scripts/mumble-server-user-wrapper:PID=$(pgrep -U $UID -u $EUID -o -x -f "/usr/sbin/murmurd -ini $DIR/murmur.ini")
./scripts/mumble-server-user-wrapper:           echo "Murmur is running"
./scripts/mumble-server-user-wrapper:           echo "Murmur is not running"
./scripts/mumble-server-user-wrapper:  echo "Murmur is already running."
./scripts/mumble-server-user-wrapper:echo "Starting Murmur"
./scripts/mumble-server-user-wrapper:exec /usr/sbin/murmurd -ini $DIR/murmur.ini
./scripts/docker-compose.yml:      - ./murmur.ini:/etc/murmur/murmur.ini
./scripts/docker-compose.yml:      - ./data:/var/lib/murmur/
./scripts/generateIceWrapper.py:    function = "void ::Murmur::" + className + "I::" + functionName + "_async(" + (", ".join(wrapArgs)) + ") {\n"
./scripts/generateIceWrapper.py:        # Try to figure out the path to the ice-file (Murmur.ice)
./scripts/generateIceWrapper.py:        args.ice_file = os.path.join(rootDir, "src", "murmur", "Murmur.ice")
./scripts/generateIceWrapper.py:        args.generated_ice_header = os.path.join(rootDir, "build", "src", "murmur", "Murmur.h")
./scripts/generateIceWrapper.py:    wrapperContent += "void ::Murmur::MetaI::getSlice_async(const ::Murmur::AMD_Meta_getSlicePtr &cb, const Ice::Current&) {\n"
./scripts/mkini-win32.bat::: Copy murmur.ini to murmur.ini.win32, and convert
./scripts/mkini-win32.bat::: LF -> CRLF so Windows users can edit murmur.ini in
./scripts/mkini-win32.bat::: we don't use tabs in murmur.ini -- and even if
./scripts/mkini-win32.bat:type murmur.ini | more /p > murmur.ini.win32
./scripts/mkini.sh:cp murmur.ini murmur.ini.win32
./scripts/mkini.sh:cp murmur.ini murmur.ini.osx
./scripts/mkini.sh:cp murmur.ini murmur.ini.system
./scripts/mkini.sh:perl -pi.bak -e 's/^(#|;|)dbus=.*$/\1dbus=system/' murmur.ini.system
./scripts/mkini.sh:perl -pi.bak -e 's/^(#|;|)logfile=.*$/logfile=\/var\/log\/mumble-server\/mumble-server.log/' murmur.ini.system
./scripts/mkini.sh:perl -pi.bak -e 's/^(#|;|)pidfile=.*$/pidfile=\/var\/run\/mumble-server\/mumble-server.pid/' murmur.ini.system
./scripts/mkini.sh:perl -pi.bak -e 's/^(#|;|)database=.*$/database=\/var\/lib\/mumble-server\/mumble-server.sqlite/' murmur.ini.system
./scripts/mkini.sh:perl -pi.bak -e 's/^(#|;|)uname=.*$/uname=mumble-server/' murmur.ini.system
./scripts/mkini.sh:perl -pi.bak -e 'BEGIN{undef $/;} s/\n/\r\n/smg' murmur.ini.win32
./scripts/murmur.ini:; Murmur configuration file.
./scripts/murmur.ini:; murmur.sqlite in default locations or create it if not found.
./scripts/murmur.ini:; Murmur defaults to using SQLite with its default rollback journal.
./scripts/murmur.ini:;     If Murmur crashes, the database will be in a consistent state, but
./scripts/murmur.ini:;     not write them to disk yet. This option can improve Murmur's
./scripts/murmur.ini:;     If Murmur crashes, the database will be include all completed writes.
./scripts/murmur.ini:;dbPrefix=murmur_
./scripts/murmur.ini:; Murmur defaults to not using D-Bus. If you wish to use dbus, which is one of the
./scripts/murmur.ini:; RPC methods available in Murmur, please specify so here.
./scripts/murmur.ini:; murmurd processes connected to the same D-Bus daemon.
./scripts/murmur.ini:;dbusservice=net.sourceforge.mumble.murmur
./scripts/murmur.ini:; If you want to use ZeroC Ice to communicate with Murmur, you need
./scripts/murmur.ini:; Specifies the file Murmur should log to. By default, Murmur
./scripts/murmur.ini:; logs to the file 'murmur.log'. If you leave this field blank
./scripts/murmur.ini:; on Unix-like systems, Murmur will force itself into foreground
./scripts/murmur.ini:;logfile=murmur.log
./scripts/murmur.ini:; If set, Murmur will write its process ID to this file
./scripts/murmur.ini:welcometext="<br />Welcome to this server running <b>Murmur</b>.<br />Enjoy your stay!<br />"
./scripts/murmur.ini:; If this is left blank (default), Murmur will bind to all available addresses.
./scripts/murmur.ini:; Murmur and Mumble are usually pretty good about cleaning up hung clients, but
./scripts/murmur.ini:; the Murmur Database to get it).
./scripts/murmur.ini:; Murmur retains the per-server log entries in an internal database which
./scripts/murmur.ini:; Otherwise, Murmur will create its own certificate automatically.
./scripts/murmur.ini:; permissions on your murmur.ini file accordingly.
./scripts/murmur.ini:; certificate in order to get Murmur to accept it. You can either concatenate
./scripts/murmur.ini:; to specify a named set of Diffie-Hellman parameters for Murmur to use.
./scripts/murmur.ini:; Murmur comes bundled with the Diffie-Hellman parameters from RFC 7919.
./scripts/murmur.ini:; By default, Murmur uses @ffdhe2048.
./scripts/murmur.ini:; After setting this option, it is recommend that you inspect your Murmur log
./scripts/murmur.ini:; to ensure that Murmur is using the cipher suites that you expected it to.
./scripts/murmur.ini:; Murmur server, and can remove the ability for older Mumble clients to be able
./scripts/murmur.ini:; If Murmur is started as root, which user should it switch to?
./scripts/murmur.ini:; This option is ignored if Murmur isn't started with root privileges.
./scripts/murmur.ini:; behavior. If obfuscate is set to true, Murmur will randomize the IP addresses
./scripts/murmur.ini:; affecting the low-latency of other users, Murmur has a rudimentary global-ban
./scripts/murmur.ini:; virtual servers on the Murmur process. It will not show up in any of the
./scripts/murmur.ini:; Murmur process - just let them expire. A single, properly functioning client
./scripts/murmur.ini:; settings out will cause Murmur to use the defaults:
./scripts/murmur.ini:; with Murmur 1.4.0.
./scripts/murmur.ini:; after the change. Default is false. This option was introduced with Murmur
./scripts/murmur.ini:; Default is true. This option was introduced with Murmur 1.5.0.
./scripts/murmur.init:# Description:          Init script for the Mumble VoIP Server murmurd.
./scripts/murmur.init:DAEMON=/usr/sbin/murmurd
./scripts/murmur.init:MURMUR_DAEMON_START=0
./scripts/murmur.init:MURMUR_USE_CAPABILITIES=0
./scripts/murmur.init:MURMUR_LIMIT_NOFILE=0
./scripts/murmur.init:# Include murmur defaults if available
./scripts/murmur.init:if [ "$MURMUR_LIMIT_NOFILE" -gt 0 ] ; then
./scripts/murmur.init:  ulimit -n $MURMUR_LIMIT_NOFILE
./scripts/murmur.init:          if [ "$MURMUR_DAEMON_START" != "1" ] ; then
./scripts/murmur.init:  if [ "$MURMUR_USE_CAPABILITIES" != "1" ] ; then
./scripts/murmur.init:                  if [ "$MURMUR_USE_CAPABILITIES" != "1" ] ; then
./src/mumble/UserListModel.h:   /// True if the message given on construction lacked column data (true for murmur <= 1.2.4)
./src/mumble/mumble_eo.ts:        <translation>&lt;b&gt;Pasvorto&lt;/b&gt;&lt;br /&gt;Ĉi tiu kampo vin permesas agordi kaj ŝanĝi facile la pasvorton de iu kanalo. Ĝi uzas la atingoĵetona trajto de Murmur fone. Se vi necesas pli detala kaj pli potenca atingokontrolo, uzi ACL-ojn kaj grupojn.</translation>
./src/mumble/mumble_fr.ts:        <translation>Crier / Murmurer à&#xa0;:</translation>
./src/murmur/murmur.qrc: <file alias="murmur.16x16.png">../../icons/murmur.16x16.png</file>
./src/murmur/murmur.qrc: <file alias="murmur.32x32.png">../../icons/murmur.32x32.png</file>
./src/murmur/murmur.qrc: <file alias="murmur.48x48.png">../../icons/murmur.48x48.png</file>
./src/murmur/murmur.qrc: <file alias="murmur.64x64.png">../../icons/murmur.64x64.png</file>
./src/murmur/murmur.plist.in:   <string>murmurd</string>
./src/murmur/murmur.rc.in:IDI_ICON1 ICON DISCARDABLE "@MURMUR_ICON@"
./src/murmur/murmur.rc.in:                              VALUE "FileDescription", "Murmur - Low-latency VoIP server"
./src/murmur/murmur.rc.in:                              VALUE "OriginalFilename", "murmur.exe"
./src/murmur/About.cpp: setWindowTitle(tr("About Murmur"));
./src/murmur/About.cpp: text->setText(tr("<h3>Murmur (%1)</h3>"
./src/murmur/About.cpp: qtwTab->addTab(about, tr("&About Murmur"));
./src/murmur/About.h:#ifndef MUMBLE_MURMUR_ABOUT_H_
./src/murmur/About.h:#define MUMBLE_MURMUR_ABOUT_H_
./src/murmur/AudioReceiverBuffer.h:#ifndef MUMBLE_MURMUR_AUDIORECEIVERBUFFER_H_
./src/murmur/AudioReceiverBuffer.h:#define MUMBLE_MURMUR_AUDIORECEIVERBUFFER_H_
./src/murmur/AudioReceiverBuffer.h:#endif // MUMBLE_MURMUR_AUDIORECEIVERBUFFER_H_
./src/murmur/CMakeLists.txt:set(MURMUR_RC "${CMAKE_CURRENT_BINARY_DIR}/murmur.rc")
./src/murmur/CMakeLists.txt:set(MURMUR_ICON "${CMAKE_SOURCE_DIR}/icons/murmur.ico")
./src/murmur/CMakeLists.txt:set(MURMUR_PLIST "${CMAKE_CURRENT_BINARY_DIR}/murmur.plist")
./src/murmur/CMakeLists.txt:configure_file("${CMAKE_CURRENT_SOURCE_DIR}/murmur.plist.in" "${MURMUR_PLIST}")
./src/murmur/CMakeLists.txt:configure_file("${CMAKE_CURRENT_SOURCE_DIR}/murmur.rc.in" "${MURMUR_RC}")
./src/murmur/CMakeLists.txt:set(ICE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Murmur.ice")
./src/murmur/CMakeLists.txt:set(MURMUR_SOURCES
./src/murmur/CMakeLists.txt:    add_executable(mumble-server WIN32 ${MURMUR_SOURCES})
./src/murmur/CMakeLists.txt:    add_executable(mumble-server ${MURMUR_SOURCES})
./src/murmur/CMakeLists.txt:set(AUTOGEN_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/murmur_autogen")
./src/murmur/CMakeLists.txt:            "MURMUR"
./src/murmur/CMakeLists.txt:                    "murmur.qrc"
./src/murmur/CMakeLists.txt:                    "${MURMUR_RC}"
./src/murmur/CMakeLists.txt:                    "UnixMurmur.cpp"
./src/murmur/CMakeLists.txt:                    "UnixMurmur.h"
./src/murmur/CMakeLists.txt:                    "MurmurIce.cpp"
./src/murmur/CMakeLists.txt:                    "MurmurIce.h"
./src/murmur/CMakeLists.txt:    file(COPY "Murmur.ice" DESTINATION ${CMAKE_BINARY_DIR})
./src/murmur/CMakeLists.txt:file(COPY "${CMAKE_SOURCE_DIR}/scripts/murmur.ini" DESTINATION ${CMAKE_BINARY_DIR})
./src/murmur/CMakeLists.txt:    # Install Murmur man files
./src/murmur/Cert.cpp:          log("Diffie-Hellman parameters (sslDHParams) were specified, but will not be used. This version of Murmur does "
./src/murmur/Cert.cpp:  if (issuer == QString::fromUtf8("Murmur Autogenerated Certificate")) {
./src/murmur/Cert.cpp:  // This allows a self-signed certificate generated by Murmur to be
./src/murmur/Cert.cpp:  if (!qscCert.isNull() && issuer.startsWith(QString::fromUtf8("Murmur Autogenerated Certificate"))
./src/murmur/Cert.cpp:                  if (!SelfSignedCertificate::generateMurmurV2Certificate(qscCert, qskKey)) {
./src/murmur/DBus.cpp:void MurmurDBus::registerTypes() {
./src/murmur/DBus.cpp:QDBusConnection *MurmurDBus::qdbc = nullptr;
./src/murmur/DBus.cpp:MurmurDBus::MurmurDBus(Server *srv) : QDBusAbstractAdaptor(srv) {
./src/murmur/DBus.cpp:void MurmurDBus::removeAuthenticator() {
./src/murmur/DBus.cpp:void MurmurDBus::idToNameSlot(QString &name, int id) {
./src/murmur/DBus.cpp:void MurmurDBus::idToTextureSlot(QByteArray &qba, int id) {
./src/murmur/DBus.cpp:void MurmurDBus::nameToIdSlot(int &id, const QString &name) {
./src/murmur/DBus.cpp:void MurmurDBus::registerUserSlot(int &res, const QMap< int, QString > &info) {
./src/murmur/DBus.cpp:void MurmurDBus::unregisterUserSlot(int &res, int id) {
./src/murmur/DBus.cpp:void MurmurDBus::getRegistrationSlot(int &res, int id, QMap< int, QString > &info) {
./src/murmur/DBus.cpp:void MurmurDBus::getRegisteredUsersSlot(const QString &filter, QMap< int, QString > &m) {
./src/murmur/DBus.cpp:void MurmurDBus::setInfoSlot(int &res, int id, const QMap< int, QString > &info) {
./src/murmur/DBus.cpp:void MurmurDBus::setTextureSlot(int &res, int id, const QByteArray &texture) {
./src/murmur/DBus.cpp:void MurmurDBus::authenticateSlot(int &res, QString &uname, int sessionId, const QList< QSslCertificate > &,
./src/murmur/DBus.cpp:void MurmurDBus::getPlayers(QList< PlayerInfoExtended > &a) {
./src/murmur/DBus.cpp:void MurmurDBus::getChannels(QList< ChannelInfo > &a) {
./src/murmur/DBus.cpp:void MurmurDBus::kickPlayer(unsigned int session, const QString &reason, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::getPlayerState(unsigned int session, const QDBusMessage &msg, PlayerInfo &pi) {
./src/murmur/DBus.cpp:void MurmurDBus::setPlayerState(const PlayerInfo &npi, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::sendMessage(unsigned int session, const QString &text, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::sendMessageChannel(int id, bool tree, const QString &text, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::addChannel(const QString &name, int chanparent, const QDBusMessage &msg, int &newid) {
./src/murmur/DBus.cpp:void MurmurDBus::removeChannel(int id, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::getChannelState(int id, const QDBusMessage &msg, ChannelInfo &state) {
./src/murmur/DBus.cpp:void MurmurDBus::setChannelState(const ChannelInfo &nci, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::getACL(int id, const QDBusMessage &msg, QList< ACLInfo > &acls, QList< GroupInfo > &groups,
./src/murmur/DBus.cpp:void MurmurDBus::setACL(int id, const QList< ACLInfo > &acls, const QList< GroupInfo > &groups, bool inherit,
./src/murmur/DBus.cpp:void MurmurDBus::getBans(QList< BanInfo > &bi) {
./src/murmur/DBus.cpp:void MurmurDBus::setBans(const QList< BanInfo > &, const QDBusMessage &) {
./src/murmur/DBus.cpp:void MurmurDBus::getPlayerNames(const QList< int > &ids, const QDBusMessage &, QStringList &names) {
./src/murmur/DBus.cpp:void MurmurDBus::getPlayerIds(const QStringList &names, const QDBusMessage &, QList< int > &ids) {
./src/murmur/DBus.cpp:void MurmurDBus::registerPlayer(const QString &name, const QDBusMessage &msg, int &id) {
./src/murmur/DBus.cpp:void MurmurDBus::unregisterPlayer(int id, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::getRegistration(int id, const QDBusMessage &msg, RegisteredPlayer &user) {
./src/murmur/DBus.cpp:void MurmurDBus::setRegistration(int id, const QString &name, const QString &email, const QString &pw,
./src/murmur/DBus.cpp:void MurmurDBus::updateRegistration(const RegisteredPlayer &user, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::getTexture(int id, const QDBusMessage &msg, QByteArray &texture) {
./src/murmur/DBus.cpp:void MurmurDBus::setTexture(int id, const QByteArray &texture, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::getRegisteredPlayers(const QString &filter, QList< RegisteredPlayer > &users) {
./src/murmur/DBus.cpp:void MurmurDBus::verifyPassword(int id, const QString &pw, const QDBusMessage &msg, bool &ok) {
./src/murmur/DBus.cpp:void MurmurDBus::setAuthenticator(const QDBusObjectPath &path, bool reentrant, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::setTemporaryGroups(int channel, int userid, const QStringList &groups, const QDBusMessage &msg) {
./src/murmur/DBus.cpp:void MurmurDBus::userStateChanged(const User *p) {
./src/murmur/DBus.cpp:void MurmurDBus::userTextMessage(const User *, const TextMessage &) {
./src/murmur/DBus.cpp:void MurmurDBus::userConnected(const User *p) {
./src/murmur/DBus.cpp:void MurmurDBus::userDisconnected(const User *p) {
./src/murmur/DBus.cpp:void MurmurDBus::channelStateChanged(const Channel *c) {
./src/murmur/DBus.cpp:void MurmurDBus::channelCreated(const Channel *c) {
./src/murmur/DBus.cpp:void MurmurDBus::channelRemoved(const Channel *c) {
./src/murmur/DBus.cpp:  new MurmurDBus(s);
./src/murmur/DBus.cpp:  if (MurmurDBus::qdbc->isConnected())
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->registerObject(QString::fromLatin1("/%1").arg(s->iServerNum), s);
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.booted", "Server already booted"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.bootfail", "Booting server failed"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.booted", "Server not booted"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.booted", "Server is running"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.cpp:                  MurmurDBus::qdbc->send(
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.cpp:          MurmurDBus::qdbc->send(msg.createErrorReply("net.sourceforge.mumble.Error.server", "Invalid server id"));
./src/murmur/DBus.h:#   ifndef MUMBLE_MURMUR_DBUS_H_
./src/murmur/DBus.h:#           define MUMBLE_MURMUR_DBUS_H_
./src/murmur/DBus.h:class MurmurDBus : public QDBusAbstractAdaptor {
./src/murmur/DBus.h:    Q_CLASSINFO("D-Bus Interface", "net.sourceforge.mumble.Murmur")
./src/murmur/DBus.h:    Q_DISABLE_COPY(MurmurDBus)
./src/murmur/DBus.h:    MurmurDBus(Server *srv);
./src/murmur/Meta.cpp:  qsDBusService              = "net.sourceforge.mumble.murmur";
./src/murmur/Meta.cpp:  qsLogfile                  = "murmur.log";
./src/murmur/Meta.cpp:          datapaths << QDir::homePath() + QLatin1String("/.murmurd");
./src/murmur/Meta.cpp:                          QFileInfo fi(p, "murmur.ini");
./src/murmur/Meta.cpp:                  qsAbsSettingsFilePath = qdBasePath.absolutePath() + QLatin1String("/murmur.ini");
./src/murmur/Meta.cpp:          qFatal("MetaParams: This version of Murmur does not support Diffie-Hellman parameters (sslDHParams). Murmur "
./src/murmur/Meta.cpp:                     "will not start unless you remove the option from your murmur.ini file.");
./src/murmur/Meta.h:#ifndef MUMBLE_MURMUR_META_H_
./src/murmur/Meta.h:#define MUMBLE_MURMUR_META_H_
./src/murmur/Meta.h:    /// from PEM bundle pointed to by murmur.ini's
./src/murmur/Meta.h:    /// pointed to by murmur.ini's sslKey option.
./src/murmur/Meta.h:    /// the PEM bundle pointed to by murmur.ini's
./src/murmur/Meta.h:    /// the murmur.ini used by this Meta instance.
./src/murmur/Meta.h:    void read(QString fname = QString("murmur.ini"));
./src/murmur/Meta.h:    /// Attempt to load SSL settings from murmur.ini.
./src/murmur/Meta.h:    /// reloadSSLSettings reloads Murmur's MetaParams's
./src/murmur/Murmur.ice: * Information and control of the murmur server. Each server has
./src/murmur/Murmur.ice:module Murmur
./src/murmur/Murmur.ice:        exception MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidSessionException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidChannelException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidServerException extends MurmurException {};
./src/murmur/Murmur.ice:        exception ServerBootedException extends MurmurException {};
./src/murmur/Murmur.ice:        exception ServerFailureException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidUserException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidTextureException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidCallbackException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidSecretException extends MurmurException {};
./src/murmur/Murmur.ice:        exception NestingLimitException extends MurmurException {};
./src/murmur/Murmur.ice:        exception WriteOnlyException extends MurmurException {};
./src/murmur/Murmur.ice:        exception InvalidInputDataException extends MurmurException {};
./src/murmur/Murmur.ice:         *  Please note that all callbacks are done asynchronously; murmur does not wait for the callback to
./src/murmur/Murmur.ice:         *  Please note that all callbacks are done asynchronously; murmur does not wait for the callback to
./src/murmur/Murmur.ice:         *  synchronously. If the response lags, the entire murmur server will lag.
./src/murmur/Murmur.ice:                 *  Note that if authentication succeeds, murmur will create a record of the user in it's database, reserving
./src/murmur/Murmur.ice:                 *  Internally, Murmur treats usernames as case-insensitive. It is recommended
./src/murmur/Murmur.ice:                 *  that authenticators do the same. Murmur checks if a username is in use when
./src/murmur/Murmur.ice:                 *  @param certhash Hash of user certificate, as used by murmur internally when matching.
./src/murmur/Murmur.ice:                 *  want murmur to take care of this information itself, simply return false to fall through.
./src/murmur/Murmur.ice:         *  Almost all of these methods support fall through, meaning murmur should continue the operation against its
./src/murmur/Murmur.ice:                 * Note: Server will be restarted on Murmur restart unless explicitly disabled
./src/murmur/Murmur.ice:         *  Please note that all callbacks are done asynchronously; murmur does not wait for the callback to
./src/murmur/Murmur.ice:                /** Fetch version of Murmur. 
./src/murmur/Murmur.ice:                /** Get murmur uptime.
./src/murmur/Murmur.ice:                 * @return Uptime of murmur in seconds
./src/murmur/MurmurI.h:#ifndef MUMBLE_MURMUR_MURMURI_H_
./src/murmur/MurmurI.h:#define MUMBLE_MURMUR_MURMURI_H_
./src/murmur/MurmurI.h:#include <Murmur.h>
./src/murmur/MurmurI.h:namespace Murmur {
./src/murmur/MurmurI.h: virtual void isRunning_async(const ::Murmur::AMD_Server_isRunningPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void start_async(const ::Murmur::AMD_Server_startPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void stop_async(const ::Murmur::AMD_Server_stopPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void delete_async(const ::Murmur::AMD_Server_deletePtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void addCallback_async(const ::Murmur::AMD_Server_addCallbackPtr &, const ::Murmur::ServerCallbackPrx &,
./src/murmur/MurmurI.h: virtual void removeCallback_async(const ::Murmur::AMD_Server_removeCallbackPtr &,
./src/murmur/MurmurI.h:                                                                   const ::Murmur::ServerCallbackPrx &, const ::Ice::Current &);
./src/murmur/MurmurI.h: virtual void setAuthenticator_async(const ::Murmur::AMD_Server_setAuthenticatorPtr &,
./src/murmur/MurmurI.h:                                                                         const ::Murmur::ServerAuthenticatorPrx &, const ::Ice::Current &);
./src/murmur/MurmurI.h: virtual void id_async(const ::Murmur::AMD_Server_idPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getConf_async(const ::Murmur::AMD_Server_getConfPtr &, const ::std::string &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getAllConf_async(const ::Murmur::AMD_Server_getAllConfPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void setConf_async(const ::Murmur::AMD_Server_setConfPtr &, const ::std::string &, const ::std::string &,
./src/murmur/MurmurI.h: virtual void setSuperuserPassword_async(const ::Murmur::AMD_Server_setSuperuserPasswordPtr &, const ::std::string &,
./src/murmur/MurmurI.h: virtual void getLog_async(const ::Murmur::AMD_Server_getLogPtr &, ::Ice::Int, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getLogLen_async(const ::Murmur::AMD_Server_getLogLenPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getUsers_async(const ::Murmur::AMD_Server_getUsersPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getChannels_async(const ::Murmur::AMD_Server_getChannelsPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getTree_async(const ::Murmur::AMD_Server_getTreePtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getCertificateList_async(const ::Murmur::AMD_Server_getCertificateListPtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void getBans_async(const ::Murmur::AMD_Server_getBansPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void setBans_async(const ::Murmur::AMD_Server_setBansPtr &, const ::Murmur::BanList &,
./src/murmur/MurmurI.h: virtual void kickUser_async(const ::Murmur::AMD_Server_kickUserPtr &, ::Ice::Int, const ::std::string &,
./src/murmur/MurmurI.h: virtual void sendMessage_async(const ::Murmur::AMD_Server_sendMessagePtr &, ::Ice::Int, const ::std::string &,
./src/murmur/MurmurI.h: virtual void hasPermission_async(const ::Murmur::AMD_Server_hasPermissionPtr &, ::Ice::Int, ::Ice::Int, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void effectivePermissions_async(const ::Murmur::AMD_Server_effectivePermissionsPtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void addContextCallback_async(const ::Murmur::AMD_Server_addContextCallbackPtr &, ::Ice::Int,
./src/murmur/MurmurI.h:                                                                           const ::Murmur::ServerContextCallbackPrx &, int, const ::Ice::Current &);
./src/murmur/MurmurI.h: virtual void removeContextCallback_async(const ::Murmur::AMD_Server_removeContextCallbackPtr &,
./src/murmur/MurmurI.h:                                                                                  const ::Murmur::ServerContextCallbackPrx &, const ::Ice::Current &);
./src/murmur/MurmurI.h: virtual void getState_async(const ::Murmur::AMD_Server_getStatePtr &, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void setState_async(const ::Murmur::AMD_Server_setStatePtr &, const ::Murmur::User &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getChannelState_async(const ::Murmur::AMD_Server_getChannelStatePtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void setChannelState_async(const ::Murmur::AMD_Server_setChannelStatePtr &, const ::Murmur::Channel &,
./src/murmur/MurmurI.h: virtual void removeChannel_async(const ::Murmur::AMD_Server_removeChannelPtr &, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void addChannel_async(const ::Murmur::AMD_Server_addChannelPtr &, const ::std::string &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void sendMessageChannel_async(const ::Murmur::AMD_Server_sendMessageChannelPtr &, ::Ice::Int, bool,
./src/murmur/MurmurI.h: virtual void getACL_async(const ::Murmur::AMD_Server_getACLPtr &, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void setACL_async(const ::Murmur::AMD_Server_setACLPtr &, ::Ice::Int, const ::Murmur::ACLList &,
./src/murmur/MurmurI.h:                                                   const ::Murmur::GroupList &, bool, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void removeUserFromGroup_async(const ::Murmur::AMD_Server_removeUserFromGroupPtr &, ::Ice::Int, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void addUserToGroup_async(const ::Murmur::AMD_Server_addUserToGroupPtr &, ::Ice::Int, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void redirectWhisperGroup_async(const ::Murmur::AMD_Server_redirectWhisperGroupPtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void getUserNames_async(const ::Murmur::AMD_Server_getUserNamesPtr &, const ::Murmur::IdList &,
./src/murmur/MurmurI.h: virtual void getUserIds_async(const ::Murmur::AMD_Server_getUserIdsPtr &, const ::Murmur::NameList &,
./src/murmur/MurmurI.h: virtual void registerUser_async(const ::Murmur::AMD_Server_registerUserPtr &, const Murmur::UserInfoMap &,
./src/murmur/MurmurI.h: virtual void unregisterUser_async(const ::Murmur::AMD_Server_unregisterUserPtr &, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void updateRegistration_async(const ::Murmur::AMD_Server_updateRegistrationPtr &, Ice::Int,
./src/murmur/MurmurI.h:                                                                           const Murmur::UserInfoMap &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getRegistration_async(const ::Murmur::AMD_Server_getRegistrationPtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void getRegisteredUsers_async(const ::Murmur::AMD_Server_getRegisteredUsersPtr &, const ::std::string &,
./src/murmur/MurmurI.h: virtual void verifyPassword_async(const ::Murmur::AMD_Server_verifyPasswordPtr &, const ::std::string &,
./src/murmur/MurmurI.h: virtual void getTexture_async(const ::Murmur::AMD_Server_getTexturePtr &, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void setTexture_async(const ::Murmur::AMD_Server_setTexturePtr &, ::Ice::Int, const ::Murmur::Texture &,
./src/murmur/MurmurI.h: virtual void getUptime_async(const ::Murmur::AMD_Server_getUptimePtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void updateCertificate_async(const ::Murmur::AMD_Server_updateCertificatePtr &, const std::string &,
./src/murmur/MurmurI.h: virtual void startListening_async(const ::Murmur::AMD_Server_startListeningPtr &, ::Ice::Int, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void stopListening_async(const ::Murmur::AMD_Server_stopListeningPtr &, ::Ice::Int, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void isListening_async(const ::Murmur::AMD_Server_isListeningPtr &, ::Ice::Int, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void getListeningChannels_async(const ::Murmur::AMD_Server_getListeningChannelsPtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void getListeningUsers_async(const ::Murmur::AMD_Server_getListeningUsersPtr &, ::Ice::Int,
./src/murmur/MurmurI.h: virtual void sendWelcomeMessage_async(const ::Murmur::AMD_Server_sendWelcomeMessagePtr &,
./src/murmur/MurmurI.h:                                                                           const ::Murmur::IdList &p1, const ::Ice::Current &current);
./src/murmur/MurmurI.h: virtual void getSliceChecksums_async(const ::Murmur::AMD_Meta_getSliceChecksumsPtr &, const ::Ice::Current &);
./src/murmur/MurmurI.h: virtual void getServer_async(const ::Murmur::AMD_Meta_getServerPtr &, ::Ice::Int, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void newServer_async(const ::Murmur::AMD_Meta_newServerPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getBootedServers_async(const ::Murmur::AMD_Meta_getBootedServersPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getAllServers_async(const ::Murmur::AMD_Meta_getAllServersPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getDefaultConf_async(const ::Murmur::AMD_Meta_getDefaultConfPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getVersion_async(const ::Murmur::AMD_Meta_getVersionPtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void addCallback_async(const ::Murmur::AMD_Meta_addCallbackPtr &, const ::Murmur::MetaCallbackPrx &,
./src/murmur/MurmurI.h: virtual void removeCallback_async(const ::Murmur::AMD_Meta_removeCallbackPtr &, const ::Murmur::MetaCallbackPrx &,
./src/murmur/MurmurI.h: virtual void getUptime_async(const ::Murmur::AMD_Meta_getUptimePtr &, const Ice::Current &);
./src/murmur/MurmurI.h: virtual void getSlice_async(const ::Murmur::AMD_Meta_getSlicePtr &, const Ice::Current &);
./src/murmur/MurmurI.h:} // namespace Murmur
./src/murmur/MurmurIce.cpp:#include "MurmurIce.h"
./src/murmur/MurmurIce.cpp:#include "MurmurI.h"
./src/murmur/MurmurIce.cpp:using namespace Murmur;
./src/murmur/MurmurIce.cpp:static MurmurIce *mi = nullptr;
./src/murmur/MurmurIce.cpp:     mi = new MurmurIce();
./src/murmur/MurmurIce.cpp:static void logToLog(const ServerDB::LogRecord &r, Murmur::LogEntry &le) {
./src/murmur/MurmurIce.cpp:static void userToUser(const ::User *p, Murmur::User &mp) {
./src/murmur/MurmurIce.cpp:     ::Murmur::NetAddress addr(16, 0);
./src/murmur/MurmurIce.cpp:static void channelToChannel(const ::Channel *c, Murmur::Channel &mc) {
./src/murmur/MurmurIce.cpp:static void ACLtoACL(const ::ChanACL *acl, Murmur::ACL &ma) {
./src/murmur/MurmurIce.cpp:static void groupToGroup(const ::Group *g, Murmur::Group &mg) {
./src/murmur/MurmurIce.cpp:static void banToBan(const ::Ban &b, Murmur::Ban &mb) {
./src/murmur/MurmurIce.cpp:     ::Murmur::NetAddress addr(16, 0);
./src/murmur/MurmurIce.cpp:static void banToBan(const ::Murmur::Ban &mb, ::Ban &b) {
./src/murmur/MurmurIce.cpp:static void infoToInfo(const QMap< int, QString > &info, Murmur::UserInfoMap &im) {
./src/murmur/MurmurIce.cpp:             im[static_cast< Murmur::UserInfo >(i.key())] = iceString(i.value());
./src/murmur/MurmurIce.cpp:static void infoToInfo(const Murmur::UserInfoMap &im, QMap< int, QString > &info) {
./src/murmur/MurmurIce.cpp:     Murmur::UserInfoMap::const_iterator i;
./src/murmur/MurmurIce.cpp:static void textmessageToTextmessage(const ::TextMessage &tm, Murmur::TextMessage &tmdst) {
./src/murmur/MurmurIce.cpp:MurmurIce::MurmurIce() {
./src/murmur/MurmurIce.cpp:             adapter   = communicator->createObjectAdapterWithEndpoints("Murmur", qPrintable(meta->mp.qsIceEndpoint));
./src/murmur/MurmurIce.cpp:                     qWarning("MurmurIce: Endpoint \"%s\" running", qPrintable(u8(ep->toString())));
./src/murmur/MurmurIce.cpp:             qCritical("MurmurIce: Initialization failed: %s", qPrintable(u8(e.ice_id())));
./src/murmur/MurmurIce.cpp:             qCritical("MurmurIce: Initialization failed: %s", qPrintable(u8(e.ice_name())));
./src/murmur/MurmurIce.cpp:MurmurIce::~MurmurIce() {
./src/murmur/MurmurIce.cpp:             qWarning("MurmurIce: Shutdown complete");
./src/murmur/MurmurIce.cpp:void MurmurIce::customEvent(QEvent *evt) {
./src/murmur/MurmurIce.cpp:void MurmurIce::badMetaProxy(const ::Murmur::MetaCallbackPrx &prx) {
./src/murmur/MurmurIce.cpp:void MurmurIce::badServerProxy(const ::Murmur::ServerCallbackPrx &prx, const ::Server *server) {
./src/murmur/MurmurIce.cpp:void MurmurIce::badAuthenticator(::Server *server) {
./src/murmur/MurmurIce.cpp:     const ::Murmur::ServerAuthenticatorPrx &prx = qmServerAuthenticator.value(server->iServerNum);
./src/murmur/MurmurIce.cpp:void MurmurIce::addMetaCallback(const ::Murmur::MetaCallbackPrx &prx) {
./src/murmur/MurmurIce.cpp:void MurmurIce::removeMetaCallback(const ::Murmur::MetaCallbackPrx &prx) {
./src/murmur/MurmurIce.cpp:void MurmurIce::addServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx) {
./src/murmur/MurmurIce.cpp:     QList<::Murmur::ServerCallbackPrx > &cbList = qmServerCallbacks[server->iServerNum];
./src/murmur/MurmurIce.cpp:void MurmurIce::removeServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx) {
./src/murmur/MurmurIce.cpp:void MurmurIce::removeServerCallbacks(const ::Server *server) {
./src/murmur/MurmurIce.cpp:void MurmurIce::addServerContextCallback(const ::Server *server, int session_id, const QString &action,
./src/murmur/MurmurIce.cpp:                                                                              const ::Murmur::ServerContextCallbackPrx &prx) {
./src/murmur/MurmurIce.cpp:     QMap< QString, ::Murmur::ServerContextCallbackPrx > &callbacks =
./src/murmur/MurmurIce.cpp:const QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > >
./src/murmur/MurmurIce.cpp:     MurmurIce::getServerContextCallbacks(const ::Server *server) const {
./src/murmur/MurmurIce.cpp:void MurmurIce::removeServerContextCallback(const ::Server *server, int session_id, const QString &action) {
./src/murmur/MurmurIce.cpp:void MurmurIce::setServerAuthenticator(const ::Server *server, const ::Murmur::ServerAuthenticatorPrx &prx) {
./src/murmur/MurmurIce.cpp:const ::Murmur::ServerAuthenticatorPrx MurmurIce::getServerAuthenticator(const ::Server *server) const {
./src/murmur/MurmurIce.cpp:void MurmurIce::removeServerAuthenticator(const ::Server *server) {
./src/murmur/MurmurIce.cpp:void MurmurIce::setServerUpdatingAuthenticator(const ::Server *server,
./src/murmur/MurmurIce.cpp:                                                                                        const ::Murmur::ServerUpdatingAuthenticatorPrx &prx) {
./src/murmur/MurmurIce.cpp:const ::Murmur::ServerUpdatingAuthenticatorPrx MurmurIce::getServerUpdatingAuthenticator(const ::Server *server) const {
./src/murmur/MurmurIce.cpp:void MurmurIce::removeServerUpdatingAuthenticator(const ::Server *server) {
./src/murmur/MurmurIce.cpp:void MurmurIce::started(::Server *s) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::MetaCallbackPrx > &qlList = qlMetaCallbacks;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::MetaCallbackPrx &prx, qlList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::stopped(::Server *s) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::MetaCallbackPrx > &qmList = qlMetaCallbacks;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::MetaCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::userConnected(const ::User *p) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::userDisconnected(const ::User *p) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::userStateChanged(const ::User *p) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::userTextMessage(const ::User *p, const ::TextMessage &message) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:     ::Murmur::TextMessage textMessage;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::channelCreated(const ::Channel *c) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::Channel mc;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::channelRemoved(const ::Channel *c) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::Channel mc;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::channelStateChanged(const ::Channel *c) {
./src/murmur/MurmurIce.cpp:     const QList<::Murmur::ServerCallbackPrx > &qmList = qmServerCallbacks[s->iServerNum];
./src/murmur/MurmurIce.cpp:     ::Murmur::Channel mc;
./src/murmur/MurmurIce.cpp:     foreach (const ::Murmur::ServerCallbackPrx &prx, qmList) {
./src/murmur/MurmurIce.cpp:void MurmurIce::contextAction(const ::User *pSrc, const QString &action, unsigned int session, int iChannel) {
./src/murmur/MurmurIce.cpp:     QMap< int, QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > > &qmAll = qmServerContextCallbacks;
./src/murmur/MurmurIce.cpp:     QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > &qmServer = qmAll[s->iServerNum];
./src/murmur/MurmurIce.cpp:     QMap< QString, ::Murmur::ServerContextCallbackPrx > &qmUser = qmServer[pSrc->uiSession];
./src/murmur/MurmurIce.cpp:     const ::Murmur::ServerContextCallbackPrx &prx = qmUser[action];
./src/murmur/MurmurIce.cpp:     ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:void MurmurIce::idToNameSlot(QString &name, int id) {
./src/murmur/MurmurIce.cpp:void MurmurIce::idToTextureSlot(QByteArray &qba, int id) {
./src/murmur/MurmurIce.cpp:             const ::Murmur::Texture &tex = prx->idToTexture(id);
./src/murmur/MurmurIce.cpp:void MurmurIce::nameToIdSlot(int &id, const QString &name) {
./src/murmur/MurmurIce.cpp:void MurmurIce::authenticateSlot(int &res, QString &uname, int sessionId, const QList< QSslCertificate > &certlist,
./src/murmur/MurmurIce.cpp:     ::Murmur::GroupNameList groups;
./src/murmur/MurmurIce.cpp:     ::Murmur::CertificateList certs;
./src/murmur/MurmurIce.cpp:             ::Murmur::CertificateDer der;
./src/murmur/MurmurIce.cpp:void MurmurIce::registerUserSlot(int &res, const QMap< int, QString > &info) {
./src/murmur/MurmurIce.cpp:     ::Murmur::UserInfoMap im;
./src/murmur/MurmurIce.cpp:void MurmurIce::unregisterUserSlot(int &res, int id) {
./src/murmur/MurmurIce.cpp:void MurmurIce::getRegistrationSlot(int &res, int id, QMap< int, QString > &info) {
./src/murmur/MurmurIce.cpp:     Murmur::UserInfoMap im;
./src/murmur/MurmurIce.cpp:void MurmurIce::getRegisteredUsersSlot(const QString &filter, QMap< int, QString > &m) {
./src/murmur/MurmurIce.cpp:     ::Murmur::NameMap lst;
./src/murmur/MurmurIce.cpp:     ::Murmur::NameMap::const_iterator i;
./src/murmur/MurmurIce.cpp:void MurmurIce::setInfoSlot(int &res, int id, const QMap< int, QString > &info) {
./src/murmur/MurmurIce.cpp:     Murmur::UserInfoMap im;
./src/murmur/MurmurIce.cpp:void MurmurIce::setTextureSlot(int &res, int id, const QByteArray &texture) {
./src/murmur/MurmurIce.cpp:     ::Murmur::Texture tex;
./src/murmur/MurmurIce.cpp:             cb->ice_exception(::Murmur::InvalidSessionException()); \
./src/murmur/MurmurIce.cpp:             cb->ice_exception(::Murmur::InvalidChannelException()); \
./src/murmur/MurmurIce.cpp:static void impl_Server_isRunning(const ::Murmur::AMD_Server_isRunningPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_start(const ::Murmur::AMD_Server_startPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_stop(const ::Murmur::AMD_Server_stopPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_delete(const ::Murmur::AMD_Server_deletePtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_addCallback(const Murmur::AMD_Server_addCallbackPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                     const Murmur::ServerCallbackPrx &cbptr) {
./src/murmur/MurmurIce.cpp:             const Murmur::ServerCallbackPrx &oneway =
./src/murmur/MurmurIce.cpp:                     Murmur::ServerCallbackPrx::checkedCast(cbptr->ice_oneway()->ice_connectionCached(false));
./src/murmur/MurmurIce.cpp:static void impl_Server_removeCallback(const Murmur::AMD_Server_removeCallbackPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                        const Murmur::ServerCallbackPrx &cbptr) {
./src/murmur/MurmurIce.cpp:             const Murmur::ServerCallbackPrx &oneway =
./src/murmur/MurmurIce.cpp:                     Murmur::ServerCallbackPrx::uncheckedCast(cbptr->ice_oneway()->ice_connectionCached(false));
./src/murmur/MurmurIce.cpp:static void impl_Server_setAuthenticator(const ::Murmur::AMD_Server_setAuthenticatorPtr &cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                              const ::Murmur::ServerAuthenticatorPrx &aptr) {
./src/murmur/MurmurIce.cpp:     ::Murmur::ServerAuthenticatorPrx prx;
./src/murmur/MurmurIce.cpp:             prx = ::Murmur::ServerAuthenticatorPrx::checkedCast(aptr->ice_connectionCached(false)->ice_timeout(5000));
./src/murmur/MurmurIce.cpp:             const ::Murmur::ServerUpdatingAuthenticatorPrx uprx =
./src/murmur/MurmurIce.cpp:                     ::Murmur::ServerUpdatingAuthenticatorPrx::checkedCast(prx);
./src/murmur/MurmurIce.cpp:static void impl_Server_id(const ::Murmur::AMD_Server_idPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getConf(const ::Murmur::AMD_Server_getConfPtr cb, int server_id, const ::std::string &key) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getAllConf(const ::Murmur::AMD_Server_getAllConfPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:     ::Murmur::ConfigMap cm;
./src/murmur/MurmurIce.cpp:static void impl_Server_setConf(const ::Murmur::AMD_Server_setConfPtr cb, int server_id, const ::std::string &key,
./src/murmur/MurmurIce.cpp:static void impl_Server_setSuperuserPassword(const ::Murmur::AMD_Server_setSuperuserPasswordPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_getLog(const ::Murmur::AMD_Server_getLogPtr cb, int server_id, ::Ice::Int min, ::Ice::Int max) {
./src/murmur/MurmurIce.cpp:     ::Murmur::LogList ll;
./src/murmur/MurmurIce.cpp:             ::Murmur::LogEntry le;
./src/murmur/MurmurIce.cpp:static void impl_Server_getLogLen(const ::Murmur::AMD_Server_getLogLenPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getUsers(const ::Murmur::AMD_Server_getUsersPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:     ::Murmur::UserMap pm;
./src/murmur/MurmurIce.cpp:             ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:static void impl_Server_getChannels(const ::Murmur::AMD_Server_getChannelsPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:     ::Murmur::ChannelMap cm;
./src/murmur/MurmurIce.cpp:             ::Murmur::Channel mc;
./src/murmur/MurmurIce.cpp:             ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:static void impl_Server_getTree(const ::Murmur::AMD_Server_getTreePtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getCertificateList(const ::Murmur::AMD_Server_getCertificateListPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:     ::Murmur::CertificateList certs;
./src/murmur/MurmurIce.cpp:             ::Murmur::CertificateDer der;
./src/murmur/MurmurIce.cpp:static void impl_Server_getBans(const ::Murmur::AMD_Server_getBansPtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:     ::Murmur::BanList bl;
./src/murmur/MurmurIce.cpp:             ::Murmur::Ban mb;
./src/murmur/MurmurIce.cpp:static void impl_Server_setBans(const ::Murmur::AMD_Server_setBansPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                             const ::Murmur::BanList &bans) {
./src/murmur/MurmurIce.cpp:             foreach (const ::Murmur::Ban &mb, bans) {
./src/murmur/MurmurIce.cpp:static void impl_Server_kickUser(const ::Murmur::AMD_Server_kickUserPtr cb, int server_id, ::Ice::Int session,
./src/murmur/MurmurIce.cpp:static void impl_Server_sendMessage(const ::Murmur::AMD_Server_sendMessagePtr cb, int server_id, ::Ice::Int session,
./src/murmur/MurmurIce.cpp:static void impl_Server_hasPermission(const ::Murmur::AMD_Server_hasPermissionPtr cb, int server_id, ::Ice::Int session,
./src/murmur/MurmurIce.cpp:static void impl_Server_effectivePermissions(const ::Murmur::AMD_Server_effectivePermissionsPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_addContextCallback(const Murmur::AMD_Server_addContextCallbackPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                                const ::Murmur::ServerContextCallbackPrx &cbptr, int ctx) {
./src/murmur/MurmurIce.cpp:     const QMap< QString, ::Murmur::ServerContextCallbackPrx > &qmPrx = mi->getServerContextCallbacks(server)[session];
./src/murmur/MurmurIce.cpp:             const Murmur::ServerContextCallbackPrx &oneway = Murmur::ServerContextCallbackPrx::checkedCast(
./src/murmur/MurmurIce.cpp:static void impl_Server_removeContextCallback(const Murmur::AMD_Server_removeContextCallbackPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                                       const Murmur::ServerContextCallbackPrx &cbptr) {
./src/murmur/MurmurIce.cpp:     const QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > &qmPrx =
./src/murmur/MurmurIce.cpp:             const Murmur::ServerContextCallbackPrx &oneway = Murmur::ServerContextCallbackPrx::uncheckedCast(
./src/murmur/MurmurIce.cpp:                     const QMap< QString, ::Murmur::ServerContextCallbackPrx > &qm = qmPrx[session];
./src/murmur/MurmurIce.cpp:static void impl_Server_getState(const ::Murmur::AMD_Server_getStatePtr cb, int server_id, ::Ice::Int session) {
./src/murmur/MurmurIce.cpp:     ::Murmur::User mp;
./src/murmur/MurmurIce.cpp:static void impl_Server_setState(const ::Murmur::AMD_Server_setStatePtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                              const ::Murmur::User &state) {
./src/murmur/MurmurIce.cpp:static void impl_Server_sendMessageChannel(const ::Murmur::AMD_Server_sendMessageChannelPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_getChannelState(const ::Murmur::AMD_Server_getChannelStatePtr cb, int server_id,
./src/murmur/MurmurIce.cpp:     ::Murmur::Channel mc;
./src/murmur/MurmurIce.cpp:static void impl_Server_setChannelState(const ::Murmur::AMD_Server_setChannelStatePtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                             const ::Murmur::Channel &state) {
./src/murmur/MurmurIce.cpp:             cb->ice_exception(::Murmur::NestingLimitException());
./src/murmur/MurmurIce.cpp:             cb->ice_exception(::Murmur::InvalidChannelException());
./src/murmur/MurmurIce.cpp:static void impl_Server_removeChannel(const ::Murmur::AMD_Server_removeChannelPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:             cb->ice_exception(::Murmur::InvalidChannelException());
./src/murmur/MurmurIce.cpp:static void impl_Server_addChannel(const ::Murmur::AMD_Server_addChannelPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:             cb->ice_exception(::Murmur::NestingLimitException());
./src/murmur/MurmurIce.cpp:static void impl_Server_getACL(const ::Murmur::AMD_Server_getACLPtr cb, int server_id, ::Ice::Int channelid) {
./src/murmur/MurmurIce.cpp:     ::Murmur::ACLList acls;
./src/murmur/MurmurIce.cpp:     ::Murmur::GroupList groups;
./src/murmur/MurmurIce.cpp:                             ::Murmur::ACL ma;
./src/murmur/MurmurIce.cpp:             ::Murmur::Group mg;
./src/murmur/MurmurIce.cpp:static void impl_Server_setACL(const ::Murmur::AMD_Server_setACLPtr cb, int server_id, ::Ice::Int channelid,
./src/murmur/MurmurIce.cpp:                                                        const ::Murmur::ACLList &acls, const ::Murmur::GroupList &groups, bool inherit) {
./src/murmur/MurmurIce.cpp:             foreach (const ::Murmur::Group &gi, groups) {
./src/murmur/MurmurIce.cpp:             foreach (const ::Murmur::ACL &ai, acls) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getUserNames(const ::Murmur::AMD_Server_getUserNamesPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                      const ::Murmur::IdList &ids) {
./src/murmur/MurmurIce.cpp:     ::Murmur::NameMap nm;
./src/murmur/MurmurIce.cpp:static void impl_Server_getUserIds(const ::Murmur::AMD_Server_getUserIdsPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                const ::Murmur::NameList &names) {
./src/murmur/MurmurIce.cpp:     ::Murmur::IdMap im;
./src/murmur/MurmurIce.cpp:static void impl_Server_registerUser(const ::Murmur::AMD_Server_registerUserPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                      const ::Murmur::UserInfoMap &im) {
./src/murmur/MurmurIce.cpp:static void impl_Server_unregisterUser(const ::Murmur::AMD_Server_unregisterUserPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_updateRegistration(const ::Murmur::AMD_Server_updateRegistrationPtr cb, int server_id, int id,
./src/murmur/MurmurIce.cpp:                                                                                const ::Murmur::UserInfoMap &im) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getRegistration(const ::Murmur::AMD_Server_getRegistrationPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:     Murmur::UserInfoMap im;
./src/murmur/MurmurIce.cpp:static void impl_Server_getRegisteredUsers(const ::Murmur::AMD_Server_getRegisteredUsersPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:     Murmur::NameMap rpl;
./src/murmur/MurmurIce.cpp:static void impl_Server_verifyPassword(const ::Murmur::AMD_Server_verifyPasswordPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_getTexture(const ::Murmur::AMD_Server_getTexturePtr cb, int server_id, ::Ice::Int userid) {
./src/murmur/MurmurIce.cpp:     ::Murmur::Texture tex;
./src/murmur/MurmurIce.cpp:static void impl_Server_setTexture(const ::Murmur::AMD_Server_setTexturePtr cb, int server_id, ::Ice::Int userid,
./src/murmur/MurmurIce.cpp:                                                                const ::Murmur::Texture &tex) {
./src/murmur/MurmurIce.cpp:static void impl_Server_getUptime(const ::Murmur::AMD_Server_getUptimePtr cb, int server_id) {
./src/murmur/MurmurIce.cpp:static void impl_Server_updateCertificate(const ::Murmur::AMD_Server_updateCertificatePtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_startListening(const ::Murmur::AMD_Server_startListeningPtr cb, int server_id, int session,
./src/murmur/MurmurIce.cpp:static void impl_Server_stopListening(const ::Murmur::AMD_Server_stopListeningPtr cb, int server_id, int session,
./src/murmur/MurmurIce.cpp:static void impl_Server_isListening(const ::Murmur::AMD_Server_isListeningPtr cb, int server_id, int session,
./src/murmur/MurmurIce.cpp:static void impl_Server_getListeningChannels(const ::Murmur::AMD_Server_getListeningChannelsPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:     ::Murmur::IntList channelIDs;
./src/murmur/MurmurIce.cpp:static void impl_Server_getListeningUsers(const ::Murmur::AMD_Server_getListeningUsersPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:     ::Murmur::IntList userSessions;
./src/murmur/MurmurIce.cpp:static void impl_Server_sendWelcomeMessage(const ::Murmur::AMD_Server_sendWelcomeMessagePtr cb, int server_id,
./src/murmur/MurmurIce.cpp:                                                                                ::Murmur::IdList receiverUserIDs) {
./src/murmur/MurmurIce.cpp:static void impl_Server_addUserToGroup(const ::Murmur::AMD_Server_addUserToGroupPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_removeUserFromGroup(const ::Murmur::AMD_Server_removeUserFromGroupPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Server_redirectWhisperGroup(const ::Murmur::AMD_Server_redirectWhisperGroupPtr cb, int server_id,
./src/murmur/MurmurIce.cpp:static void impl_Meta_getSliceChecksums(const ::Murmur::AMD_Meta_getSliceChecksumsPtr cb, const Ice::ObjectAdapterPtr) {
./src/murmur/MurmurIce.cpp:static void impl_Meta_getServer(const ::Murmur::AMD_Meta_getServerPtr cb, const Ice::ObjectAdapterPtr adapter,
./src/murmur/MurmurIce.cpp:static void impl_Meta_newServer(const ::Murmur::AMD_Meta_newServerPtr cb, const Ice::ObjectAdapterPtr adapter) {
./src/murmur/MurmurIce.cpp:static void impl_Meta_getAllServers(const ::Murmur::AMD_Meta_getAllServersPtr cb, const Ice::ObjectAdapterPtr adapter) {
./src/murmur/MurmurIce.cpp:     ::Murmur::ServerList sl;
./src/murmur/MurmurIce.cpp:static void impl_Meta_getDefaultConf(const ::Murmur::AMD_Meta_getDefaultConfPtr cb, const Ice::ObjectAdapterPtr) {
./src/murmur/MurmurIce.cpp:     ::Murmur::ConfigMap cm;
./src/murmur/MurmurIce.cpp:static void impl_Meta_getBootedServers(const ::Murmur::AMD_Meta_getBootedServersPtr cb,
./src/murmur/MurmurIce.cpp:     ::Murmur::ServerList sl;
./src/murmur/MurmurIce.cpp:static void impl_Meta_getVersion(const ::Murmur::AMD_Meta_getVersionPtr cb, const Ice::ObjectAdapterPtr) {
./src/murmur/MurmurIce.cpp:static void impl_Meta_addCallback(const Murmur::AMD_Meta_addCallbackPtr cb, const Ice::ObjectAdapterPtr,
./src/murmur/MurmurIce.cpp:                                                               const Murmur::MetaCallbackPrx &cbptr) {
./src/murmur/MurmurIce.cpp:             const Murmur::MetaCallbackPrx &oneway =
./src/murmur/MurmurIce.cpp:                     Murmur::MetaCallbackPrx::checkedCast(cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
./src/murmur/MurmurIce.cpp:static void impl_Meta_removeCallback(const Murmur::AMD_Meta_removeCallbackPtr cb, const Ice::ObjectAdapterPtr,
./src/murmur/MurmurIce.cpp:                                                                      const Murmur::MetaCallbackPrx &cbptr) {
./src/murmur/MurmurIce.cpp:             const Murmur::MetaCallbackPrx &oneway =
./src/murmur/MurmurIce.cpp:                     Murmur::MetaCallbackPrx::uncheckedCast(cbptr->ice_oneway()->ice_connectionCached(false)->ice_timeout(5000));
./src/murmur/MurmurIce.cpp:static void impl_Meta_getUptime(const ::Murmur::AMD_Meta_getUptimePtr cb, const Ice::ObjectAdapterPtr) {
./src/murmur/MurmurIce.cpp:#include "MurmurIceWrapper.cpp"
./src/murmur/MurmurIce.h:#      ifndef MUMBLE_MURMUR_MURMURICE_H_
./src/murmur/MurmurIce.h:#              define MUMBLE_MURMUR_MURMURICE_H_
./src/murmur/MurmurIce.h:#              include "MurmurI.h"
./src/murmur/MurmurIce.h:class MurmurIce : public QObject {
./src/murmur/MurmurIce.h:       friend class MurmurLocker;
./src/murmur/MurmurIce.h:       void badMetaProxy(const ::Murmur::MetaCallbackPrx &prx);
./src/murmur/MurmurIce.h:       void badServerProxy(const ::Murmur::ServerCallbackPrx &prx, const ::Server *server);
./src/murmur/MurmurIce.h:       QList<::Murmur::MetaCallbackPrx > qlMetaCallbacks;
./src/murmur/MurmurIce.h:       QMap< int, QList<::Murmur::ServerCallbackPrx > > qmServerCallbacks;
./src/murmur/MurmurIce.h:       QMap< int, QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > > > qmServerContextCallbacks;
./src/murmur/MurmurIce.h:       QMap< int, ::Murmur::ServerAuthenticatorPrx > qmServerAuthenticator;
./src/murmur/MurmurIce.h:       QMap< int, ::Murmur::ServerUpdatingAuthenticatorPrx > qmServerUpdatingAuthenticator;
./src/murmur/MurmurIce.h:       MurmurIce();
./src/murmur/MurmurIce.h:       ~MurmurIce();
./src/murmur/MurmurIce.h:       void addMetaCallback(const ::Murmur::MetaCallbackPrx &prx);
./src/murmur/MurmurIce.h:       void removeMetaCallback(const ::Murmur::MetaCallbackPrx &prx);
./src/murmur/MurmurIce.h:       void addServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx);
./src/murmur/MurmurIce.h:       void removeServerCallback(const ::Server *server, const ::Murmur::ServerCallbackPrx &prx);
./src/murmur/MurmurIce.h:                                                                 const ::Murmur::ServerContextCallbackPrx &prx);
./src/murmur/MurmurIce.h:       const QMap< int, QMap< QString, ::Murmur::ServerContextCallbackPrx > >
./src/murmur/MurmurIce.h:       void setServerAuthenticator(const ::Server *server, const ::Murmur::ServerAuthenticatorPrx &prx);
./src/murmur/MurmurIce.h:       const ::Murmur::ServerAuthenticatorPrx getServerAuthenticator(const ::Server *server) const;
./src/murmur/MurmurIce.h:       void setServerUpdatingAuthenticator(const ::Server *server, const ::Murmur::ServerUpdatingAuthenticatorPrx &prx);
./src/murmur/MurmurIce.h:       const ::Murmur::ServerUpdatingAuthenticatorPrx getServerUpdatingAuthenticator(const ::Server *server) const;
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::isRunning_async(const ::Murmur::AMD_Server_isRunningPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::start_async(const ::Murmur::AMD_Server_startPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::stop_async(const ::Murmur::AMD_Server_stopPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::delete_async(const ::Murmur::AMD_Server_deletePtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::id_async(const ::Murmur::AMD_Server_idPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::addCallback_async(const ::Murmur::AMD_Server_addCallbackPtr &cb, const ServerCallbackPrx &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::removeCallback_async(const ::Murmur::AMD_Server_removeCallbackPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setAuthenticator_async(const ::Murmur::AMD_Server_setAuthenticatorPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getConf_async(const ::Murmur::AMD_Server_getConfPtr &cb, const ::std::string &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getAllConf_async(const ::Murmur::AMD_Server_getAllConfPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setConf_async(const ::Murmur::AMD_Server_setConfPtr &cb, const ::std::string &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setSuperuserPassword_async(const ::Murmur::AMD_Server_setSuperuserPasswordPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getLog_async(const ::Murmur::AMD_Server_getLogPtr &cb, ::Ice::Int p1, ::Ice::Int p2,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getLogLen_async(const ::Murmur::AMD_Server_getLogLenPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getUsers_async(const ::Murmur::AMD_Server_getUsersPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getChannels_async(const ::Murmur::AMD_Server_getChannelsPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getCertificateList_async(const ::Murmur::AMD_Server_getCertificateListPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getTree_async(const ::Murmur::AMD_Server_getTreePtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getBans_async(const ::Murmur::AMD_Server_getBansPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setBans_async(const ::Murmur::AMD_Server_setBansPtr &cb, const BanList &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::kickUser_async(const ::Murmur::AMD_Server_kickUserPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getState_async(const ::Murmur::AMD_Server_getStatePtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setState_async(const ::Murmur::AMD_Server_setStatePtr &cb, const User &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::sendMessage_async(const ::Murmur::AMD_Server_sendMessagePtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::hasPermission_async(const ::Murmur::AMD_Server_hasPermissionPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::effectivePermissions_async(const ::Murmur::AMD_Server_effectivePermissionsPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::addContextCallback_async(const ::Murmur::AMD_Server_addContextCallbackPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::removeContextCallback_async(const ::Murmur::AMD_Server_removeContextCallbackPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getChannelState_async(const ::Murmur::AMD_Server_getChannelStatePtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setChannelState_async(const ::Murmur::AMD_Server_setChannelStatePtr &cb, const Channel &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::removeChannel_async(const ::Murmur::AMD_Server_removeChannelPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::addChannel_async(const ::Murmur::AMD_Server_addChannelPtr &cb, const ::std::string &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::sendMessageChannel_async(const ::Murmur::AMD_Server_sendMessageChannelPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getACL_async(const ::Murmur::AMD_Server_getACLPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setACL_async(const ::Murmur::AMD_Server_setACLPtr &cb, ::Ice::Int p1, const ACLList &p2,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::addUserToGroup_async(const ::Murmur::AMD_Server_addUserToGroupPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::removeUserFromGroup_async(const ::Murmur::AMD_Server_removeUserFromGroupPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::redirectWhisperGroup_async(const ::Murmur::AMD_Server_redirectWhisperGroupPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getUserNames_async(const ::Murmur::AMD_Server_getUserNamesPtr &cb, const IdList &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getUserIds_async(const ::Murmur::AMD_Server_getUserIdsPtr &cb, const NameList &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::registerUser_async(const ::Murmur::AMD_Server_registerUserPtr &cb, const UserInfoMap &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::unregisterUser_async(const ::Murmur::AMD_Server_unregisterUserPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::updateRegistration_async(const ::Murmur::AMD_Server_updateRegistrationPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getRegistration_async(const ::Murmur::AMD_Server_getRegistrationPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getRegisteredUsers_async(const ::Murmur::AMD_Server_getRegisteredUsersPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::verifyPassword_async(const ::Murmur::AMD_Server_verifyPasswordPtr &cb, const ::std::string &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getTexture_async(const ::Murmur::AMD_Server_getTexturePtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::setTexture_async(const ::Murmur::AMD_Server_setTexturePtr &cb, ::Ice::Int p1, const Texture &p2,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getUptime_async(const ::Murmur::AMD_Server_getUptimePtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::updateCertificate_async(const ::Murmur::AMD_Server_updateCertificatePtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::startListening_async(const ::Murmur::AMD_Server_startListeningPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::stopListening_async(const ::Murmur::AMD_Server_stopListeningPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::isListening_async(const ::Murmur::AMD_Server_isListeningPtr &cb, ::Ice::Int p1, ::Ice::Int p2,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getListeningChannels_async(const ::Murmur::AMD_Server_getListeningChannelsPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::getListeningUsers_async(const ::Murmur::AMD_Server_getListeningUsersPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::ServerI::sendWelcomeMessage_async(const ::Murmur::AMD_Server_sendWelcomeMessagePtr &cb, const IdList &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getServer_async(const ::Murmur::AMD_Meta_getServerPtr &cb, ::Ice::Int p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::newServer_async(const ::Murmur::AMD_Meta_newServerPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getBootedServers_async(const ::Murmur::AMD_Meta_getBootedServersPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getAllServers_async(const ::Murmur::AMD_Meta_getAllServersPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getDefaultConf_async(const ::Murmur::AMD_Meta_getDefaultConfPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getVersion_async(const ::Murmur::AMD_Meta_getVersionPtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::addCallback_async(const ::Murmur::AMD_Meta_addCallbackPtr &cb, const MetaCallbackPrx &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::removeCallback_async(const ::Murmur::AMD_Meta_removeCallbackPtr &cb, const MetaCallbackPrx &p1,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getUptime_async(const ::Murmur::AMD_Meta_getUptimePtr &cb, const ::Ice::Current &current) {
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getSliceChecksums_async(const ::Murmur::AMD_Meta_getSliceChecksumsPtr &cb,
./src/murmur/MurmurIceWrapper.cpp:void ::Murmur::MetaI::getSlice_async(const ::Murmur::AMD_Meta_getSlicePtr &cb, const Ice::Current &) {
./src/murmur/MurmurIceWrapper.cpp:              "\n\n\n\n#include <Ice/SliceChecksumDict.ice>\nmodule Murmur\n{\n\n[\"python:seq:tuple\"] sequence<byte> "
./src/murmur/MurmurIceWrapper.cpp:              "UserInfoMap;\n\nclass Tree {\nChannel c;\nTreeList children;\nUserList users;\n};\nexception MurmurException "
./src/murmur/MurmurIceWrapper.cpp:              "{};\nexception InvalidSessionException extends MurmurException {};\nexception InvalidChannelException extends "
./src/murmur/MurmurIceWrapper.cpp:              "MurmurException {};\nexception InvalidServerException extends MurmurException {};\nexception "
./src/murmur/MurmurIceWrapper.cpp:              "ServerBootedException extends MurmurException {};\nexception ServerFailureException extends MurmurException "
./src/murmur/MurmurIceWrapper.cpp:              "{};\nexception InvalidUserException extends MurmurException {};\nexception InvalidTextureException extends "
./src/murmur/MurmurIceWrapper.cpp:              "MurmurException {};\nexception InvalidCallbackException extends MurmurException {};\nexception "
./src/murmur/MurmurIceWrapper.cpp:              "InvalidSecretException extends MurmurException {};\nexception NestingLimitException extends MurmurException "
./src/murmur/MurmurIceWrapper.cpp:              "{};\nexception WriteOnlyException extends MurmurException {};\nexception InvalidInputDataException extends "
./src/murmur/MurmurIceWrapper.cpp:              "MurmurException {};\n\ninterface ServerCallback {\nidempotent void userConnected(User state);\nidempotent "
./src/murmur/PBKDF2.h:#ifndef MUMBLE_MURMUR_PBKDF2_H_
./src/murmur/PBKDF2.h:#define MUMBLE_MURMUR_PBKDF2_H_
./src/murmur/PBKDF2.h:/// Fully static wrapper class for PBKF2 password hashing functionality used in Murmur.
./src/murmur/PBKDF2.h:#endif // MUMBLE_MURMUR_PBKDF2_H_
./src/murmur/Server.cpp:                // murmur.ini's sslCA option.
./src/murmur/Server.cpp:                // murmur.ini's sslCA option.
./src/murmur/Server.h:#ifndef MUMBLE_MURMUR_SERVER_H_
./src/murmur/Server.h:#define MUMBLE_MURMUR_SERVER_H_
./src/murmur/Server.h:  /// These are the only two threads in Murmur that
./src/murmur/ServerDB.cpp:              qFatal("ServerDB: invalid DB driver specified: '%s'. Murmur only supports QSQLITE, QMYSQL, and QPSQL.",
./src/murmur/ServerDB.cpp:                                      QFile f(datapaths[i] + "/murmur.sqlite");
./src/murmur/ServerDB.cpp:                                              QFile f(datapaths[i] + "/murmur.sqlite");
./src/murmur/ServerDB.h:#ifndef MUMBLE_MURMUR_DATABASE_H_
./src/murmur/ServerDB.h:#define MUMBLE_MURMUR_DATABASE_H_
./src/murmur/ServerUser.h:#ifndef MUMBLE_MURMUR_SERVERUSER_H_
./src/murmur/ServerUser.h:#define MUMBLE_MURMUR_SERVERUSER_H_
./src/murmur/TracyConstants.h:#ifndef MUMBLE_MURMUR_TRACYCONSTANTS_H_
./src/murmur/TracyConstants.h:#define MUMBLE_MURMUR_TRACYCONSTANTS_H_
./src/murmur/TracyConstants.h:#endif // MUMBLE_MURMUR_TRACYCONSTANTS_H_
./src/murmur/Tray.cpp:  qsti->setToolTip(tr("Murmur"));
./src/murmur/Tray.cpp:  qaQuit = new QAction(tr("&Quit Murmur"), this);
./src/murmur/Tray.cpp:  qaAbout = new QAction(tr("&About Murmur"), this);
./src/murmur/Tray.cpp:  qm = new QMenu(tr("Murmur"), nullptr);
./src/murmur/Tray.cpp:          qsti->showMessage(tr("Murmur"), tr("%1 server running.").arg(meta->qhServers.count()),
./src/murmur/Tray.cpp:  if (QMessageBox::question(nullptr, tr("Murmur"), tr("Are you sure you want to quit Murmur?"),
./src/murmur/Tray.cpp:  mw->setWindowTitle(QString::fromLatin1("Murmur -- %1").arg(MUMBLE_RELEASE));
./src/murmur/Tray.h:#ifndef MUMBLE_MURMUR_TRAY_H_
./src/murmur/Tray.h:#define MUMBLE_MURMUR_TRAY_H_
./src/murmur/UnixMurmur.cpp:#include "UnixMurmur.h"
./src/murmur/UnixMurmur.cpp:int UnixMurmur::iHupFd[2];
./src/murmur/UnixMurmur.cpp:int UnixMurmur::iTermFd[2];
./src/murmur/UnixMurmur.cpp:int UnixMurmur::iUsr1Fd[2];
./src/murmur/UnixMurmur.cpp:UnixMurmur::UnixMurmur() {
./src/murmur/UnixMurmur.cpp:UnixMurmur::~UnixMurmur() {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::hupSignalHandler(int) {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::termSignalHandler(int) {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::usr1SignalHandler(int) {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::handleSigHup() {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::handleSigTerm() {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::handleSigUsr1() {
./src/murmur/UnixMurmur.cpp:            qWarning("UnixMurmur: Trying to reload SSL settings...");
./src/murmur/UnixMurmur.cpp:                    qWarning("UnixMurmur: Done reloading SSL settings.");
./src/murmur/UnixMurmur.cpp:                    qWarning("UnixMurmur: Failed to reload SSL settings. Server state is intact and fully operational. No "
./src/murmur/UnixMurmur.cpp:void UnixMurmur::setuid() {
./src/murmur/UnixMurmur.cpp:            qCritical("WARNING: You are launching murmurd as root on Mac OS X or Darwin. Murmur does not need "
./src/murmur/UnixMurmur.cpp:            qCritical("WARNING: You are running murmurd as root, without setting a uname in the ini file. This might be a "
./src/murmur/UnixMurmur.cpp:void UnixMurmur::initialcap() {
./src/murmur/UnixMurmur.cpp:void UnixMurmur::finalcap() {
./src/murmur/UnixMurmur.cpp:const QString UnixMurmur::trySystemIniFiles(const QString &fname) {
./src/murmur/UnixMurmur.cpp:    inipaths << QLatin1String("/usr/local/etc/murmur.ini");
./src/murmur/UnixMurmur.cpp:    inipaths << QLatin1String("/etc/murmur.ini");
./src/murmur/UnixMurmur.h:#ifndef MUMBLE_MURMUR_UNIXMURMUR_H_
./src/murmur/UnixMurmur.h:#define MUMBLE_MURMUR_UNIXMURMUR_H_
./src/murmur/UnixMurmur.h:class UnixMurmur : public QObject {
./src/murmur/UnixMurmur.h:      Q_DISABLE_COPY(UnixMurmur)
./src/murmur/UnixMurmur.h:      UnixMurmur();
./src/murmur/UnixMurmur.h:      ~UnixMurmur();
./src/murmur/Zeroconf.h:#ifndef MUMBLE_MURMUR_ZEROCONF_H_
./src/murmur/Zeroconf.h:#define MUMBLE_MURMUR_ZEROCONF_H_
./src/murmur/main.cpp:# include "UnixMurmur.h"
./src/murmur/main.cpp:static UnixMurmur *unixMurmur = nullptr;
./src/murmur/main.cpp:static void murmurMessageOutputQString(QtMsgType type, const QString &msg) {
./src/murmur/main.cpp:  if (unixMurmur->logToSyslog) {
./src/murmur/main.cpp:          ::MessageBoxA(nullptr, qPrintable(m), "Murmur", MB_OK | MB_ICONWARNING);
./src/murmur/main.cpp:static void murmurMessageOutputWithContext(QtMsgType type, const QMessageLogContext &ctx, const QString &msg) {
./src/murmur/main.cpp:  murmurMessageOutputQString(type, msg);
./src/murmur/main.cpp:  delete MurmurDBus::qdbc;
./src/murmur/main.cpp:  MurmurDBus::qdbc = nullptr;
./src/murmur/main.cpp:  icon.addFile(QLatin1String(":/murmur.16x16.png"));
./src/murmur/main.cpp:  icon.addFile(QLatin1String(":/murmur.32x32.png"));
./src/murmur/main.cpp:  icon.addFile(QLatin1String(":/murmur.64x64.png"));
./src/murmur/main.cpp:  UnixMurmur unixhandler;
./src/murmur/main.cpp:  unixMurmur = &unixhandler;
./src/murmur/main.cpp:  a.setApplicationName("Murmur");
./src/murmur/main.cpp:  qInstallMessageHandler(murmurMessageOutputWithContext);
./src/murmur/main.cpp:                            "                         The purpose of this option is to test how many clients Murmur can handle.\n"
./src/murmur/main.cpp:                            "                         Murmur will exit after this test.\n"
./src/murmur/main.cpp:                            "  -license               Show Murmur's license.\n"
./src/murmur/main.cpp:                            "  -authors               Show Murmur's authors.\n"
./src/murmur/main.cpp:                            "  -third-party-licenses  Show licenses for third-party software used by Murmur.\n"
./src/murmur/main.cpp:                            "If no inifile is provided, murmur will search for one in \n"
./src/murmur/main.cpp:          qFatal("SSL: this version of Murmur is built against Qt without SSL Support. Aborting.");
./src/murmur/main.cpp:                  fprintf(stderr, "murmurd: failed to open logfile %s: no logging will be done\n",
./src/murmur/main.cpp:          openlog("murmurd", LOG_PID, LOG_DAEMON);
./src/murmur/main.cpp:          syslog(LOG_DEBUG, "murmurd syslog adapter up and running");
./src/murmur/main.cpp:  // all these POSIX locks. If another process (i.e. not murmur) makes any
./src/murmur/main.cpp:  MurmurDBus::registerTypes();
./src/murmur/main.cpp:                  MurmurDBus::qdbc = new QDBusConnection(QDBusConnection::sessionBus());
./src/murmur/main.cpp:                  MurmurDBus::qdbc = new QDBusConnection(QDBusConnection::systemBus());
./src/murmur/main.cpp:                  MurmurDBus::qdbc = new QDBusConnection(QDBusConnection::connectToBus(Meta::mp.qsDBus, "mainbus"));
./src/murmur/main.cpp:                  if (!MurmurDBus::qdbc->isConnected()) {
./src/murmur/main.cpp:                          MurmurDBus::qdbc = new QDBusConnection(QDBusConnection::connectToBus(Meta::mp.qsDBus, "mainbus"));
./src/murmur/main.cpp:          if (!MurmurDBus::qdbc->isConnected()) {
./src/murmur/main.cpp:                  if (MurmurDBus::qdbc->isConnected()) {
./src/murmur/main.cpp:                          if (!MurmurDBus::qdbc->registerObject("/", meta)
./src/murmur/main.cpp:                                  || !MurmurDBus::qdbc->registerService(Meta::mp.qsDBusService)) {
./src/murmur/main.cpp:                                  QDBusError e = MurmurDBus::qdbc->lastError();
./src/murmur/main.cpp:  qWarning("Murmur %d.%d.%d (%s) running on %s: %s: Booting servers", major, minor, patch, qPrintable(strver),
./src/murmur/murmur_pch.h:#     ifndef MUMBLE_MURMUR_MURMUR_PCH_H_
./src/murmur/murmur_pch.h:#             define MUMBLE_MURMUR_MURMUR_PCH_H_
./src/tests/TestCrypt/CMakeLists.txt:target_include_directories(TestCrypt PRIVATE "${CMAKE_SOURCE_DIR}/src/murmur")
./src/tests/TestSelfSignedCertificate/TestSelfSignedCertificate.cpp:    bool ok = SelfSignedCertificate::generateMurmurV2Certificate(cert, key);
./src/tests/TestAudioReceiverBuffer/CMakeLists.txt:set(HEADER_TO_COPY "${CMAKE_SOURCE_DIR}/src/murmur/AudioReceiverBuffer.h")
./src/tests/TestAudioReceiverBuffer/CMakeLists.txt:set(SOURCE_TO_COPY "${CMAKE_SOURCE_DIR}/src/murmur/AudioReceiverBuffer.cpp")
./src/crypto/CryptographicRandom.cpp:   // If OpenSSL cannot acquire enough random data to seed its CSPRNG at the time Mumble and Murmur
./src/ACL.cpp:#ifdef MURMUR
./src/ACL.cpp:#ifdef MURMUR
./src/ACL.h:#ifdef MURMUR
./src/CMakeLists.txt:option(server "Build the server (Murmur)" ON)
./src/CMakeLists.txt:   add_subdirectory(murmur)
./src/Connection.h:#ifdef MURMUR
./src/Group.cpp:#ifdef MURMUR
./src/Group.cpp:#ifdef MURMUR
./src/Group.h:#ifdef MURMUR
./src/SelfSignedCertificate.cpp:                commonName = QLatin1String("Murmur Autogenerated Certificate v2");
./src/SelfSignedCertificate.cpp:                CHECK(add_ext(x509, NID_netscape_comment, SSL_STRING("Generated from murmur")));
./src/SelfSignedCertificate.cpp:bool SelfSignedCertificate::generateMurmurV2Certificate(QSslCertificate &qscCert, QSslKey &qskKey) {
./src/SelfSignedCertificate.h:  static bool generateMurmurV2Certificate(QSslCertificate &qscCert, QSslKey &qskKey);
./src/benchmarks/AudioReceiverBuffer/CMakeLists.txt:set(HEADER_TO_COPY "${CMAKE_SOURCE_DIR}/src/murmur/AudioReceiverBuffer.h")
./src/benchmarks/AudioReceiverBuffer/CMakeLists.txt:set(SOURCE_TO_COPY "${CMAKE_SOURCE_DIR}/src/murmur/AudioReceiverBuffer.cpp")
./src/licenses.h:       "Murmur's PBKDF2 support\n"
./src/licenses.h:       "       src/murmur/PBKDF2.cpp\n"
./src/licenses.h:       "       src/murmur/PBKDF2.h\n"
./Changelog.md:Improved: Uninstall no longer deletes murmur.ini file (#4096)
./fakebots_.py:certs_directory = "/home/murmur0/fake/certs/" ## trailing / is important, FIXME
./Doxyfile:                         Murmur.*
./docs/additional-readmes/README.static.linux:What is Murmur?
./docs/additional-readmes/README.static.linux:Murmur is the server component of Mumble, an open-source voice chat utility.
./docs/additional-readmes/README.static.linux:This package is a statically compiled version of Murmur for Linux. It is
./docs/additional-readmes/README.static.linux:Running Murmur
./docs/additional-readmes/README.static.linux:In this build of Murmur, the binary is called 'murmur.x86'. To get Murmur
./docs/additional-readmes/README.static.linux: $ ./murmur.x86 -fg -ini murmur.ini
./docs/additional-readmes/README.static.linux:This will spawn a foregrounded (Murmur will, by default, run in daemon mode,
./docs/additional-readmes/README.static.linux:When Murmur runs for the first time, it performs a few special initialization
./docs/additional-readmes/README.static.linux:This password is important for setting up the Murmur server, so make a note
./docs/additional-readmes/README.static.linux:of it. It is output by the Murmur server the first time it runs, and will
./docs/additional-readmes/README.static.linux:Murmur has the concept of a 'SuperUser', which is the initial administrative user
./docs/additional-readmes/README.static.linux:    Simply specify SuperUser as your username, and the password that Murmur
./docs/additional-readmes/README.static.linux:For more advanced setup and usage of Murmur, please visit the Mumble Wiki,
./docs/additional-readmes/README.static.linux:   http://wiki.mumble.info/wiki/Running_Murmur
./docs/additional-readmes/README.static.linux:   http://wiki.mumble.info/wiki/Murmurguide
./docs/additional-readmes/README.static.linux:Additional Murmur Options
./docs/additional-readmes/README.static.linux:The above instructions use a very bare-bones approach to running Murmur.
./docs/additional-readmes/README.static.linux:murmur.x86 [-supw <password>] [-ini <inifile>] [-fg] [v]
./docs/additional-readmes/README.static.linux:        Murmur will set the password in the database and then exit.
./docs/additional-readmes/README.static.linux:-ini    Use an ini file other than murmur.ini, use this to run several
./docs/additional-readmes/README.static.linux:        instances of Murmur from the same directory. Make sure each
./docs/additional-readmes/README.static.osx:What is Murmur?
./docs/additional-readmes/README.static.osx:Murmur is the server component of Mumble, an open-source voice chat utility.
./docs/additional-readmes/README.static.osx:This package is a statically compiled version of Murmur for OS X.
./docs/additional-readmes/README.static.osx:Running Murmur
./docs/additional-readmes/README.static.osx:In this build of Murmur, the binary is called 'murmurd'. To get Murmur
./docs/additional-readmes/README.static.osx: $ ./murmurd -fg -ini murmur.ini
./docs/additional-readmes/README.static.osx:This will spawn a foregrounded (Murmur will, by default, run in daemon mode,
./docs/additional-readmes/README.static.osx:When Murmur runs for the first time, it performs a few special initialization
./docs/additional-readmes/README.static.osx:This password is important for setting up the Murmur server, so make a note
./docs/additional-readmes/README.static.osx:of it. It is output by the Murmur server the first time it runs, and will
./docs/additional-readmes/README.static.osx:Murmur has the concept of a 'SuperUser', which is the initial administrative user
./docs/additional-readmes/README.static.osx:    Simply specify SuperUser as your username, and the password that Murmur
./docs/additional-readmes/README.static.osx:For more advanced setup and usage of Murmur, please visit the Mumble Wiki,
./docs/additional-readmes/README.static.osx:   http://wiki.mumble.info/wiki/Running_Murmur
./docs/additional-readmes/README.static.osx:   http://wiki.mumble.info/wiki/Murmurguide
./docs/additional-readmes/README.static.osx:Additional Murmur Options
./docs/additional-readmes/README.static.osx:The above instructions use a very bare-bones approach to running Murmur.
./docs/additional-readmes/README.static.osx:murmurd [-supw <password>] [-ini <inifile>] [-fg] [v]
./docs/additional-readmes/README.static.osx:        Murmur will set the password in the database and then exit.
./docs/additional-readmes/README.static.osx:-ini    Use an ini file other than murmur.ini, use this to run several
./docs/additional-readmes/README.static.osx:        instances of Murmur from the same directory. Make sure each
./docs/dev/ExtendingTheIceInterface.md:Note: If not stated otherwise all referenced files live in `src/murmur/`.
./docs/dev/ExtendingTheIceInterface.md:| `Murmur.ice` | Contains the formal definition of the interface |
./docs/dev/ExtendingTheIceInterface.md:| `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` |
./docs/dev/ExtendingTheIceInterface.md:| `Murmur.cpp` | Contains some boilerplate and Ice-internal implementation code. This file is generated and lives alongside `Murmur.h` |
./docs/dev/ExtendingTheIceInterface.md:| `MurmurI.h` | Contains the definition of the actually implemented API classes (`ServerI` and `MetaI`). These extend the abstract base classes from `Murmur.h` |
./docs/dev/ExtendingTheIceInterface.md:| `MurmurIceWrapper.cpp` | Contains wrapper implementation of the `*I` API classes. This file is auto-generated by the `scripts/generateIceWrapper.py` script |
./docs/dev/ExtendingTheIceInterface.md:| `MurmurIce.h` | Contains the definition of a statically used helper class |
./docs/dev/ExtendingTheIceInterface.md:| `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 |
./docs/dev/ExtendingTheIceInterface.md:| `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` |
./docs/dev/ExtendingTheIceInterface.md:1. Let cmake invoke `slice2cpp` to generate `Murmur.h` and `Murmur.cpp`
./docs/dev/ExtendingTheIceInterface.md:2. Invoke `generateIceWrapper.py` to generate `MurmurIceWrapper.cpp`
./docs/dev/ExtendingTheIceInterface.md:3. Add new function declarations to `MurmurU.h`
./docs/dev/ExtendingTheIceInterface.md:4. Write impl function in `MurmurIce.cpp`
./docs/dev/ExtendingTheIceInterface.md:The next step is the generation of the `MurmurIceWrapper.cpp` file by executing the following command (assuming the call is performed from the
./docs/dev/ExtendingTheIceInterface.md:$ python3 scripts/generateIceWrapper.py --ice-file src/murmur/Murmur.ice --generated-ice-header build/src/murmur/Murmur.h --out-file src/murmur/MurmurIceWrapper.cpp 
./docs/dev/ExtendingTheIceInterface.md:Using ICE-file at                   "src/murmur/Murmur.ice"
./docs/dev/ExtendingTheIceInterface.md:Using ICE-generated header file at  "build/src/murmur/Murmur.h"
./docs/dev/ExtendingTheIceInterface.md:The `MurmurIceWrapper.cpp` file generates the `*_async` versions of the Ice callbacks that handle the async nature of these callbacks and also
./docs/dev/ExtendingTheIceInterface.md:defined in `MurmurIce.cpp`. For instance a function called `updateCertificates` inside the `Server` class will call `impl_Server_updateCertificate`
./docs/dev/ExtendingTheIceInterface.md:which has to be defined as a `static` function inside `MurmurIce.cpp`.
./docs/dev/ExtendingTheIceInterface.md:The declaration of the async functions generated this way are contained inside `MurmurI.h`. You have to manually add the function's declaration into
./docs/dev/ExtendingTheIceInterface.md:into the `Murmur.h` file (make the declaration `virtual` though).
./docs/dev/ExtendingTheIceInterface.md:static void impl_<className>_<functionName>(const ::Murmur::AMD_<className>_<functionName>Ptr cb [, int server_id] [, <function arguments>]) {
./docs/dev/ExtendingTheIceInterface.md:- `<functionName>`: Name of the function as declared in the `Murmur.ice` file
./docs/dev/ExtendingTheIceInterface.md: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.
./docs/dev/ExtendingTheIceInterface.md:`::Murmur::IdList`).
./docs/dev/ExtendingTheIceInterface.md:In general it is a good idea to have a look at the existing implementation inside `MurmurIce.cpp` and take inspiration from those.
./docs/dev/ExtendingTheIceInterface.md: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:
./docs/dev/ExtendingTheIceInterface.md:| `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).) |
./docs/dev/ExtendingTheIceInterface.md:| `port` | `6502` | The TCP port on which Ice's interface is listening. (Check [`murmur.ini`'s `ice` property  `-p` flag](../../scripts/murmur.ini#L65).) |
./docs/dev/ExtendingTheIceInterface.md:| `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.) |
./docs/dev/ExtendingTheIceInterface.md:| `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.) |
./docs/dev/ExtendingTheIceInterface.md:> :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.
./docs/dev/ExtendingTheIceInterface.md: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.)
./docs/dev/ExtendingTheIceInterface.md:# Make sure Murmur is running (in a separate terminal)
./docs/dev/ExtendingTheIceInterface.md:# $ ./murmur.x86 ...
./docs/dev/ExtendingTheIceInterface.md:slicefile = "Murmur.ice"
./docs/dev/ExtendingTheIceInterface.md:Import dynamically compiled murmur class... Done
./docs/dev/ExtendingTheIceInterface.md:Murmur object accessible via 'murmur' or 'm'
./docs/dev/ExtendingTheIceInterface.md:> :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.
./docs/dev/MurmurLocking.md:# Locking in Murmur
./docs/dev/MurmurLocking.md:## Murmur's threads
./docs/dev/MurmurLocking.md:Murmur makes use of multiple operating system threads.
./docs/dev/MurmurLocking.md:Most logic in Murmur happens on the main thread.
./docs/dev/MurmurLocking.md:Each virtual server in Murmur is represented by the
./docs/dev/MurmurLocking.md:Murmur's RPC systems usually run on a separate thread --
./docs/dev/MurmurLocking.md:## Understanding data ownership in Murmur
./docs/dev/MurmurLocking.md:exactly Murmur uses this lock, because it is not
./docs/dev/MurmurLocking.md:is only ever accessed by two threads, Murmur is clever in
./docs/dev/MurmurLocking.md:When reading data in the main thread that Murmur knows is
./docs/dev/MurmurLocking.md:is *owned* by the main thread), Murmur will avoid taking a
./docs/dev/MurmurLocking.md:This section documents the owners of data in Murmur that is
./docs/dev/MurmurLocking.md:data races in Murmur.
./docs/dev/build-instructions/cmake_options.md:Build the server (Murmur)
./docs/dev/build-instructions/common_build_errors.md:|CMake Error at cmake/qt-utils.cmake:6 (include):<br>  include could not find requested file:<br><br>    FindPythonInterpreter<br>Call Stack (most recent call first):<br> <br>src/murmur/CMakeLists.txt:16 (include) | Submodules are outdated<br> Run the command 'git submodule update --init' |
./docs/dev/TheMumbleSourceCode.md:│   ├── murmur
./docs/dev/TheMumbleSourceCode.md:that are used by the Mumble client as well as by the server that live in `src/mumble` and `src/murmur` respectively. The `src/mumble_exe` direcrtory
./docs/DockerCompose.md:## Configuring Murmur
./docs/DockerCompose.md:4. Create the file `murmur.ini` and copy the [default murmur.ini](../scripts/murmur.ini) into it.
./docs/DockerCompose.md:5. Change `database` in `murmur.ini` to `/var/lib/murmur/murmur.sqlite`.
./docs/DockerCompose.md:First, give Murmur permission to read the certificate files. There are two options for this:
./docs/DockerCompose.md:2. Have Murmur read the certificate files as `root` and then switch accounts. This is done by adding `user: "0:0"` to `docker-compose.yml` and changing `uname` to `uname=murmur` in `murmur.ini`
./docs/DockerCompose.md:Finally, change `sslCert` and `sslKey` in `murmur.ini` to their respective paths and run `docker-compose down` followed by `docker-compose up -d`.
./botamusique/configuration.example.ini:# [server] section tells the bot how to connect to your murmur server.
./botamusique/README.md:1. Install [Opus Codec](https://www.opus-codec.org/) (which should be already installed if you installed Mumble or Murmur, or you may try to install `opus-tools` with your package manager).
./botamusique/README.md:1. Usually, the first thing is to set the Murmur server you'd like the bot to connect to. You may also specify which channel the bot stays, and tokens used by the bot.
./botamusique/README.md:By default, murmur server uses certificates to identify users. Without a valid certificate, you wouldn't able to register the bot into your Murmur server. Some server even refused users without a certificate. Therefore, it is recommended to generate a certificate for the bot. If you have a certificate (for say, `botmusique.pem` in the folder of the bot), you can specify its location in
./.gitignore:scripts/Murmur.ice
./.gitignore:scripts/murmur.ini.*
./.gitignore:src/murmur/murmur_ice/Murmur.h
./.gitignore:src/murmur/murmur_ice/Murmur.cpp
./.gitignore:src/murmur/MurmurRPC.proto.Wrapper.cpp
./CMakeLists.txt:                       ${CMAKE_SOURCE_DIR}/icons/murmur.ico
./Dockerfile:RUN groupadd --gid $GID murmur \
./Dockerfile:   && useradd --uid $UID --gid $GID murmur
./Dockerfile:COPY --from=0 /root/mumble/scripts/murmur.ini /etc/murmur/murmur.ini
./Dockerfile:RUN mkdir /var/lib/murmur && \
./Dockerfile:   chown --verbose murmur:murmur /var/lib/murmur && \
./Dockerfile:   sed -i 's/^database=$/database=\/var\/lib\/murmur\/murmur.sqlite/' /etc/murmur/murmur.ini
./Dockerfile:USER murmur
./Dockerfile:CMD ["/usr/bin/mumble-server", "-v", "-fg", "-ini", "/etc/murmur/murmur.ini"]
./README.md:There are two modules in Mumble; the client (mumble) and the server (murmur).
./README.md:### Running Murmur
./README.md:Doubleclick the Murmur icon to start murmur. There will be a small icon on your
./README.md:To set the superuser password, run murmur with the parameters `-supw <password>`.
./README.md:### Running Murmur
./README.md:Murmur is distributed separately from the Mumble client on MacOS.
./README.md:For more information please see the "Running Murmur" in the Linux/Unix section below.
./README.md:### Running Murmur
./README.md:Murmur should be run from the command line, so start a shell (command prompt)
./README.md:and go to wherever you installed Mumble. Run murmur as
./README.md:murmurd [-supw <password>] [-ini <inifile>] [-fg] [v]
./README.md:        the SuperUser is disabled. If you use this option, murmur will
./README.md:-ini    Use an inifile other than murmur.ini, use this to run several instances
./README.md:        of murmur from the same directory. Make sure each instance is using
./README.md:You can also specify user id (UID) and group id (GID) for the *murmur* user in the image. This allows users who use bind mount volumes to use the same UID/GID in the container as in the host:

[tgurr]

Even more so a reason that the partly renaming shouldn't have been added half-baked in the first place and obviously things haven't been reverted for the new version as well. Packaging is also not a trivial 5-minutes task.

[Krzmbrzl]

obviously things haven't been reverted for the new version as well

Nor will they for future versions.

[Krzmbrzl]

I can only make the following offer: If someone who actually knows how these things are supposed to be used and work together cooperates with me on this, I can try to update the config files and scripts to work with the new binary name (though the question would be whether it wouldn't be more efficient if that person simply created a PR on their own). But as it stands, I don't use these scripts and for the most part don't know how they are supposed to work together. Thus, me messing around with this will probably make nobody happy.

Personally, I would even go so far as to questioning whether these scripts should be part of this repo in the first place, but I guess that is a different discussion.

[dvzrv]

If someone who actually knows how these things are supposed to be used and work together cooperates with me on this, I can try to update the config files and scripts to work with the new binary name (though the question would be whether it wouldn't be more efficient if that person simply created a PR on their own)

I could help you with that. However, I have 0 clue about other init systems besides systemd integration and how those are still used on their respective OSes. You would need to find someone else for the .init file for that matter.

[Krzmbrzl]

Alright, then let's start with systemd and just see where we land with that :D

So I guess the only relevant file for systemd is the .service file, right? The obvious thing thst needs to be changed is to use the new executable's name instead of murmurd. Anything else?

However, in that file we are assuming that the server is installed to /usr/bin/, which doesn't appear to be very general to me 👀 Is that just where packages tend to install it and therefore it works?

[davidebeatrici]

Yep.

[Krzmbrzl]

Please have a look at #5838 and let me know whether the changes there go into the right direction or not. Any feedback on it is welcome.

[Krzmbrzl]

I think as far as packagers are concerned the issue should now be resolved (via #5838) :thinking: Everything I believe is only visible to actual developers working on the Mumble code.

As such I will close this issue.

Should there be something that I missed, please let me know.

[Krzmbrzl]

Note that due to the size of the changes, I would prefer not to backport these changes to the 1.4.x branch (for now) in order not to risk breaking anything. However, since 1.5 shouldn't be too far away at this point, I hope this is acceptable....