Proto commits in mumble-voip/mumble

These commits are when the Protocol Buffers files have changed: (only the last 100 relevant commits are shown)

2025-05-04

FEAT(server): Allow running while DB is in read-only mode Note that the server's feature set is reduced to the absolute minimum and most requests to the server will simply be dropped. Only users that have already been on the server when it entered this mode will be able to stay on the server and keep talking to each other. No new connections will be accepted and nobody can move channels or perform any other noteworthy actions (except writing text messages, which will still work). This mode is explicitly meant to be used only for short periods of time that might be needed to perform a database backup etc.

The documentation is generated from this commit.

2025-01-15

FEAT(server, client): Add rolling connection quality stats Previously, only the total packet statistics since the user had connected were tracked. While a good start, these stats are not really helping to understand sudden connection problems. This commit adds additional server-side rolling packet stats which are updated every few seconds/minutes. These new stats are sent using additional fields in the UserStats protocol message and rendered in the UserInformation dialog in the client. Closes #5872

2024-09-30

MAINT: Remove copyright year from all copyright notices Keeping these up-to-date is just super tedious and they don't really fulfill any purpose these days.

2023-01-08

MAINT: Update copyright headers to 2023 (cherry picked from commit 249d2c6298cbce059a619dd32b1fde6131ab022f) # Conflicts: # src/mumble/AudioOutputToken.h

MAINT: Update copyright headers to 2023

2022-11-27

FEAT(server): Flag bot connections This commit introduces a new flag that connecting clients can use to tell the server they are connecting to that they consider themselves bot clients. This information can then be used (as is the case for the official server implementation) to e.g. correct the reported user count on the server to only include "real" clients - aka: no bots. Fixes #5461

2022-09-12

FEAT: Make channel listeners persistent on server For registered users, the server will now remember their channel listeners (and their volume adjustments) and will restore them once the user rejoins this server.

2022-09-09

FIX(client, server): Fix patch versions > 255 Previously, the Mumble version was encoded with a uint32 in the network protocol reserving 2 bytes for the major component and 1 byte for each minor and patch. The versioning format was changed to include a build number in the patch field. With a recent update (1.4.274) the patch field exceeded 255 for the first time and broke the protocol version. This commit completely reworks how the version is stored internally and transfered with the network protocol. The new version is a uint64 and consists of 4 fields with 2 bytes each. This allows each version component to reach up to 65535. Furthermore, all instances of integer version types have been replaced with the alias Version::full_t for a better abstraction. Version literals have been replaced by Version::fromComponents calls. Fixes #5827

2022-09-08

FIX(client, server): Fix patch versions > 255 Previously, the Mumble version was encoded with a uint32 in the network protocol reserving 2 bytes for the major component and 1 byte for each minor and patch. The versioning format was changed to include a build number in the patch field. With a recent update (1.4.274) the patch field exceeded 255 for the first time and broke the protocol version. This commit completely reworks how the version is stored internally and transfered with the network protocol. The new version is a uint64 and consists of 4 fields with 2 bytes each. This allows each version component to reach up to 65535. Furthermore, all instances of integer version types have been replaced with the alias Version::full_t for a better abstraction. Version literals have been replaced by Version::fromComponents calls. Fixes #5827

2022-03-27

CHANGE: Use Protobuf for UDP messages Previously Mumble was using a custom binary format for transmitting data via UDP (mainly audio). This has worked for a long time but besides being inconvenient for 3rdParty implementors (they had to manually re-implement encoding and decoding support for this format) this format was not very flexible and changes to the data format were very hard. In order to improve on this situation, this commit introduces changes that allow to use Protobuf for the UDP messages as well (it's already used for TCP). With that it should be relatively easy to extend/change the UDP packet formats in the future and 3rdParty implementors can now simply use Protobuf to handle decoding/encoding packets for them (much less work and much less prone to errors). Since the new Protobuf format is incompatible with the old UDP format, this commit also includes support for dealing with older clients or servers that don't recognize the new protocol yet. That way the new protocol format is only used if both the client and the server are recent enough to have it implemented (assumed to be the case >=1.5.0). Note also that the server will make sure that clients using the old and the new format can seamlessly communicate with one another. Therefore, on the surface it should not be noticeable to the user which protocol is currently used. Note also that the new protocol format only supports Opus as an audio codec. If one of the legacy codecs is to be used, the legacy packet format has to be used as well. However, all codecs except for Opus will be removed from Mumble in the future anyway. Fixes #4350

2022-03-16

CHANGE(server): Remove gRPC implementation The gRPC implementation never left the experimental state and never reached a properly stable state to the point where we would feel good about enabling it by default. In addition to that, there has been no further attempts at finding and fixing the encountered issues in the implementation (except #3947 but that was discontinued). As such we had an essentially unmaintained piece of code in our server implementation that was known to be buggy and that nobody wanted to fix. In addition to that the implementation itself could not be considered very clean or elegant and therefore only represented a few smelly corners in our code base. For this reason, we decided to remove the gRPC support entirely from Mumble (for now). What we hope to gain by that is: - Prevent people from building unstable server versions and then coming to us complaining that it crashed/misbehaved - Removing (essentially) dead code - Reduce the RPC implementation complexity That last piece is crucial: By removing gRPC support we reduce the amount of supported RPC frameworks to only one (ignoring DBus for now). Our future plans include a refactoring of how RPC is being handled and implemented and only having to worry about maintaining compatibility with one RPC system is much easier than having to worry about two (with (slightly) different APIs). Once the RPC implementation has been rewritten, more RPC backends may be reintroduced and in that process we might investigate adding a proper gRPC implementation to the code (that then hopefully is more stable than the current one). Fixes #4567 Fixes #4197 Fixes #3496 Fixes #3429 Fixes #3265

2022-01-04

MAINT: Update copyright to 2022

2021-11-10

FEAT(server): Add option to disallow recording This commit adds a new server-configuration that can be used in the murmur.ini file. It can be used to forbid anyone on the server from using Mumble's built-in recording functionality. Any client trying to start a recording nonetheless, will be kicked from the server. From Mumble 1.5.0 clients will know about this configuration and will disable the recording action in the UI, if recording is not allowed on the server.

2021-06-21

DOCS: Add note to Mumble.proto The datatype used for permissions in proto messages is inconsistent. In 2 of 3 message types it is uint32 but in erverSync it is uint64. We can't change that anymore but this commit adds a note about it into the proto file. Ref: #5139

2021-04-16

FEAT(client): Plugin framework This commit introduces a new plugin framework into the codebase of the Mumble client. Note that "plugin" here really refers to a (more or less) general purpose plugin and is therefore not to be confused with the previously available positional data plugins (only responsible for fetching positional data from a running game and passing that to Mumble). The plugin interface is written in C, removing the compiler-dependence the old "plugins" had. Instead plugins can now be written in an arbitrary language as long as that language is capable of being compiled into a shared library and also being capable of being C-compatible. As already indicated a plugin is essentially a shared library that provides certain functions that allow Mumble to interface with it. Inside Mumble the so-called PluginManager is responsible for managing the plugins and relaying events to the respective callbacks. Plugins themselves can also interact with Mumble on their own initiative by using the provided API functions. Fixes #2455 Fixes #2148 Fixes #1594 Fixes #2051 Fixes #3742 Fixes #4575 Fixes #4751

2021-03-02

MAINT: Update copyright notice to 2021 This was done by running scripts/updateLicenseHeaders.py and then manually editing the LICENSE file.

2021-01-20

DOCS: fixed typos

2020-06-29

DOCS: Fix typos in Mumble.proto

2020-05-12

src/Mumble.proto: Documention on ContextActionModify closes #4115

2020-04-16

Feature: Channel Listeners This implements #3319 by allowing users to "listen" to a channel they have not joined. Doing so will place a "listener proxy" (in other software this is sometimes known as a "phantom") in that channel which will look like a normal user except that it'll have the same name as the user listening to that channel and an ear-icon instead of the normal avatar-icon. It will also always show a muted-icon next to it. If a listener proxy is in a channel, the server will route all audio packets from that channel to the user the proxy belongs to (as if that user was in the channel). Note though that the opposite of this is not true: The users in the channel will not hear audio from the listening user unless that user decides to join the channel. Furthermore it is possible to set a local volume adjustment for each individual proxy that will be applied to all audio that is received through it.

2020-02-28

Merge pull request #3929: Improve channel password handling

Protocol: Added fields 'is_enter_restricted' and 'can_enter' to the ChannelState message in order for the protocol to be able to tell clients about which channels they will be able to enter

2020-02-27

Merge pull request #3978: Fixups for #3927

Mumble.proto: Fixed comment formatting

2020-02-08

Merge PR #3927: Added support for temporary access tokens

2020-01-07

Auto-update LICENSE.header in source files

2019-12-28

AccessTokens: Added support for temporary access tokens in the UserState message

2019-01-25

Auto-update LICENSE.header in source files

2018-06-13

Introduce channelcountlimit to limit max channels per server Having to many channels on a server can impact performance to the point of making the instance unusably slow. This can be a problem for hosters that allow their users unlimited channel creation. This patch introduces a new per-server configuration parameter channelcountlimit which can be used to configure a maximum number of channels that may be created on each of the virtual servers. Once the limit is reached channel creation will be rejected with permission denied. To allow a translated error message we have to bump the client version to 1.3.1 to be able to use a fallback message for older clients. As usual dbus, ice and grpc can ignore this limit. It is only enforced against clients.

2018-01-01

Auto-update LICENSE.header in source files.

2017-01-20

Mumble.proto: explicitly use proto2 syntax. The protoc compiler in protobuf 3.x.y complains (warns) about Mumble.proto not explicitly specifying a syntax. This commit fixes that. The syntax=XXX declaration is mentioned in language spec for proto 2, so this should still work for protobuf 2.6, etc. See https://developers.google.com/protocol-buffers/docs/reference/proto2-spec

2017-01-08

Update tree copyrights to 2017.

2016-05-10

src: update to use LICENSE.header.

src/murmur: update to use LICENSE.header.

2016-05-09

Document undocumented fields in Mumble.proto (#2261) Fixes #1990

2016-05-08

grpc: do renames and add notes to MurmurRPC.proto

grpc: update license headers to use the new-style header.

grpc: update docs

grpc: change Server.uptime to Update from uint32

grpc: fix ServerService.Get for stopped servers

grpc: remove proto field Authenticator.Response.Initialize.updating

grpc: add Find message to Authenticator

grpc: start AuthenticatorService.Stream implementation

grpc: change AuthenticatorService to a (hopefully) easier to use API

grpc: implement ACLService.Get

grpc: implement ACLService.Set

grpc: implement ConfigService.GetDefaults

grpc: implement ConfigService.Get

grpc: implement ConfigService.SetField

grpc: implement ConfigService.GetField

grpc: replace individual Config fields in favour of a map<string, string>

grpc: implement ACLService.GetEffectivePermissions

grpc: implement ACLService.RemoveTemporaryGroup

grpc: implement ACLService.AddTemporaryGroup

grpc: start ServerService.Events implementation

grpc: implement AudioService.SetRedirectWhisperGroup

grpc: implement LogService.Query

grpc: implement BanService.Set

grpc: implement BanService.Get

grpc: implement MetaService.Events

grpc: implement DatabaseService.Query

grpc: implement DatabaseService.Verify

grpc: implement DatabaseService.Deregister

grpc: implement DatabaseService.Register

grpc: implement DatabaseService.Update

grpc: implement DatabaseService.Get

grpc: implement ServerService.Query.

grpc: implement UserService.Query

grpc: implement ChannelService.Query.

grpc: implement TreeService.Get.

grpc: implement targeting of TextMessageService.Send messages

grpc: implement UserService.Update

grpc: implement ServerService.Start

grpc: implement ServerService.Remove

grpc: implement (rough) ContextActionService.Events

grpc: implemented streaming generator, temporary removed certain streaming RPC methods

grpc: implement ServerService.Get

grpc: implement ServerService.Stop

grpc: implement ServerService.Create

grpc: implement ContextActionService.Remove

grpc: implement ContextActionService.Add

grpc: switch to async grpc API, change naming of service methods

grpc: implement ChannelService.add

grpc: implement ChannelService.remove

grpc: implement ChannelService.update

grpc: implement ChannelService.get

grpc: implement UserService.kick

grpc: implement UserService.query

grpc: start UserService, implement UserService::get

grpc: add broadcasting to TextMessageService.send

grpc: start implementation

grpc: switch to proto2 from proto3 proto3 does not support empty fields, which is at odds with how the current Mumble protocol operates

grpc: add first MurmurRPC protobuf draft

grpc: add empty MurmurRPC.proto file

grpc: add User.Kick.actor

grpc: add TextMessageFilter method comment

grpc: implement TextMessageFilter

grpc: only allow users to trigger explicitly added context actions

grpc: add comment about incomplete embedded protobuf messages

grpc: document more of the RPC protocol