Add Mumble support (#1245)

44 files changed, 7768 insertions, 0 deletions

diff --git a/vendor/layeh.com/gumble/LICENSE b/vendor/layeh.com/gumble/LICENSE
new file mode 100644
index 00000000..14e2f777
--- /dev/null
+++ b/vendor/layeh.com/gumble/LICENSE
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
diff --git a/vendor/layeh.com/gumble/gumble/MumbleProto/LICENSE b/vendor/layeh.com/gumble/gumble/MumbleProto/LICENSE
new file mode 100644
index 00000000..c3ffe8f9
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/MumbleProto/LICENSE
@@ -0,0 +1,37 @@
+Copyright (C) 2005-2013, Thorvald Natvig <thorvald@natvig.com>
+Copyright (C) 2007, Stefan Gehn <mETz AT gehn DOT net>
+Copyright (C) 2007, Sebastian Schlingmann <mit_service@users.sourceforge.net>
+Copyright (C) 2008-2013, Mikkel Krautz <mikkel@krautz.dk>
+Copyright (C) 2008, Andreas Messer <andi@bupfen.de>
+Copyright (C) 2007, Trenton Schulz
+Copyright (C) 2008-2013, Stefan Hacker <dd0t@users.sourceforge.net>
+Copyright (C) 2008-2011, Snares <snares@users.sourceforge.net>
+Copyright (C) 2009-2013, Benjamin Jemlich <pcgod@users.sourceforge.net>
+Copyright (C) 2009-2013, Kissaki <kissaki@gmx.de>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+- Neither the name of the Mumble Developers nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+`AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/layeh.com/gumble/gumble/MumbleProto/Mumble.pb.go b/vendor/layeh.com/gumble/gumble/MumbleProto/Mumble.pb.go
new file mode 100644
index 00000000..25380122
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/MumbleProto/Mumble.pb.go
@@ -0,0 +1,3085 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Mumble.proto
+
+package MumbleProto
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Reject_RejectType int32
+
+const (
+	// The rejection reason is unknown (details should be available
+	// in Reject.reason).
+	Reject_None Reject_RejectType = 0
+	// The client attempted to connect with an incompatible version.
+	Reject_WrongVersion Reject_RejectType = 1
+	// The user name supplied by the client was invalid.
+	Reject_InvalidUsername Reject_RejectType = 2
+	// The client attempted to authenticate as a user with a password but it
+	// was wrong.
+	Reject_WrongUserPW Reject_RejectType = 3
+	// The client attempted to connect to a passworded server but the password
+	// was wrong.
+	Reject_WrongServerPW Reject_RejectType = 4
+	// Supplied username is already in use.
+	Reject_UsernameInUse Reject_RejectType = 5
+	// Server is currently full and cannot accept more users.
+	Reject_ServerFull Reject_RejectType = 6
+	// The user did not provide a certificate but one is required.
+	Reject_NoCertificate     Reject_RejectType = 7
+	Reject_AuthenticatorFail Reject_RejectType = 8
+)
+
+var Reject_RejectType_name = map[int32]string{
+	0: "None",
+	1: "WrongVersion",
+	2: "InvalidUsername",
+	3: "WrongUserPW",
+	4: "WrongServerPW",
+	5: "UsernameInUse",
+	6: "ServerFull",
+	7: "NoCertificate",
+	8: "AuthenticatorFail",
+}
+
+var Reject_RejectType_value = map[string]int32{
+	"None":              0,
+	"WrongVersion":      1,
+	"InvalidUsername":   2,
+	"WrongUserPW":       3,
+	"WrongServerPW":     4,
+	"UsernameInUse":     5,
+	"ServerFull":        6,
+	"NoCertificate":     7,
+	"AuthenticatorFail": 8,
+}
+
+func (x Reject_RejectType) Enum() *Reject_RejectType {
+	p := new(Reject_RejectType)
+	*p = x
+	return p
+}
+
+func (x Reject_RejectType) String() string {
+	return proto.EnumName(Reject_RejectType_name, int32(x))
+}
+
+func (x *Reject_RejectType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Reject_RejectType_value, data, "Reject_RejectType")
+	if err != nil {
+		return err
+	}
+	*x = Reject_RejectType(value)
+	return nil
+}
+
+func (Reject_RejectType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{4, 0}
+}
+
+type PermissionDenied_DenyType int32
+
+const (
+	// Operation denied for other reason, see reason field.
+	PermissionDenied_Text PermissionDenied_DenyType = 0
+	// Permissions were denied.
+	PermissionDenied_Permission PermissionDenied_DenyType = 1
+	// Cannot modify SuperUser.
+	PermissionDenied_SuperUser PermissionDenied_DenyType = 2
+	// Invalid channel name.
+	PermissionDenied_ChannelName PermissionDenied_DenyType = 3
+	// Text message too long.
+	PermissionDenied_TextTooLong PermissionDenied_DenyType = 4
+	// The flux capacitor was spelled wrong.
+	PermissionDenied_H9K PermissionDenied_DenyType = 5
+	// Operation not permitted in temporary channel.
+	PermissionDenied_TemporaryChannel PermissionDenied_DenyType = 6
+	// Operation requires certificate.
+	PermissionDenied_MissingCertificate PermissionDenied_DenyType = 7
+	// Invalid username.
+	PermissionDenied_UserName PermissionDenied_DenyType = 8
+	// Channel is full.
+	PermissionDenied_ChannelFull PermissionDenied_DenyType = 9
+	// Channels are nested too deply.
+	PermissionDenied_NestingLimit PermissionDenied_DenyType = 10
+	// Maximum channel count reached.
+	PermissionDenied_ChannelCountLimit PermissionDenied_DenyType = 11
+)
+
+var PermissionDenied_DenyType_name = map[int32]string{
+	0:  "Text",
+	1:  "Permission",
+	2:  "SuperUser",
+	3:  "ChannelName",
+	4:  "TextTooLong",
+	5:  "H9K",
+	6:  "TemporaryChannel",
+	7:  "MissingCertificate",
+	8:  "UserName",
+	9:  "ChannelFull",
+	10: "NestingLimit",
+	11: "ChannelCountLimit",
+}
+
+var PermissionDenied_DenyType_value = map[string]int32{
+	"Text":               0,
+	"Permission":         1,
+	"SuperUser":          2,
+	"ChannelName":        3,
+	"TextTooLong":        4,
+	"H9K":                5,
+	"TemporaryChannel":   6,
+	"MissingCertificate": 7,
+	"UserName":           8,
+	"ChannelFull":        9,
+	"NestingLimit":       10,
+	"ChannelCountLimit":  11,
+}
+
+func (x PermissionDenied_DenyType) Enum() *PermissionDenied_DenyType {
+	p := new(PermissionDenied_DenyType)
+	*p = x
+	return p
+}
+
+func (x PermissionDenied_DenyType) String() string {
+	return proto.EnumName(PermissionDenied_DenyType_name, int32(x))
+}
+
+func (x *PermissionDenied_DenyType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(PermissionDenied_DenyType_value, data, "PermissionDenied_DenyType")
+	if err != nil {
+		return err
+	}
+	*x = PermissionDenied_DenyType(value)
+	return nil
+}
+
+func (PermissionDenied_DenyType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{12, 0}
+}
+
+type ContextActionModify_Context int32
+
+const (
+	// Action is applicable to the server.
+	ContextActionModify_Server ContextActionModify_Context = 1
+	// Action can target a Channel.
+	ContextActionModify_Channel ContextActionModify_Context = 2
+	// Action can target a User.
+	ContextActionModify_User ContextActionModify_Context = 4
+)
+
+var ContextActionModify_Context_name = map[int32]string{
+	1: "Server",
+	2: "Channel",
+	4: "User",
+}
+
+var ContextActionModify_Context_value = map[string]int32{
+	"Server":  1,
+	"Channel": 2,
+	"User":    4,
+}
+
+func (x ContextActionModify_Context) Enum() *ContextActionModify_Context {
+	p := new(ContextActionModify_Context)
+	*p = x
+	return p
+}
+
+func (x ContextActionModify_Context) String() string {
+	return proto.EnumName(ContextActionModify_Context_name, int32(x))
+}
+
+func (x *ContextActionModify_Context) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ContextActionModify_Context_value, data, "ContextActionModify_Context")
+	if err != nil {
+		return err
+	}
+	*x = ContextActionModify_Context(value)
+	return nil
+}
+
+func (ContextActionModify_Context) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{16, 0}
+}
+
+type ContextActionModify_Operation int32
+
+const (
+	ContextActionModify_Add    ContextActionModify_Operation = 0
+	ContextActionModify_Remove ContextActionModify_Operation = 1
+)
+
+var ContextActionModify_Operation_name = map[int32]string{
+	0: "Add",
+	1: "Remove",
+}
+
+var ContextActionModify_Operation_value = map[string]int32{
+	"Add":    0,
+	"Remove": 1,
+}
+
+func (x ContextActionModify_Operation) Enum() *ContextActionModify_Operation {
+	p := new(ContextActionModify_Operation)
+	*p = x
+	return p
+}
+
+func (x ContextActionModify_Operation) String() string {
+	return proto.EnumName(ContextActionModify_Operation_name, int32(x))
+}
+
+func (x *ContextActionModify_Operation) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ContextActionModify_Operation_value, data, "ContextActionModify_Operation")
+	if err != nil {
+		return err
+	}
+	*x = ContextActionModify_Operation(value)
+	return nil
+}
+
+func (ContextActionModify_Operation) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{16, 1}
+}
+
+type Version struct {
+	// 2-byte Major, 1-byte Minor and 1-byte Patch version number.
+	Version *uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
+	// Client release name.
+	Release *string `protobuf:"bytes,2,opt,name=release" json:"release,omitempty"`
+	// Client OS name.
+	Os *string `protobuf:"bytes,3,opt,name=os" json:"os,omitempty"`
+	// Client OS version.
+	OsVersion            *string  `protobuf:"bytes,4,opt,name=os_version,json=osVersion" json:"os_version,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Version) Reset()         { *m = Version{} }
+func (m *Version) String() string { return proto.CompactTextString(m) }
+func (*Version) ProtoMessage()    {}
+func (*Version) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{0}
+}
+
+func (m *Version) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Version.Unmarshal(m, b)
+}
+func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Version.Marshal(b, m, deterministic)
+}
+func (m *Version) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Version.Merge(m, src)
+}
+func (m *Version) XXX_Size() int {
+	return xxx_messageInfo_Version.Size(m)
+}
+func (m *Version) XXX_DiscardUnknown() {
+	xxx_messageInfo_Version.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Version proto.InternalMessageInfo
+
+func (m *Version) GetVersion() uint32 {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return 0
+}
+
+func (m *Version) GetRelease() string {
+	if m != nil && m.Release != nil {
+		return *m.Release
+	}
+	return ""
+}
+
+func (m *Version) GetOs() string {
+	if m != nil && m.Os != nil {
+		return *m.Os
+	}
+	return ""
+}
+
+func (m *Version) GetOsVersion() string {
+	if m != nil && m.OsVersion != nil {
+		return *m.OsVersion
+	}
+	return ""
+}
+
+// Not used. Not even for tunneling UDP through TCP.
+type UDPTunnel struct {
+	// Not used.
+	Packet               []byte   `protobuf:"bytes,1,req,name=packet" json:"packet,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UDPTunnel) Reset()         { *m = UDPTunnel{} }
+func (m *UDPTunnel) String() string { return proto.CompactTextString(m) }
+func (*UDPTunnel) ProtoMessage()    {}
+func (*UDPTunnel) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{1}
+}
+
+func (m *UDPTunnel) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UDPTunnel.Unmarshal(m, b)
+}
+func (m *UDPTunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UDPTunnel.Marshal(b, m, deterministic)
+}
+func (m *UDPTunnel) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UDPTunnel.Merge(m, src)
+}
+func (m *UDPTunnel) XXX_Size() int {
+	return xxx_messageInfo_UDPTunnel.Size(m)
+}
+func (m *UDPTunnel) XXX_DiscardUnknown() {
+	xxx_messageInfo_UDPTunnel.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UDPTunnel proto.InternalMessageInfo
+
+func (m *UDPTunnel) GetPacket() []byte {
+	if m != nil {
+		return m.Packet
+	}
+	return nil
+}
+
+// Used by the client to send the authentication credentials to the server.
+type Authenticate struct {
+	// UTF-8 encoded username.
+	Username *string `protobuf:"bytes,1,opt,name=username" json:"username,omitempty"`
+	// Server or user password.
+	Password *string `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"`
+	// Additional access tokens for server ACL groups.
+	Tokens []string `protobuf:"bytes,3,rep,name=tokens" json:"tokens,omitempty"`
+	// A list of CELT bitstream version constants supported by the client.
+	CeltVersions         []int32  `protobuf:"varint,4,rep,name=celt_versions,json=celtVersions" json:"celt_versions,omitempty"`
+	Opus                 *bool    `protobuf:"varint,5,opt,name=opus,def=0" json:"opus,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Authenticate) Reset()         { *m = Authenticate{} }
+func (m *Authenticate) String() string { return proto.CompactTextString(m) }
+func (*Authenticate) ProtoMessage()    {}
+func (*Authenticate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{2}
+}
+
+func (m *Authenticate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Authenticate.Unmarshal(m, b)
+}
+func (m *Authenticate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Authenticate.Marshal(b, m, deterministic)
+}
+func (m *Authenticate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Authenticate.Merge(m, src)
+}
+func (m *Authenticate) XXX_Size() int {
+	return xxx_messageInfo_Authenticate.Size(m)
+}
+func (m *Authenticate) XXX_DiscardUnknown() {
+	xxx_messageInfo_Authenticate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Authenticate proto.InternalMessageInfo
+
+const Default_Authenticate_Opus bool = false
+
+func (m *Authenticate) GetUsername() string {
+	if m != nil && m.Username != nil {
+		return *m.Username
+	}
+	return ""
+}
+
+func (m *Authenticate) GetPassword() string {
+	if m != nil && m.Password != nil {
+		return *m.Password
+	}
+	return ""
+}
+
+func (m *Authenticate) GetTokens() []string {
+	if m != nil {
+		return m.Tokens
+	}
+	return nil
+}
+
+func (m *Authenticate) GetCeltVersions() []int32 {
+	if m != nil {
+		return m.CeltVersions
+	}
+	return nil
+}
+
+func (m *Authenticate) GetOpus() bool {
+	if m != nil && m.Opus != nil {
+		return *m.Opus
+	}
+	return Default_Authenticate_Opus
+}
+
+// Sent by the client to notify the server that the client is still alive.
+// Server must reply to the packet with the same timestamp and its own
+// good/late/lost/resync numbers. None of the fields is strictly required.
+type Ping struct {
+	// Client timestamp. Server should not attempt to decode.
+	Timestamp *uint64 `protobuf:"varint,1,opt,name=timestamp" json:"timestamp,omitempty"`
+	// The amount of good packets received.
+	Good *uint32 `protobuf:"varint,2,opt,name=good" json:"good,omitempty"`
+	// The amount of late packets received.
+	Late *uint32 `protobuf:"varint,3,opt,name=late" json:"late,omitempty"`
+	// The amount of packets never received.
+	Lost *uint32 `protobuf:"varint,4,opt,name=lost" json:"lost,omitempty"`
+	// The amount of nonce resyncs.
+	Resync *uint32 `protobuf:"varint,5,opt,name=resync" json:"resync,omitempty"`
+	// The total amount of UDP packets received.
+	UdpPackets *uint32 `protobuf:"varint,6,opt,name=udp_packets,json=udpPackets" json:"udp_packets,omitempty"`
+	// The total amount of TCP packets received.
+	TcpPackets *uint32 `protobuf:"varint,7,opt,name=tcp_packets,json=tcpPackets" json:"tcp_packets,omitempty"`
+	// UDP ping average.
+	UdpPingAvg *float32 `protobuf:"fixed32,8,opt,name=udp_ping_avg,json=udpPingAvg" json:"udp_ping_avg,omitempty"`
+	// UDP ping variance.
+	UdpPingVar *float32 `protobuf:"fixed32,9,opt,name=udp_ping_var,json=udpPingVar" json:"udp_ping_var,omitempty"`
+	// TCP ping average.
+	TcpPingAvg *float32 `protobuf:"fixed32,10,opt,name=tcp_ping_avg,json=tcpPingAvg" json:"tcp_ping_avg,omitempty"`
+	// TCP ping variance.
+	TcpPingVar           *float32 `protobuf:"fixed32,11,opt,name=tcp_ping_var,json=tcpPingVar" json:"tcp_ping_var,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Ping) Reset()         { *m = Ping{} }
+func (m *Ping) String() string { return proto.CompactTextString(m) }
+func (*Ping) ProtoMessage()    {}
+func (*Ping) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{3}
+}
+
+func (m *Ping) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Ping.Unmarshal(m, b)
+}
+func (m *Ping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Ping.Marshal(b, m, deterministic)
+}
+func (m *Ping) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Ping.Merge(m, src)
+}
+func (m *Ping) XXX_Size() int {
+	return xxx_messageInfo_Ping.Size(m)
+}
+func (m *Ping) XXX_DiscardUnknown() {
+	xxx_messageInfo_Ping.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Ping proto.InternalMessageInfo
+
+func (m *Ping) GetTimestamp() uint64 {
+	if m != nil && m.Timestamp != nil {
+		return *m.Timestamp
+	}
+	return 0
+}
+
+func (m *Ping) GetGood() uint32 {
+	if m != nil && m.Good != nil {
+		return *m.Good
+	}
+	return 0
+}
+
+func (m *Ping) GetLate() uint32 {
+	if m != nil && m.Late != nil {
+		return *m.Late
+	}
+	return 0
+}
+
+func (m *Ping) GetLost() uint32 {
+	if m != nil && m.Lost != nil {
+		return *m.Lost
+	}
+	return 0
+}
+
+func (m *Ping) GetResync() uint32 {
+	if m != nil && m.Resync != nil {
+		return *m.Resync
+	}
+	return 0
+}
+
+func (m *Ping) GetUdpPackets() uint32 {
+	if m != nil && m.UdpPackets != nil {
+		return *m.UdpPackets
+	}
+	return 0
+}
+
+func (m *Ping) GetTcpPackets() uint32 {
+	if m != nil && m.TcpPackets != nil {
+		return *m.TcpPackets
+	}
+	return 0
+}
+
+func (m *Ping) GetUdpPingAvg() float32 {
+	if m != nil && m.UdpPingAvg != nil {
+		return *m.UdpPingAvg
+	}
+	return 0
+}
+
+func (m *Ping) GetUdpPingVar() float32 {
+	if m != nil && m.UdpPingVar != nil {
+		return *m.UdpPingVar
+	}
+	return 0
+}
+
+func (m *Ping) GetTcpPingAvg() float32 {
+	if m != nil && m.TcpPingAvg != nil {
+		return *m.TcpPingAvg
+	}
+	return 0
+}
+
+func (m *Ping) GetTcpPingVar() float32 {
+	if m != nil && m.TcpPingVar != nil {
+		return *m.TcpPingVar
+	}
+	return 0
+}
+
+// Sent by the server when it rejects the user connection.
+type Reject struct {
+	// Rejection type.
+	Type *Reject_RejectType `protobuf:"varint,1,opt,name=type,enum=MumbleProto.Reject_RejectType" json:"type,omitempty"`
+	// Human readable rejection reason.
+	Reason               *string  `protobuf:"bytes,2,opt,name=reason" json:"reason,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Reject) Reset()         { *m = Reject{} }
+func (m *Reject) String() string { return proto.CompactTextString(m) }
+func (*Reject) ProtoMessage()    {}
+func (*Reject) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{4}
+}
+
+func (m *Reject) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Reject.Unmarshal(m, b)
+}
+func (m *Reject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Reject.Marshal(b, m, deterministic)
+}
+func (m *Reject) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Reject.Merge(m, src)
+}
+func (m *Reject) XXX_Size() int {
+	return xxx_messageInfo_Reject.Size(m)
+}
+func (m *Reject) XXX_DiscardUnknown() {
+	xxx_messageInfo_Reject.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Reject proto.InternalMessageInfo
+
+func (m *Reject) GetType() Reject_RejectType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return Reject_None
+}
+
+func (m *Reject) GetReason() string {
+	if m != nil && m.Reason != nil {
+		return *m.Reason
+	}
+	return ""
+}
+
+// ServerSync message is sent by the server when it has authenticated the user
+// and finished synchronizing the server state.
+type ServerSync struct {
+	// The session of the current user.
+	Session *uint32 `protobuf:"varint,1,opt,name=session" json:"session,omitempty"`
+	// Maximum bandwidth that the user should use.
+	MaxBandwidth *uint32 `protobuf:"varint,2,opt,name=max_bandwidth,json=maxBandwidth" json:"max_bandwidth,omitempty"`
+	// Server welcome text.
+	WelcomeText *string `protobuf:"bytes,3,opt,name=welcome_text,json=welcomeText" json:"welcome_text,omitempty"`
+	// Current user permissions in the root channel.
+	Permissions          *uint64  `protobuf:"varint,4,opt,name=permissions" json:"permissions,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ServerSync) Reset()         { *m = ServerSync{} }
+func (m *ServerSync) String() string { return proto.CompactTextString(m) }
+func (*ServerSync) ProtoMessage()    {}
+func (*ServerSync) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{5}
+}
+
+func (m *ServerSync) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ServerSync.Unmarshal(m, b)
+}
+func (m *ServerSync) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ServerSync.Marshal(b, m, deterministic)
+}
+func (m *ServerSync) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ServerSync.Merge(m, src)
+}
+func (m *ServerSync) XXX_Size() int {
+	return xxx_messageInfo_ServerSync.Size(m)
+}
+func (m *ServerSync) XXX_DiscardUnknown() {
+	xxx_messageInfo_ServerSync.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServerSync proto.InternalMessageInfo
+
+func (m *ServerSync) GetSession() uint32 {
+	if m != nil && m.Session != nil {
+		return *m.Session
+	}
+	return 0
+}
+
+func (m *ServerSync) GetMaxBandwidth() uint32 {
+	if m != nil && m.MaxBandwidth != nil {
+		return *m.MaxBandwidth
+	}
+	return 0
+}
+
+func (m *ServerSync) GetWelcomeText() string {
+	if m != nil && m.WelcomeText != nil {
+		return *m.WelcomeText
+	}
+	return ""
+}
+
+func (m *ServerSync) GetPermissions() uint64 {
+	if m != nil && m.Permissions != nil {
+		return *m.Permissions
+	}
+	return 0
+}
+
+// Sent by the client when it wants a channel removed. Sent by the server when
+// a channel has been removed and clients should be notified.
+type ChannelRemove struct {
+	ChannelId            *uint32  `protobuf:"varint,1,req,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ChannelRemove) Reset()         { *m = ChannelRemove{} }
+func (m *ChannelRemove) String() string { return proto.CompactTextString(m) }
+func (*ChannelRemove) ProtoMessage()    {}
+func (*ChannelRemove) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{6}
+}
+
+func (m *ChannelRemove) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ChannelRemove.Unmarshal(m, b)
+}
+func (m *ChannelRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ChannelRemove.Marshal(b, m, deterministic)
+}
+func (m *ChannelRemove) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ChannelRemove.Merge(m, src)
+}
+func (m *ChannelRemove) XXX_Size() int {
+	return xxx_messageInfo_ChannelRemove.Size(m)
+}
+func (m *ChannelRemove) XXX_DiscardUnknown() {
+	xxx_messageInfo_ChannelRemove.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ChannelRemove proto.InternalMessageInfo
+
+func (m *ChannelRemove) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+// Used to communicate channel properties between the client and the server.
+// Sent by the server during the login process or when channel properties are
+// updated. Client may use this message to update said channel properties.
+type ChannelState struct {
+	// Unique ID for the channel within the server.
+	ChannelId *uint32 `protobuf:"varint,1,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// channel_id of the parent channel.
+	Parent *uint32 `protobuf:"varint,2,opt,name=parent" json:"parent,omitempty"`
+	// UTF-8 encoded channel name.
+	Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
+	// A collection of channel id values of the linked channels. Absent during
+	// the first channel listing.
+	Links []uint32 `protobuf:"varint,4,rep,name=links" json:"links,omitempty"`
+	// UTF-8 encoded channel description. Only if the description is less than
+	// 128 bytes
+	Description *string `protobuf:"bytes,5,opt,name=description" json:"description,omitempty"`
+	// A collection of channel_id values that should be added to links.
+	LinksAdd []uint32 `protobuf:"varint,6,rep,name=links_add,json=linksAdd" json:"links_add,omitempty"`
+	// A collection of channel_id values that should be removed from links.
+	LinksRemove []uint32 `protobuf:"varint,7,rep,name=links_remove,json=linksRemove" json:"links_remove,omitempty"`
+	// True if the channel is temporary.
+	Temporary *bool `protobuf:"varint,8,opt,name=temporary,def=0" json:"temporary,omitempty"`
+	// Position weight to tweak the channel position in the channel list.
+	Position *int32 `protobuf:"varint,9,opt,name=position,def=0" json:"position,omitempty"`
+	// SHA1 hash of the description if the description is 128 bytes or more.
+	DescriptionHash []byte `protobuf:"bytes,10,opt,name=description_hash,json=descriptionHash" json:"description_hash,omitempty"`
+	// Maximum number of users allowed in the channel. If this value is zero,
+	// the maximum number of users allowed in the channel is given by the
+	// server's "usersperchannel" setting.
+	MaxUsers *uint32 `protobuf:"varint,11,opt,name=max_users,json=maxUsers" json:"max_users,omitempty"`
+	// Whether this channel has enter restrictions (ACL denying ENTER) set
+	IsEnterRestricted *bool `protobuf:"varint,12,opt,name=is_enter_restricted,json=isEnterRestricted" json:"is_enter_restricted,omitempty"`
+	// Whether the receiver of this msg is considered to be able to enter this channel
+	CanEnter             *bool    `protobuf:"varint,13,opt,name=can_enter,json=canEnter" json:"can_enter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ChannelState) Reset()         { *m = ChannelState{} }
+func (m *ChannelState) String() string { return proto.CompactTextString(m) }
+func (*ChannelState) ProtoMessage()    {}
+func (*ChannelState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{7}
+}
+
+func (m *ChannelState) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ChannelState.Unmarshal(m, b)
+}
+func (m *ChannelState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ChannelState.Marshal(b, m, deterministic)
+}
+func (m *ChannelState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ChannelState.Merge(m, src)
+}
+func (m *ChannelState) XXX_Size() int {
+	return xxx_messageInfo_ChannelState.Size(m)
+}
+func (m *ChannelState) XXX_DiscardUnknown() {
+	xxx_messageInfo_ChannelState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ChannelState proto.InternalMessageInfo
+
+const Default_ChannelState_Temporary bool = false
+const Default_ChannelState_Position int32 = 0
+
+func (m *ChannelState) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *ChannelState) GetParent() uint32 {
+	if m != nil && m.Parent != nil {
+		return *m.Parent
+	}
+	return 0
+}
+
+func (m *ChannelState) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *ChannelState) GetLinks() []uint32 {
+	if m != nil {
+		return m.Links
+	}
+	return nil
+}
+
+func (m *ChannelState) GetDescription() string {
+	if m != nil && m.Description != nil {
+		return *m.Description
+	}
+	return ""
+}
+
+func (m *ChannelState) GetLinksAdd() []uint32 {
+	if m != nil {
+		return m.LinksAdd
+	}
+	return nil
+}
+
+func (m *ChannelState) GetLinksRemove() []uint32 {
+	if m != nil {
+		return m.LinksRemove
+	}
+	return nil
+}
+
+func (m *ChannelState) GetTemporary() bool {
+	if m != nil && m.Temporary != nil {
+		return *m.Temporary
+	}
+	return Default_ChannelState_Temporary
+}
+
+func (m *ChannelState) GetPosition() int32 {
+	if m != nil && m.Position != nil {
+		return *m.Position
+	}
+	return Default_ChannelState_Position
+}
+
+func (m *ChannelState) GetDescriptionHash() []byte {
+	if m != nil {
+		return m.DescriptionHash
+	}
+	return nil
+}
+
+func (m *ChannelState) GetMaxUsers() uint32 {
+	if m != nil && m.MaxUsers != nil {
+		return *m.MaxUsers
+	}
+	return 0
+}
+
+func (m *ChannelState) GetIsEnterRestricted() bool {
+	if m != nil && m.IsEnterRestricted != nil {
+		return *m.IsEnterRestricted
+	}
+	return false
+}
+
+func (m *ChannelState) GetCanEnter() bool {
+	if m != nil && m.CanEnter != nil {
+		return *m.CanEnter
+	}
+	return false
+}
+
+// Used to communicate user leaving or being kicked. May be sent by the client
+// when it attempts to kick a user. Sent by the server when it informs the
+// clients that a user is not present anymore.
+type UserRemove struct {
+	// The user who is being kicked, identified by their session, not present
+	// when no one is being kicked.
+	Session *uint32 `protobuf:"varint,1,req,name=session" json:"session,omitempty"`
+	// The user who initiated the removal. Either the user who performs the kick
+	// or the user who is currently leaving.
+	Actor *uint32 `protobuf:"varint,2,opt,name=actor" json:"actor,omitempty"`
+	// Reason for the kick, stored as the ban reason if the user is banned.
+	Reason *string `protobuf:"bytes,3,opt,name=reason" json:"reason,omitempty"`
+	// True if the kick should result in a ban.
+	Ban                  *bool    `protobuf:"varint,4,opt,name=ban" json:"ban,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UserRemove) Reset()         { *m = UserRemove{} }
+func (m *UserRemove) String() string { return proto.CompactTextString(m) }
+func (*UserRemove) ProtoMessage()    {}
+func (*UserRemove) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{8}
+}
+
+func (m *UserRemove) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserRemove.Unmarshal(m, b)
+}
+func (m *UserRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserRemove.Marshal(b, m, deterministic)
+}
+func (m *UserRemove) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserRemove.Merge(m, src)
+}
+func (m *UserRemove) XXX_Size() int {
+	return xxx_messageInfo_UserRemove.Size(m)
+}
+func (m *UserRemove) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserRemove.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserRemove proto.InternalMessageInfo
+
+func (m *UserRemove) GetSession() uint32 {
+	if m != nil && m.Session != nil {
+		return *m.Session
+	}
+	return 0
+}
+
+func (m *UserRemove) GetActor() uint32 {
+	if m != nil && m.Actor != nil {
+		return *m.Actor
+	}
+	return 0
+}
+
+func (m *UserRemove) GetReason() string {
+	if m != nil && m.Reason != nil {
+		return *m.Reason
+	}
+	return ""
+}
+
+func (m *UserRemove) GetBan() bool {
+	if m != nil && m.Ban != nil {
+		return *m.Ban
+	}
+	return false
+}
+
+// Sent by the server when it communicates new and changed users to client.
+// First seen during login procedure. May be sent by the client when it wishes
+// to alter its state.
+type UserState struct {
+	// Unique user session ID of the user whose state this is, may change on
+	// reconnect.
+	Session *uint32 `protobuf:"varint,1,opt,name=session" json:"session,omitempty"`
+	// The session of the user who is updating this user.
+	Actor *uint32 `protobuf:"varint,2,opt,name=actor" json:"actor,omitempty"`
+	// User name, UTF-8 encoded.
+	Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
+	// Registered user ID if the user is registered.
+	UserId *uint32 `protobuf:"varint,4,opt,name=user_id,json=userId" json:"user_id,omitempty"`
+	// Channel on which the user is.
+	ChannelId *uint32 `protobuf:"varint,5,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// True if the user is muted by admin.
+	Mute *bool `protobuf:"varint,6,opt,name=mute" json:"mute,omitempty"`
+	// True if the user is deafened by admin.
+	Deaf *bool `protobuf:"varint,7,opt,name=deaf" json:"deaf,omitempty"`
+	// True if the user has been suppressed from talking by a reason other than
+	// being muted.
+	Suppress *bool `protobuf:"varint,8,opt,name=suppress" json:"suppress,omitempty"`
+	// True if the user has muted self.
+	SelfMute *bool `protobuf:"varint,9,opt,name=self_mute,json=selfMute" json:"self_mute,omitempty"`
+	// True if the user has deafened self.
+	SelfDeaf *bool `protobuf:"varint,10,opt,name=self_deaf,json=selfDeaf" json:"self_deaf,omitempty"`
+	// User image if it is less than 128 bytes.
+	Texture []byte `protobuf:"bytes,11,opt,name=texture" json:"texture,omitempty"`
+	// The positional audio plugin identifier.
+	// Positional audio information is only sent to users who share
+	// identical plugin contexts.
+	//
+	// This value is not trasmitted to clients.
+	PluginContext []byte `protobuf:"bytes,12,opt,name=plugin_context,json=pluginContext" json:"plugin_context,omitempty"`
+	// The user's plugin-specific identity.
+	// This value is not transmitted to clients.
+	PluginIdentity *string `protobuf:"bytes,13,opt,name=plugin_identity,json=pluginIdentity" json:"plugin_identity,omitempty"`
+	// User comment if it is less than 128 bytes.
+	Comment *string `protobuf:"bytes,14,opt,name=comment" json:"comment,omitempty"`
+	// The hash of the user certificate.
+	Hash *string `protobuf:"bytes,15,opt,name=hash" json:"hash,omitempty"`
+	// SHA1 hash of the user comment if it 128 bytes or more.
+	CommentHash []byte `protobuf:"bytes,16,opt,name=comment_hash,json=commentHash" json:"comment_hash,omitempty"`
+	// SHA1 hash of the user picture if it 128 bytes or more.
+	TextureHash []byte `protobuf:"bytes,17,opt,name=texture_hash,json=textureHash" json:"texture_hash,omitempty"`
+	// True if the user is a priority speaker.
+	PrioritySpeaker *bool `protobuf:"varint,18,opt,name=priority_speaker,json=prioritySpeaker" json:"priority_speaker,omitempty"`
+	// True if the user is currently recording.
+	Recording *bool `protobuf:"varint,19,opt,name=recording" json:"recording,omitempty"`
+	// A list of temporary acces tokens to be respected when processing this request.
+	TemporaryAccessTokens []string `protobuf:"bytes,20,rep,name=temporary_access_tokens,json=temporaryAccessTokens" json:"temporary_access_tokens,omitempty"`
+	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
+	XXX_unrecognized      []byte   `json:"-"`
+	XXX_sizecache         int32    `json:"-"`
+}
+
+func (m *UserState) Reset()         { *m = UserState{} }
+func (m *UserState) String() string { return proto.CompactTextString(m) }
+func (*UserState) ProtoMessage()    {}
+func (*UserState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{9}
+}
+
+func (m *UserState) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserState.Unmarshal(m, b)
+}
+func (m *UserState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserState.Marshal(b, m, deterministic)
+}
+func (m *UserState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserState.Merge(m, src)
+}
+func (m *UserState) XXX_Size() int {
+	return xxx_messageInfo_UserState.Size(m)
+}
+func (m *UserState) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserState proto.InternalMessageInfo
+
+func (m *UserState) GetSession() uint32 {
+	if m != nil && m.Session != nil {
+		return *m.Session
+	}
+	return 0
+}
+
+func (m *UserState) GetActor() uint32 {
+	if m != nil && m.Actor != nil {
+		return *m.Actor
+	}
+	return 0
+}
+
+func (m *UserState) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *UserState) GetUserId() uint32 {
+	if m != nil && m.UserId != nil {
+		return *m.UserId
+	}
+	return 0
+}
+
+func (m *UserState) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *UserState) GetMute() bool {
+	if m != nil && m.Mute != nil {
+		return *m.Mute
+	}
+	return false
+}
+
+func (m *UserState) GetDeaf() bool {
+	if m != nil && m.Deaf != nil {
+		return *m.Deaf
+	}
+	return false
+}
+
+func (m *UserState) GetSuppress() bool {
+	if m != nil && m.Suppress != nil {
+		return *m.Suppress
+	}
+	return false
+}
+
+func (m *UserState) GetSelfMute() bool {
+	if m != nil && m.SelfMute != nil {
+		return *m.SelfMute
+	}
+	return false
+}
+
+func (m *UserState) GetSelfDeaf() bool {
+	if m != nil && m.SelfDeaf != nil {
+		return *m.SelfDeaf
+	}
+	return false
+}
+
+func (m *UserState) GetTexture() []byte {
+	if m != nil {
+		return m.Texture
+	}
+	return nil
+}
+
+func (m *UserState) GetPluginContext() []byte {
+	if m != nil {
+		return m.PluginContext
+	}
+	return nil
+}
+
+func (m *UserState) GetPluginIdentity() string {
+	if m != nil && m.PluginIdentity != nil {
+		return *m.PluginIdentity
+	}
+	return ""
+}
+
+func (m *UserState) GetComment() string {
+	if m != nil && m.Comment != nil {
+		return *m.Comment
+	}
+	return ""
+}
+
+func (m *UserState) GetHash() string {
+	if m != nil && m.Hash != nil {
+		return *m.Hash
+	}
+	return ""
+}
+
+func (m *UserState) GetCommentHash() []byte {
+	if m != nil {
+		return m.CommentHash
+	}
+	return nil
+}
+
+func (m *UserState) GetTextureHash() []byte {
+	if m != nil {
+		return m.TextureHash
+	}
+	return nil
+}
+
+func (m *UserState) GetPrioritySpeaker() bool {
+	if m != nil && m.PrioritySpeaker != nil {
+		return *m.PrioritySpeaker
+	}
+	return false
+}
+
+func (m *UserState) GetRecording() bool {
+	if m != nil && m.Recording != nil {
+		return *m.Recording
+	}
+	return false
+}
+
+func (m *UserState) GetTemporaryAccessTokens() []string {
+	if m != nil {
+		return m.TemporaryAccessTokens
+	}
+	return nil
+}
+
+// Relays information on the bans. The client may send the BanList message to
+// either modify the list of bans or query them from the server. The server
+// sends this list only after a client queries for it.
+type BanList struct {
+	// List of ban entries currently in place.
+	Bans []*BanList_BanEntry `protobuf:"bytes,1,rep,name=bans" json:"bans,omitempty"`
+	// True if the server should return the list, false if it should replace old
+	// ban list with the one provided.
+	Query                *bool    `protobuf:"varint,2,opt,name=query,def=0" json:"query,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BanList) Reset()         { *m = BanList{} }
+func (m *BanList) String() string { return proto.CompactTextString(m) }
+func (*BanList) ProtoMessage()    {}
+func (*BanList) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{10}
+}
+
+func (m *BanList) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BanList.Unmarshal(m, b)
+}
+func (m *BanList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BanList.Marshal(b, m, deterministic)
+}
+func (m *BanList) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BanList.Merge(m, src)
+}
+func (m *BanList) XXX_Size() int {
+	return xxx_messageInfo_BanList.Size(m)
+}
+func (m *BanList) XXX_DiscardUnknown() {
+	xxx_messageInfo_BanList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BanList proto.InternalMessageInfo
+
+const Default_BanList_Query bool = false
+
+func (m *BanList) GetBans() []*BanList_BanEntry {
+	if m != nil {
+		return m.Bans
+	}
+	return nil
+}
+
+func (m *BanList) GetQuery() bool {
+	if m != nil && m.Query != nil {
+		return *m.Query
+	}
+	return Default_BanList_Query
+}
+
+type BanList_BanEntry struct {
+	// Banned IP address.
+	Address []byte `protobuf:"bytes,1,req,name=address" json:"address,omitempty"`
+	// The length of the subnet mask for the ban.
+	Mask *uint32 `protobuf:"varint,2,req,name=mask" json:"mask,omitempty"`
+	// User name for identification purposes (does not affect the ban).
+	Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
+	// The certificate hash of the banned user.
+	Hash *string `protobuf:"bytes,4,opt,name=hash" json:"hash,omitempty"`
+	// Reason for the ban (does not affect the ban).
+	Reason *string `protobuf:"bytes,5,opt,name=reason" json:"reason,omitempty"`
+	// Ban start time.
+	Start *string `protobuf:"bytes,6,opt,name=start" json:"start,omitempty"`
+	// Ban duration in seconds.
+	Duration             *uint32  `protobuf:"varint,7,opt,name=duration" json:"duration,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BanList_BanEntry) Reset()         { *m = BanList_BanEntry{} }
+func (m *BanList_BanEntry) String() string { return proto.CompactTextString(m) }
+func (*BanList_BanEntry) ProtoMessage()    {}
+func (*BanList_BanEntry) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{10, 0}
+}
+
+func (m *BanList_BanEntry) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BanList_BanEntry.Unmarshal(m, b)
+}
+func (m *BanList_BanEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BanList_BanEntry.Marshal(b, m, deterministic)
+}
+func (m *BanList_BanEntry) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BanList_BanEntry.Merge(m, src)
+}
+func (m *BanList_BanEntry) XXX_Size() int {
+	return xxx_messageInfo_BanList_BanEntry.Size(m)
+}
+func (m *BanList_BanEntry) XXX_DiscardUnknown() {
+	xxx_messageInfo_BanList_BanEntry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BanList_BanEntry proto.InternalMessageInfo
+
+func (m *BanList_BanEntry) GetAddress() []byte {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+func (m *BanList_BanEntry) GetMask() uint32 {
+	if m != nil && m.Mask != nil {
+		return *m.Mask
+	}
+	return 0
+}
+
+func (m *BanList_BanEntry) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *BanList_BanEntry) GetHash() string {
+	if m != nil && m.Hash != nil {
+		return *m.Hash
+	}
+	return ""
+}
+
+func (m *BanList_BanEntry) GetReason() string {
+	if m != nil && m.Reason != nil {
+		return *m.Reason
+	}
+	return ""
+}
+
+func (m *BanList_BanEntry) GetStart() string {
+	if m != nil && m.Start != nil {
+		return *m.Start
+	}
+	return ""
+}
+
+func (m *BanList_BanEntry) GetDuration() uint32 {
+	if m != nil && m.Duration != nil {
+		return *m.Duration
+	}
+	return 0
+}
+
+// Used to send and broadcast text messages.
+type TextMessage struct {
+	// The message sender, identified by its session.
+	Actor *uint32 `protobuf:"varint,1,opt,name=actor" json:"actor,omitempty"`
+	// Target users for the message, identified by their session.
+	Session []uint32 `protobuf:"varint,2,rep,name=session" json:"session,omitempty"`
+	// The channels to which the message is sent, identified by their
+	// channel_ids.
+	ChannelId []uint32 `protobuf:"varint,3,rep,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// The root channels when sending message recursively to several channels,
+	// identified by their channel_ids.
+	TreeId []uint32 `protobuf:"varint,4,rep,name=tree_id,json=treeId" json:"tree_id,omitempty"`
+	// The UTF-8 encoded message. May be HTML if the server allows.
+	Message              *string  `protobuf:"bytes,5,req,name=message" json:"message,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TextMessage) Reset()         { *m = TextMessage{} }
+func (m *TextMessage) String() string { return proto.CompactTextString(m) }
+func (*TextMessage) ProtoMessage()    {}
+func (*TextMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{11}
+}
+
+func (m *TextMessage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TextMessage.Unmarshal(m, b)
+}
+func (m *TextMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TextMessage.Marshal(b, m, deterministic)
+}
+func (m *TextMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TextMessage.Merge(m, src)
+}
+func (m *TextMessage) XXX_Size() int {
+	return xxx_messageInfo_TextMessage.Size(m)
+}
+func (m *TextMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_TextMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TextMessage proto.InternalMessageInfo
+
+func (m *TextMessage) GetActor() uint32 {
+	if m != nil && m.Actor != nil {
+		return *m.Actor
+	}
+	return 0
+}
+
+func (m *TextMessage) GetSession() []uint32 {
+	if m != nil {
+		return m.Session
+	}
+	return nil
+}
+
+func (m *TextMessage) GetChannelId() []uint32 {
+	if m != nil {
+		return m.ChannelId
+	}
+	return nil
+}
+
+func (m *TextMessage) GetTreeId() []uint32 {
+	if m != nil {
+		return m.TreeId
+	}
+	return nil
+}
+
+func (m *TextMessage) GetMessage() string {
+	if m != nil && m.Message != nil {
+		return *m.Message
+	}
+	return ""
+}
+
+type PermissionDenied struct {
+	// The denied permission when type is Permission.
+	Permission *uint32 `protobuf:"varint,1,opt,name=permission" json:"permission,omitempty"`
+	// channel_id for the channel where the permission was denied when type is
+	// Permission.
+	ChannelId *uint32 `protobuf:"varint,2,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// The user who was denied permissions, identified by session.
+	Session *uint32 `protobuf:"varint,3,opt,name=session" json:"session,omitempty"`
+	// Textual reason for the denial.
+	Reason *string `protobuf:"bytes,4,opt,name=reason" json:"reason,omitempty"`
+	// Type of the denial.
+	Type *PermissionDenied_DenyType `protobuf:"varint,5,opt,name=type,enum=MumbleProto.PermissionDenied_DenyType" json:"type,omitempty"`
+	// The name that is invalid when type is UserName.
+	Name                 *string  `protobuf:"bytes,6,opt,name=name" json:"name,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PermissionDenied) Reset()         { *m = PermissionDenied{} }
+func (m *PermissionDenied) String() string { return proto.CompactTextString(m) }
+func (*PermissionDenied) ProtoMessage()    {}
+func (*PermissionDenied) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{12}
+}
+
+func (m *PermissionDenied) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PermissionDenied.Unmarshal(m, b)
+}
+func (m *PermissionDenied) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PermissionDenied.Marshal(b, m, deterministic)
+}
+func (m *PermissionDenied) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PermissionDenied.Merge(m, src)
+}
+func (m *PermissionDenied) XXX_Size() int {
+	return xxx_messageInfo_PermissionDenied.Size(m)
+}
+func (m *PermissionDenied) XXX_DiscardUnknown() {
+	xxx_messageInfo_PermissionDenied.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PermissionDenied proto.InternalMessageInfo
+
+func (m *PermissionDenied) GetPermission() uint32 {
+	if m != nil && m.Permission != nil {
+		return *m.Permission
+	}
+	return 0
+}
+
+func (m *PermissionDenied) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *PermissionDenied) GetSession() uint32 {
+	if m != nil && m.Session != nil {
+		return *m.Session
+	}
+	return 0
+}
+
+func (m *PermissionDenied) GetReason() string {
+	if m != nil && m.Reason != nil {
+		return *m.Reason
+	}
+	return ""
+}
+
+func (m *PermissionDenied) GetType() PermissionDenied_DenyType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return PermissionDenied_Text
+}
+
+func (m *PermissionDenied) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+type ACL struct {
+	// Channel ID of the channel this message affects.
+	ChannelId *uint32 `protobuf:"varint,1,req,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// True if the channel inherits its parent's ACLs.
+	InheritAcls *bool `protobuf:"varint,2,opt,name=inherit_acls,json=inheritAcls,def=1" json:"inherit_acls,omitempty"`
+	// User group specifications.
+	Groups []*ACL_ChanGroup `protobuf:"bytes,3,rep,name=groups" json:"groups,omitempty"`
+	// ACL specifications.
+	Acls []*ACL_ChanACL `protobuf:"bytes,4,rep,name=acls" json:"acls,omitempty"`
+	// True if the message is a query for ACLs instead of setting them.
+	Query                *bool    `protobuf:"varint,5,opt,name=query,def=0" json:"query,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ACL) Reset()         { *m = ACL{} }
+func (m *ACL) String() string { return proto.CompactTextString(m) }
+func (*ACL) ProtoMessage()    {}
+func (*ACL) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{13}
+}
+
+func (m *ACL) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ACL.Unmarshal(m, b)
+}
+func (m *ACL) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ACL.Marshal(b, m, deterministic)
+}
+func (m *ACL) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ACL.Merge(m, src)
+}
+func (m *ACL) XXX_Size() int {
+	return xxx_messageInfo_ACL.Size(m)
+}
+func (m *ACL) XXX_DiscardUnknown() {
+	xxx_messageInfo_ACL.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ACL proto.InternalMessageInfo
+
+const Default_ACL_InheritAcls bool = true
+const Default_ACL_Query bool = false
+
+func (m *ACL) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *ACL) GetInheritAcls() bool {
+	if m != nil && m.InheritAcls != nil {
+		return *m.InheritAcls
+	}
+	return Default_ACL_InheritAcls
+}
+
+func (m *ACL) GetGroups() []*ACL_ChanGroup {
+	if m != nil {
+		return m.Groups
+	}
+	return nil
+}
+
+func (m *ACL) GetAcls() []*ACL_ChanACL {
+	if m != nil {
+		return m.Acls
+	}
+	return nil
+}
+
+func (m *ACL) GetQuery() bool {
+	if m != nil && m.Query != nil {
+		return *m.Query
+	}
+	return Default_ACL_Query
+}
+
+type ACL_ChanGroup struct {
+	// Name of the channel group, UTF-8 encoded.
+	Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	// True if the group has been inherited from the parent (Read only).
+	Inherited *bool `protobuf:"varint,2,opt,name=inherited,def=1" json:"inherited,omitempty"`
+	// True if the group members are inherited.
+	Inherit *bool `protobuf:"varint,3,opt,name=inherit,def=1" json:"inherit,omitempty"`
+	// True if the group can be inherited by sub channels.
+	Inheritable *bool `protobuf:"varint,4,opt,name=inheritable,def=1" json:"inheritable,omitempty"`
+	// Users explicitly included in this group, identified by user_id.
+	Add []uint32 `protobuf:"varint,5,rep,name=add" json:"add,omitempty"`
+	// Users explicitly removed from this group in this channel if the group
+	// has been inherited, identified by user_id.
+	Remove []uint32 `protobuf:"varint,6,rep,name=remove" json:"remove,omitempty"`
+	// Users inherited, identified by user_id.
+	InheritedMembers     []uint32 `protobuf:"varint,7,rep,name=inherited_members,json=inheritedMembers" json:"inherited_members,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ACL_ChanGroup) Reset()         { *m = ACL_ChanGroup{} }
+func (m *ACL_ChanGroup) String() string { return proto.CompactTextString(m) }
+func (*ACL_ChanGroup) ProtoMessage()    {}
+func (*ACL_ChanGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{13, 0}
+}
+
+func (m *ACL_ChanGroup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ACL_ChanGroup.Unmarshal(m, b)
+}
+func (m *ACL_ChanGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ACL_ChanGroup.Marshal(b, m, deterministic)
+}
+func (m *ACL_ChanGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ACL_ChanGroup.Merge(m, src)
+}
+func (m *ACL_ChanGroup) XXX_Size() int {
+	return xxx_messageInfo_ACL_ChanGroup.Size(m)
+}
+func (m *ACL_ChanGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_ACL_ChanGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ACL_ChanGroup proto.InternalMessageInfo
+
+const Default_ACL_ChanGroup_Inherited bool = true
+const Default_ACL_ChanGroup_Inherit bool = true
+const Default_ACL_ChanGroup_Inheritable bool = true
+
+func (m *ACL_ChanGroup) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *ACL_ChanGroup) GetInherited() bool {
+	if m != nil && m.Inherited != nil {
+		return *m.Inherited
+	}
+	return Default_ACL_ChanGroup_Inherited
+}
+
+func (m *ACL_ChanGroup) GetInherit() bool {
+	if m != nil && m.Inherit != nil {
+		return *m.Inherit
+	}
+	return Default_ACL_ChanGroup_Inherit
+}
+
+func (m *ACL_ChanGroup) GetInheritable() bool {
+	if m != nil && m.Inheritable != nil {
+		return *m.Inheritable
+	}
+	return Default_ACL_ChanGroup_Inheritable
+}
+
+func (m *ACL_ChanGroup) GetAdd() []uint32 {
+	if m != nil {
+		return m.Add
+	}
+	return nil
+}
+
+func (m *ACL_ChanGroup) GetRemove() []uint32 {
+	if m != nil {
+		return m.Remove
+	}
+	return nil
+}
+
+func (m *ACL_ChanGroup) GetInheritedMembers() []uint32 {
+	if m != nil {
+		return m.InheritedMembers
+	}
+	return nil
+}
+
+type ACL_ChanACL struct {
+	// True if this ACL applies to the current channel.
+	ApplyHere *bool `protobuf:"varint,1,opt,name=apply_here,json=applyHere,def=1" json:"apply_here,omitempty"`
+	// True if this ACL applies to the sub channels.
+	ApplySubs *bool `protobuf:"varint,2,opt,name=apply_subs,json=applySubs,def=1" json:"apply_subs,omitempty"`
+	// True if the ACL has been inherited from the parent.
+	Inherited *bool `protobuf:"varint,3,opt,name=inherited,def=1" json:"inherited,omitempty"`
+	// ID of the user that is affected by this ACL.
+	UserId *uint32 `protobuf:"varint,4,opt,name=user_id,json=userId" json:"user_id,omitempty"`
+	// ID of the group that is affected by this ACL.
+	Group *string `protobuf:"bytes,5,opt,name=group" json:"group,omitempty"`
+	// Bit flag field of the permissions granted by this ACL.
+	Grant *uint32 `protobuf:"varint,6,opt,name=grant" json:"grant,omitempty"`
+	// Bit flag field of the permissions denied by this ACL.
+	Deny                 *uint32  `protobuf:"varint,7,opt,name=deny" json:"deny,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ACL_ChanACL) Reset()         { *m = ACL_ChanACL{} }
+func (m *ACL_ChanACL) String() string { return proto.CompactTextString(m) }
+func (*ACL_ChanACL) ProtoMessage()    {}
+func (*ACL_ChanACL) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{13, 1}
+}
+
+func (m *ACL_ChanACL) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ACL_ChanACL.Unmarshal(m, b)
+}
+func (m *ACL_ChanACL) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ACL_ChanACL.Marshal(b, m, deterministic)
+}
+func (m *ACL_ChanACL) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ACL_ChanACL.Merge(m, src)
+}
+func (m *ACL_ChanACL) XXX_Size() int {
+	return xxx_messageInfo_ACL_ChanACL.Size(m)
+}
+func (m *ACL_ChanACL) XXX_DiscardUnknown() {
+	xxx_messageInfo_ACL_ChanACL.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ACL_ChanACL proto.InternalMessageInfo
+
+const Default_ACL_ChanACL_ApplyHere bool = true
+const Default_ACL_ChanACL_ApplySubs bool = true
+const Default_ACL_ChanACL_Inherited bool = true
+
+func (m *ACL_ChanACL) GetApplyHere() bool {
+	if m != nil && m.ApplyHere != nil {
+		return *m.ApplyHere
+	}
+	return Default_ACL_ChanACL_ApplyHere
+}
+
+func (m *ACL_ChanACL) GetApplySubs() bool {
+	if m != nil && m.ApplySubs != nil {
+		return *m.ApplySubs
+	}
+	return Default_ACL_ChanACL_ApplySubs
+}
+
+func (m *ACL_ChanACL) GetInherited() bool {
+	if m != nil && m.Inherited != nil {
+		return *m.Inherited
+	}
+	return Default_ACL_ChanACL_Inherited
+}
+
+func (m *ACL_ChanACL) GetUserId() uint32 {
+	if m != nil && m.UserId != nil {
+		return *m.UserId
+	}
+	return 0
+}
+
+func (m *ACL_ChanACL) GetGroup() string {
+	if m != nil && m.Group != nil {
+		return *m.Group
+	}
+	return ""
+}
+
+func (m *ACL_ChanACL) GetGrant() uint32 {
+	if m != nil && m.Grant != nil {
+		return *m.Grant
+	}
+	return 0
+}
+
+func (m *ACL_ChanACL) GetDeny() uint32 {
+	if m != nil && m.Deny != nil {
+		return *m.Deny
+	}
+	return 0
+}
+
+// Client may use this message to refresh its registered user information. The
+// client should fill the IDs or Names of the users it wants to refresh. The
+// server fills the missing parts and sends the message back.
+type QueryUsers struct {
+	// user_ids.
+	Ids []uint32 `protobuf:"varint,1,rep,name=ids" json:"ids,omitempty"`
+	// User names in the same order as ids.
+	Names                []string `protobuf:"bytes,2,rep,name=names" json:"names,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *QueryUsers) Reset()         { *m = QueryUsers{} }
+func (m *QueryUsers) String() string { return proto.CompactTextString(m) }
+func (*QueryUsers) ProtoMessage()    {}
+func (*QueryUsers) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{14}
+}
+
+func (m *QueryUsers) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_QueryUsers.Unmarshal(m, b)
+}
+func (m *QueryUsers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_QueryUsers.Marshal(b, m, deterministic)
+}
+func (m *QueryUsers) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryUsers.Merge(m, src)
+}
+func (m *QueryUsers) XXX_Size() int {
+	return xxx_messageInfo_QueryUsers.Size(m)
+}
+func (m *QueryUsers) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryUsers.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryUsers proto.InternalMessageInfo
+
+func (m *QueryUsers) GetIds() []uint32 {
+	if m != nil {
+		return m.Ids
+	}
+	return nil
+}
+
+func (m *QueryUsers) GetNames() []string {
+	if m != nil {
+		return m.Names
+	}
+	return nil
+}
+
+// Used to initialize and resync the UDP encryption. Either side may request a
+// resync by sending the message without any values filled. The resync is
+// performed by sending the message with only the client or server nonce
+// filled.
+type CryptSetup struct {
+	// Encryption key.
+	Key []byte `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	// Client nonce.
+	ClientNonce []byte `protobuf:"bytes,2,opt,name=client_nonce,json=clientNonce" json:"client_nonce,omitempty"`
+	// Server nonce.
+	ServerNonce          []byte   `protobuf:"bytes,3,opt,name=server_nonce,json=serverNonce" json:"server_nonce,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CryptSetup) Reset()         { *m = CryptSetup{} }
+func (m *CryptSetup) String() string { return proto.CompactTextString(m) }
+func (*CryptSetup) ProtoMessage()    {}
+func (*CryptSetup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{15}
+}
+
+func (m *CryptSetup) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CryptSetup.Unmarshal(m, b)
+}
+func (m *CryptSetup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CryptSetup.Marshal(b, m, deterministic)
+}
+func (m *CryptSetup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CryptSetup.Merge(m, src)
+}
+func (m *CryptSetup) XXX_Size() int {
+	return xxx_messageInfo_CryptSetup.Size(m)
+}
+func (m *CryptSetup) XXX_DiscardUnknown() {
+	xxx_messageInfo_CryptSetup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CryptSetup proto.InternalMessageInfo
+
+func (m *CryptSetup) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *CryptSetup) GetClientNonce() []byte {
+	if m != nil {
+		return m.ClientNonce
+	}
+	return nil
+}
+
+func (m *CryptSetup) GetServerNonce() []byte {
+	if m != nil {
+		return m.ServerNonce
+	}
+	return nil
+}
+
+type ContextActionModify struct {
+	// The action name.
+	Action *string `protobuf:"bytes,1,req,name=action" json:"action,omitempty"`
+	// The display name of the action.
+	Text *string `protobuf:"bytes,2,opt,name=text" json:"text,omitempty"`
+	// Context bit flags defining where the action should be displayed.
+	Context              *uint32                        `protobuf:"varint,3,opt,name=context" json:"context,omitempty"`
+	Operation            *ContextActionModify_Operation `protobuf:"varint,4,opt,name=operation,enum=MumbleProto.ContextActionModify_Operation" json:"operation,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
+	XXX_unrecognized     []byte                         `json:"-"`
+	XXX_sizecache        int32                          `json:"-"`
+}
+
+func (m *ContextActionModify) Reset()         { *m = ContextActionModify{} }
+func (m *ContextActionModify) String() string { return proto.CompactTextString(m) }
+func (*ContextActionModify) ProtoMessage()    {}
+func (*ContextActionModify) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{16}
+}
+
+func (m *ContextActionModify) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ContextActionModify.Unmarshal(m, b)
+}
+func (m *ContextActionModify) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ContextActionModify.Marshal(b, m, deterministic)
+}
+func (m *ContextActionModify) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ContextActionModify.Merge(m, src)
+}
+func (m *ContextActionModify) XXX_Size() int {
+	return xxx_messageInfo_ContextActionModify.Size(m)
+}
+func (m *ContextActionModify) XXX_DiscardUnknown() {
+	xxx_messageInfo_ContextActionModify.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ContextActionModify proto.InternalMessageInfo
+
+func (m *ContextActionModify) GetAction() string {
+	if m != nil && m.Action != nil {
+		return *m.Action
+	}
+	return ""
+}
+
+func (m *ContextActionModify) GetText() string {
+	if m != nil && m.Text != nil {
+		return *m.Text
+	}
+	return ""
+}
+
+func (m *ContextActionModify) GetContext() uint32 {
+	if m != nil && m.Context != nil {
+		return *m.Context
+	}
+	return 0
+}
+
+func (m *ContextActionModify) GetOperation() ContextActionModify_Operation {
+	if m != nil && m.Operation != nil {
+		return *m.Operation
+	}
+	return ContextActionModify_Add
+}
+
+// Sent by the client when it wants to initiate a Context action.
+type ContextAction struct {
+	// The target User for the action, identified by session.
+	Session *uint32 `protobuf:"varint,1,opt,name=session" json:"session,omitempty"`
+	// The target Channel for the action, identified by channel_id.
+	ChannelId *uint32 `protobuf:"varint,2,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// The action that should be executed.
+	Action               *string  `protobuf:"bytes,3,req,name=action" json:"action,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ContextAction) Reset()         { *m = ContextAction{} }
+func (m *ContextAction) String() string { return proto.CompactTextString(m) }
+func (*ContextAction) ProtoMessage()    {}
+func (*ContextAction) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{17}
+}
+
+func (m *ContextAction) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ContextAction.Unmarshal(m, b)
+}
+func (m *ContextAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ContextAction.Marshal(b, m, deterministic)
+}
+func (m *ContextAction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ContextAction.Merge(m, src)
+}
+func (m *ContextAction) XXX_Size() int {
+	return xxx_messageInfo_ContextAction.Size(m)
+}
+func (m *ContextAction) XXX_DiscardUnknown() {
+	xxx_messageInfo_ContextAction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ContextAction proto.InternalMessageInfo
+
+func (m *ContextAction) GetSession() uint32 {
+	if m != nil && m.Session != nil {
+		return *m.Session
+	}
+	return 0
+}
+
+func (m *ContextAction) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *ContextAction) GetAction() string {
+	if m != nil && m.Action != nil {
+		return *m.Action
+	}
+	return ""
+}
+
+// Lists the registered users.
+type UserList struct {
+	// A list of registered users.
+	Users                []*UserList_User `protobuf:"bytes,1,rep,name=users" json:"users,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *UserList) Reset()         { *m = UserList{} }
+func (m *UserList) String() string { return proto.CompactTextString(m) }
+func (*UserList) ProtoMessage()    {}
+func (*UserList) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{18}
+}
+
+func (m *UserList) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserList.Unmarshal(m, b)
+}
+func (m *UserList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserList.Marshal(b, m, deterministic)
+}
+func (m *UserList) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserList.Merge(m, src)
+}
+func (m *UserList) XXX_Size() int {
+	return xxx_messageInfo_UserList.Size(m)
+}
+func (m *UserList) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserList proto.InternalMessageInfo
+
+func (m *UserList) GetUsers() []*UserList_User {
+	if m != nil {
+		return m.Users
+	}
+	return nil
+}
+
+type UserList_User struct {
+	// Registered user ID.
+	UserId *uint32 `protobuf:"varint,1,req,name=user_id,json=userId" json:"user_id,omitempty"`
+	// Registered user name.
+	Name                 *string  `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+	LastSeen             *string  `protobuf:"bytes,3,opt,name=last_seen,json=lastSeen" json:"last_seen,omitempty"`
+	LastChannel          *uint32  `protobuf:"varint,4,opt,name=last_channel,json=lastChannel" json:"last_channel,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UserList_User) Reset()         { *m = UserList_User{} }
+func (m *UserList_User) String() string { return proto.CompactTextString(m) }
+func (*UserList_User) ProtoMessage()    {}
+func (*UserList_User) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{18, 0}
+}
+
+func (m *UserList_User) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserList_User.Unmarshal(m, b)
+}
+func (m *UserList_User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserList_User.Marshal(b, m, deterministic)
+}
+func (m *UserList_User) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserList_User.Merge(m, src)
+}
+func (m *UserList_User) XXX_Size() int {
+	return xxx_messageInfo_UserList_User.Size(m)
+}
+func (m *UserList_User) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserList_User.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserList_User proto.InternalMessageInfo
+
+func (m *UserList_User) GetUserId() uint32 {
+	if m != nil && m.UserId != nil {
+		return *m.UserId
+	}
+	return 0
+}
+
+func (m *UserList_User) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *UserList_User) GetLastSeen() string {
+	if m != nil && m.LastSeen != nil {
+		return *m.LastSeen
+	}
+	return ""
+}
+
+func (m *UserList_User) GetLastChannel() uint32 {
+	if m != nil && m.LastChannel != nil {
+		return *m.LastChannel
+	}
+	return 0
+}
+
+// Sent by the client when it wants to register or clear whisper targets.
+//
+// Note: The first available target ID is 1 as 0 is reserved for normal
+// talking. Maximum target ID is 30.
+type VoiceTarget struct {
+	// Voice target ID.
+	Id *uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
+	// The receivers that this voice target includes.
+	Targets              []*VoiceTarget_Target `protobuf:"bytes,2,rep,name=targets" json:"targets,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *VoiceTarget) Reset()         { *m = VoiceTarget{} }
+func (m *VoiceTarget) String() string { return proto.CompactTextString(m) }
+func (*VoiceTarget) ProtoMessage()    {}
+func (*VoiceTarget) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{19}
+}
+
+func (m *VoiceTarget) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VoiceTarget.Unmarshal(m, b)
+}
+func (m *VoiceTarget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VoiceTarget.Marshal(b, m, deterministic)
+}
+func (m *VoiceTarget) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VoiceTarget.Merge(m, src)
+}
+func (m *VoiceTarget) XXX_Size() int {
+	return xxx_messageInfo_VoiceTarget.Size(m)
+}
+func (m *VoiceTarget) XXX_DiscardUnknown() {
+	xxx_messageInfo_VoiceTarget.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VoiceTarget proto.InternalMessageInfo
+
+func (m *VoiceTarget) GetId() uint32 {
+	if m != nil && m.Id != nil {
+		return *m.Id
+	}
+	return 0
+}
+
+func (m *VoiceTarget) GetTargets() []*VoiceTarget_Target {
+	if m != nil {
+		return m.Targets
+	}
+	return nil
+}
+
+type VoiceTarget_Target struct {
+	// Users that are included as targets.
+	Session []uint32 `protobuf:"varint,1,rep,name=session" json:"session,omitempty"`
+	// Channel that is included as a target.
+	ChannelId *uint32 `protobuf:"varint,2,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// ACL group that is included as a target.
+	Group *string `protobuf:"bytes,3,opt,name=group" json:"group,omitempty"`
+	// True if the voice should follow links from the specified channel.
+	Links *bool `protobuf:"varint,4,opt,name=links,def=0" json:"links,omitempty"`
+	// True if the voice should also be sent to children of the specific
+	// channel.
+	Children             *bool    `protobuf:"varint,5,opt,name=children,def=0" json:"children,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *VoiceTarget_Target) Reset()         { *m = VoiceTarget_Target{} }
+func (m *VoiceTarget_Target) String() string { return proto.CompactTextString(m) }
+func (*VoiceTarget_Target) ProtoMessage()    {}
+func (*VoiceTarget_Target) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{19, 0}
+}
+
+func (m *VoiceTarget_Target) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VoiceTarget_Target.Unmarshal(m, b)
+}
+func (m *VoiceTarget_Target) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VoiceTarget_Target.Marshal(b, m, deterministic)
+}
+func (m *VoiceTarget_Target) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VoiceTarget_Target.Merge(m, src)
+}
+func (m *VoiceTarget_Target) XXX_Size() int {
+	return xxx_messageInfo_VoiceTarget_Target.Size(m)
+}
+func (m *VoiceTarget_Target) XXX_DiscardUnknown() {
+	xxx_messageInfo_VoiceTarget_Target.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VoiceTarget_Target proto.InternalMessageInfo
+
+const Default_VoiceTarget_Target_Links bool = false
+const Default_VoiceTarget_Target_Children bool = false
+
+func (m *VoiceTarget_Target) GetSession() []uint32 {
+	if m != nil {
+		return m.Session
+	}
+	return nil
+}
+
+func (m *VoiceTarget_Target) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *VoiceTarget_Target) GetGroup() string {
+	if m != nil && m.Group != nil {
+		return *m.Group
+	}
+	return ""
+}
+
+func (m *VoiceTarget_Target) GetLinks() bool {
+	if m != nil && m.Links != nil {
+		return *m.Links
+	}
+	return Default_VoiceTarget_Target_Links
+}
+
+func (m *VoiceTarget_Target) GetChildren() bool {
+	if m != nil && m.Children != nil {
+		return *m.Children
+	}
+	return Default_VoiceTarget_Target_Children
+}
+
+// Sent by the client when it wants permissions for a certain channel. Sent by
+// the server when it replies to the query or wants the user to resync all
+// channel permissions.
+type PermissionQuery struct {
+	// channel_id of the channel for which the permissions are queried.
+	ChannelId *uint32 `protobuf:"varint,1,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	// Channel permissions.
+	Permissions *uint32 `protobuf:"varint,2,opt,name=permissions" json:"permissions,omitempty"`
+	// True if the client should drop its current permission information for all
+	// channels.
+	Flush                *bool    `protobuf:"varint,3,opt,name=flush,def=0" json:"flush,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PermissionQuery) Reset()         { *m = PermissionQuery{} }
+func (m *PermissionQuery) String() string { return proto.CompactTextString(m) }
+func (*PermissionQuery) ProtoMessage()    {}
+func (*PermissionQuery) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{20}
+}
+
+func (m *PermissionQuery) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PermissionQuery.Unmarshal(m, b)
+}
+func (m *PermissionQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PermissionQuery.Marshal(b, m, deterministic)
+}
+func (m *PermissionQuery) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PermissionQuery.Merge(m, src)
+}
+func (m *PermissionQuery) XXX_Size() int {
+	return xxx_messageInfo_PermissionQuery.Size(m)
+}
+func (m *PermissionQuery) XXX_DiscardUnknown() {
+	xxx_messageInfo_PermissionQuery.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PermissionQuery proto.InternalMessageInfo
+
+const Default_PermissionQuery_Flush bool = false
+
+func (m *PermissionQuery) GetChannelId() uint32 {
+	if m != nil && m.ChannelId != nil {
+		return *m.ChannelId
+	}
+	return 0
+}
+
+func (m *PermissionQuery) GetPermissions() uint32 {
+	if m != nil && m.Permissions != nil {
+		return *m.Permissions
+	}
+	return 0
+}
+
+func (m *PermissionQuery) GetFlush() bool {
+	if m != nil && m.Flush != nil {
+		return *m.Flush
+	}
+	return Default_PermissionQuery_Flush
+}
+
+// Sent by the server to notify the users of the version of the CELT codec they
+// should use. This may change during the connection when new users join.
+type CodecVersion struct {
+	// The version of the CELT Alpha codec.
+	Alpha *int32 `protobuf:"varint,1,req,name=alpha" json:"alpha,omitempty"`
+	// The version of the CELT Beta codec.
+	Beta *int32 `protobuf:"varint,2,req,name=beta" json:"beta,omitempty"`
+	// True if the user should prefer Alpha over Beta.
+	PreferAlpha          *bool    `protobuf:"varint,3,req,name=prefer_alpha,json=preferAlpha,def=1" json:"prefer_alpha,omitempty"`
+	Opus                 *bool    `protobuf:"varint,4,opt,name=opus,def=0" json:"opus,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CodecVersion) Reset()         { *m = CodecVersion{} }
+func (m *CodecVersion) String() string { return proto.CompactTextString(m) }
+func (*CodecVersion) ProtoMessage()    {}
+func (*CodecVersion) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{21}
+}
+
+func (m *CodecVersion) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CodecVersion.Unmarshal(m, b)
+}
+func (m *CodecVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CodecVersion.Marshal(b, m, deterministic)
+}
+func (m *CodecVersion) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CodecVersion.Merge(m, src)
+}
+func (m *CodecVersion) XXX_Size() int {
+	return xxx_messageInfo_CodecVersion.Size(m)
+}
+func (m *CodecVersion) XXX_DiscardUnknown() {
+	xxx_messageInfo_CodecVersion.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CodecVersion proto.InternalMessageInfo
+
+const Default_CodecVersion_PreferAlpha bool = true
+const Default_CodecVersion_Opus bool = false
+
+func (m *CodecVersion) GetAlpha() int32 {
+	if m != nil && m.Alpha != nil {
+		return *m.Alpha
+	}
+	return 0
+}
+
+func (m *CodecVersion) GetBeta() int32 {
+	if m != nil && m.Beta != nil {
+		return *m.Beta
+	}
+	return 0
+}
+
+func (m *CodecVersion) GetPreferAlpha() bool {
+	if m != nil && m.PreferAlpha != nil {
+		return *m.PreferAlpha
+	}
+	return Default_CodecVersion_PreferAlpha
+}
+
+func (m *CodecVersion) GetOpus() bool {
+	if m != nil && m.Opus != nil {
+		return *m.Opus
+	}
+	return Default_CodecVersion_Opus
+}
+
+// Used to communicate user stats between the server and clients.
+type UserStats struct {
+	// User whose stats these are.
+	Session *uint32 `protobuf:"varint,1,opt,name=session" json:"session,omitempty"`
+	// True if the message contains only mutable stats (packets, ping).
+	StatsOnly *bool `protobuf:"varint,2,opt,name=stats_only,json=statsOnly,def=0" json:"stats_only,omitempty"`
+	// Full user certificate chain of the user certificate in DER format.
+	Certificates [][]byte `protobuf:"bytes,3,rep,name=certificates" json:"certificates,omitempty"`
+	// Packet statistics for packets received from the client.
+	FromClient *UserStats_Stats `protobuf:"bytes,4,opt,name=from_client,json=fromClient" json:"from_client,omitempty"`
+	// Packet statistics for packets sent by the server.
+	FromServer *UserStats_Stats `protobuf:"bytes,5,opt,name=from_server,json=fromServer" json:"from_server,omitempty"`
+	// Amount of UDP packets sent.
+	UdpPackets *uint32 `protobuf:"varint,6,opt,name=udp_packets,json=udpPackets" json:"udp_packets,omitempty"`
+	// Amount of TCP packets sent.
+	TcpPackets *uint32 `protobuf:"varint,7,opt,name=tcp_packets,json=tcpPackets" json:"tcp_packets,omitempty"`
+	// UDP ping average.
+	UdpPingAvg *float32 `protobuf:"fixed32,8,opt,name=udp_ping_avg,json=udpPingAvg" json:"udp_ping_avg,omitempty"`
+	// UDP ping variance.
+	UdpPingVar *float32 `protobuf:"fixed32,9,opt,name=udp_ping_var,json=udpPingVar" json:"udp_ping_var,omitempty"`
+	// TCP ping average.
+	TcpPingAvg *float32 `protobuf:"fixed32,10,opt,name=tcp_ping_avg,json=tcpPingAvg" json:"tcp_ping_avg,omitempty"`
+	// TCP ping variance.
+	TcpPingVar *float32 `protobuf:"fixed32,11,opt,name=tcp_ping_var,json=tcpPingVar" json:"tcp_ping_var,omitempty"`
+	// Client version.
+	Version *Version `protobuf:"bytes,12,opt,name=version" json:"version,omitempty"`
+	// A list of CELT bitstream version constants supported by the client of this
+	// user.
+	CeltVersions []int32 `protobuf:"varint,13,rep,name=celt_versions,json=celtVersions" json:"celt_versions,omitempty"`
+	// Client IP address.
+	Address []byte `protobuf:"bytes,14,opt,name=address" json:"address,omitempty"`
+	// Bandwith used by this client.
+	Bandwidth *uint32 `protobuf:"varint,15,opt,name=bandwidth" json:"bandwidth,omitempty"`
+	// Connection duration.
+	Onlinesecs *uint32 `protobuf:"varint,16,opt,name=onlinesecs" json:"onlinesecs,omitempty"`
+	// Duration since last activity.
+	Idlesecs *uint32 `protobuf:"varint,17,opt,name=idlesecs" json:"idlesecs,omitempty"`
+	// True if the user has a strong certificate.
+	StrongCertificate    *bool    `protobuf:"varint,18,opt,name=strong_certificate,json=strongCertificate,def=0" json:"strong_certificate,omitempty"`
+	Opus                 *bool    `protobuf:"varint,19,opt,name=opus,def=0" json:"opus,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UserStats) Reset()         { *m = UserStats{} }
+func (m *UserStats) String() string { return proto.CompactTextString(m) }
+func (*UserStats) ProtoMessage()    {}
+func (*UserStats) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{22}
+}
+
+func (m *UserStats) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserStats.Unmarshal(m, b)
+}
+func (m *UserStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserStats.Marshal(b, m, deterministic)
+}
+func (m *UserStats) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserStats.Merge(m, src)
+}
+func (m *UserStats) XXX_Size() int {
+	return xxx_messageInfo_UserStats.Size(m)
+}
+func (m *UserStats) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserStats.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserStats proto.InternalMessageInfo
+
+const Default_UserStats_StatsOnly bool = false
+const Default_UserStats_StrongCertificate bool = false
+const Default_UserStats_Opus bool = false
+
+func (m *UserStats) GetSession() uint32 {
+	if m != nil && m.Session != nil {
+		return *m.Session
+	}
+	return 0
+}
+
+func (m *UserStats) GetStatsOnly() bool {
+	if m != nil && m.StatsOnly != nil {
+		return *m.StatsOnly
+	}
+	return Default_UserStats_StatsOnly
+}
+
+func (m *UserStats) GetCertificates() [][]byte {
+	if m != nil {
+		return m.Certificates
+	}
+	return nil
+}
+
+func (m *UserStats) GetFromClient() *UserStats_Stats {
+	if m != nil {
+		return m.FromClient
+	}
+	return nil
+}
+
+func (m *UserStats) GetFromServer() *UserStats_Stats {
+	if m != nil {
+		return m.FromServer
+	}
+	return nil
+}
+
+func (m *UserStats) GetUdpPackets() uint32 {
+	if m != nil && m.UdpPackets != nil {
+		return *m.UdpPackets
+	}
+	return 0
+}
+
+func (m *UserStats) GetTcpPackets() uint32 {
+	if m != nil && m.TcpPackets != nil {
+		return *m.TcpPackets
+	}
+	return 0
+}
+
+func (m *UserStats) GetUdpPingAvg() float32 {
+	if m != nil && m.UdpPingAvg != nil {
+		return *m.UdpPingAvg
+	}
+	return 0
+}
+
+func (m *UserStats) GetUdpPingVar() float32 {
+	if m != nil && m.UdpPingVar != nil {
+		return *m.UdpPingVar
+	}
+	return 0
+}
+
+func (m *UserStats) GetTcpPingAvg() float32 {
+	if m != nil && m.TcpPingAvg != nil {
+		return *m.TcpPingAvg
+	}
+	return 0
+}
+
+func (m *UserStats) GetTcpPingVar() float32 {
+	if m != nil && m.TcpPingVar != nil {
+		return *m.TcpPingVar
+	}
+	return 0
+}
+
+func (m *UserStats) GetVersion() *Version {
+	if m != nil {
+		return m.Version
+	}
+	return nil
+}
+
+func (m *UserStats) GetCeltVersions() []int32 {
+	if m != nil {
+		return m.CeltVersions
+	}
+	return nil
+}
+
+func (m *UserStats) GetAddress() []byte {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+func (m *UserStats) GetBandwidth() uint32 {
+	if m != nil && m.Bandwidth != nil {
+		return *m.Bandwidth
+	}
+	return 0
+}
+
+func (m *UserStats) GetOnlinesecs() uint32 {
+	if m != nil && m.Onlinesecs != nil {
+		return *m.Onlinesecs
+	}
+	return 0
+}
+
+func (m *UserStats) GetIdlesecs() uint32 {
+	if m != nil && m.Idlesecs != nil {
+		return *m.Idlesecs
+	}
+	return 0
+}
+
+func (m *UserStats) GetStrongCertificate() bool {
+	if m != nil && m.StrongCertificate != nil {
+		return *m.StrongCertificate
+	}
+	return Default_UserStats_StrongCertificate
+}
+
+func (m *UserStats) GetOpus() bool {
+	if m != nil && m.Opus != nil {
+		return *m.Opus
+	}
+	return Default_UserStats_Opus
+}
+
+type UserStats_Stats struct {
+	// The amount of good packets received.
+	Good *uint32 `protobuf:"varint,1,opt,name=good" json:"good,omitempty"`
+	// The amount of late packets received.
+	Late *uint32 `protobuf:"varint,2,opt,name=late" json:"late,omitempty"`
+	// The amount of packets never received.
+	Lost *uint32 `protobuf:"varint,3,opt,name=lost" json:"lost,omitempty"`
+	// The amount of nonce resyncs.
+	Resync               *uint32  `protobuf:"varint,4,opt,name=resync" json:"resync,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UserStats_Stats) Reset()         { *m = UserStats_Stats{} }
+func (m *UserStats_Stats) String() string { return proto.CompactTextString(m) }
+func (*UserStats_Stats) ProtoMessage()    {}
+func (*UserStats_Stats) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{22, 0}
+}
+
+func (m *UserStats_Stats) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserStats_Stats.Unmarshal(m, b)
+}
+func (m *UserStats_Stats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserStats_Stats.Marshal(b, m, deterministic)
+}
+func (m *UserStats_Stats) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserStats_Stats.Merge(m, src)
+}
+func (m *UserStats_Stats) XXX_Size() int {
+	return xxx_messageInfo_UserStats_Stats.Size(m)
+}
+func (m *UserStats_Stats) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserStats_Stats.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserStats_Stats proto.InternalMessageInfo
+
+func (m *UserStats_Stats) GetGood() uint32 {
+	if m != nil && m.Good != nil {
+		return *m.Good
+	}
+	return 0
+}
+
+func (m *UserStats_Stats) GetLate() uint32 {
+	if m != nil && m.Late != nil {
+		return *m.Late
+	}
+	return 0
+}
+
+func (m *UserStats_Stats) GetLost() uint32 {
+	if m != nil && m.Lost != nil {
+		return *m.Lost
+	}
+	return 0
+}
+
+func (m *UserStats_Stats) GetResync() uint32 {
+	if m != nil && m.Resync != nil {
+		return *m.Resync
+	}
+	return 0
+}
+
+// Used by the client to request binary data from the server. By default large
+// comments or textures are not sent within standard messages but instead the
+// hash is. If the client does not recognize the hash it may request the
+// resource when it needs it. The client does so by sending a RequestBlob
+// message with the correct fields filled with the user sessions or channel_ids
+// it wants to receive. The server replies to this by sending a new
+// UserState/ChannelState message with the resources filled even if they would
+// normally be transmitted as hashes.
+type RequestBlob struct {
+	// sessions of the requested UserState textures.
+	SessionTexture []uint32 `protobuf:"varint,1,rep,name=session_texture,json=sessionTexture" json:"session_texture,omitempty"`
+	// sessions of the requested UserState comments.
+	SessionComment []uint32 `protobuf:"varint,2,rep,name=session_comment,json=sessionComment" json:"session_comment,omitempty"`
+	// channel_ids of the requested ChannelState descriptions.
+	ChannelDescription   []uint32 `protobuf:"varint,3,rep,name=channel_description,json=channelDescription" json:"channel_description,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *RequestBlob) Reset()         { *m = RequestBlob{} }
+func (m *RequestBlob) String() string { return proto.CompactTextString(m) }
+func (*RequestBlob) ProtoMessage()    {}
+func (*RequestBlob) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{23}
+}
+
+func (m *RequestBlob) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RequestBlob.Unmarshal(m, b)
+}
+func (m *RequestBlob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RequestBlob.Marshal(b, m, deterministic)
+}
+func (m *RequestBlob) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RequestBlob.Merge(m, src)
+}
+func (m *RequestBlob) XXX_Size() int {
+	return xxx_messageInfo_RequestBlob.Size(m)
+}
+func (m *RequestBlob) XXX_DiscardUnknown() {
+	xxx_messageInfo_RequestBlob.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RequestBlob proto.InternalMessageInfo
+
+func (m *RequestBlob) GetSessionTexture() []uint32 {
+	if m != nil {
+		return m.SessionTexture
+	}
+	return nil
+}
+
+func (m *RequestBlob) GetSessionComment() []uint32 {
+	if m != nil {
+		return m.SessionComment
+	}
+	return nil
+}
+
+func (m *RequestBlob) GetChannelDescription() []uint32 {
+	if m != nil {
+		return m.ChannelDescription
+	}
+	return nil
+}
+
+// Sent by the server when it informs the clients on server configuration
+// details.
+type ServerConfig struct {
+	// The maximum bandwidth the clients should use.
+	MaxBandwidth *uint32 `protobuf:"varint,1,opt,name=max_bandwidth,json=maxBandwidth" json:"max_bandwidth,omitempty"`
+	// Server welcome text.
+	WelcomeText *string `protobuf:"bytes,2,opt,name=welcome_text,json=welcomeText" json:"welcome_text,omitempty"`
+	// True if the server allows HTML.
+	AllowHtml *bool `protobuf:"varint,3,opt,name=allow_html,json=allowHtml" json:"allow_html,omitempty"`
+	// Maximum text message length.
+	MessageLength *uint32 `protobuf:"varint,4,opt,name=message_length,json=messageLength" json:"message_length,omitempty"`
+	// Maximum image message length.
+	ImageMessageLength *uint32 `protobuf:"varint,5,opt,name=image_message_length,json=imageMessageLength" json:"image_message_length,omitempty"`
+	// The maximum number of users allowed on the server.
+	MaxUsers             *uint32  `protobuf:"varint,6,opt,name=max_users,json=maxUsers" json:"max_users,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ServerConfig) Reset()         { *m = ServerConfig{} }
+func (m *ServerConfig) String() string { return proto.CompactTextString(m) }
+func (*ServerConfig) ProtoMessage()    {}
+func (*ServerConfig) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{24}
+}
+
+func (m *ServerConfig) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ServerConfig.Unmarshal(m, b)
+}
+func (m *ServerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ServerConfig.Marshal(b, m, deterministic)
+}
+func (m *ServerConfig) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ServerConfig.Merge(m, src)
+}
+func (m *ServerConfig) XXX_Size() int {
+	return xxx_messageInfo_ServerConfig.Size(m)
+}
+func (m *ServerConfig) XXX_DiscardUnknown() {
+	xxx_messageInfo_ServerConfig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServerConfig proto.InternalMessageInfo
+
+func (m *ServerConfig) GetMaxBandwidth() uint32 {
+	if m != nil && m.MaxBandwidth != nil {
+		return *m.MaxBandwidth
+	}
+	return 0
+}
+
+func (m *ServerConfig) GetWelcomeText() string {
+	if m != nil && m.WelcomeText != nil {
+		return *m.WelcomeText
+	}
+	return ""
+}
+
+func (m *ServerConfig) GetAllowHtml() bool {
+	if m != nil && m.AllowHtml != nil {
+		return *m.AllowHtml
+	}
+	return false
+}
+
+func (m *ServerConfig) GetMessageLength() uint32 {
+	if m != nil && m.MessageLength != nil {
+		return *m.MessageLength
+	}
+	return 0
+}
+
+func (m *ServerConfig) GetImageMessageLength() uint32 {
+	if m != nil && m.ImageMessageLength != nil {
+		return *m.ImageMessageLength
+	}
+	return 0
+}
+
+func (m *ServerConfig) GetMaxUsers() uint32 {
+	if m != nil && m.MaxUsers != nil {
+		return *m.MaxUsers
+	}
+	return 0
+}
+
+// Sent by the server to inform the clients of suggested client configuration
+// specified by the server administrator.
+type SuggestConfig struct {
+	// Suggested client version.
+	Version *uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
+	// True if the administrator suggests positional audio to be used on this
+	// server.
+	Positional *bool `protobuf:"varint,2,opt,name=positional" json:"positional,omitempty"`
+	// True if the administrator suggests push to talk to be used on this server.
+	PushToTalk           *bool    `protobuf:"varint,3,opt,name=push_to_talk,json=pushToTalk" json:"push_to_talk,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SuggestConfig) Reset()         { *m = SuggestConfig{} }
+func (m *SuggestConfig) String() string { return proto.CompactTextString(m) }
+func (*SuggestConfig) ProtoMessage()    {}
+func (*SuggestConfig) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56c09c2dce0fb003, []int{25}
+}
+
+func (m *SuggestConfig) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SuggestConfig.Unmarshal(m, b)
+}
+func (m *SuggestConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SuggestConfig.Marshal(b, m, deterministic)
+}
+func (m *SuggestConfig) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SuggestConfig.Merge(m, src)
+}
+func (m *SuggestConfig) XXX_Size() int {
+	return xxx_messageInfo_SuggestConfig.Size(m)
+}
+func (m *SuggestConfig) XXX_DiscardUnknown() {
+	xxx_messageInfo_SuggestConfig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SuggestConfig proto.InternalMessageInfo
+
+func (m *SuggestConfig) GetVersion() uint32 {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return 0
+}
+
+func (m *SuggestConfig) GetPositional() bool {
+	if m != nil && m.Positional != nil {
+		return *m.Positional
+	}
+	return false
+}
+
+func (m *SuggestConfig) GetPushToTalk() bool {
+	if m != nil && m.PushToTalk != nil {
+		return *m.PushToTalk
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterEnum("MumbleProto.Reject_RejectType", Reject_RejectType_name, Reject_RejectType_value)
+	proto.RegisterEnum("MumbleProto.PermissionDenied_DenyType", PermissionDenied_DenyType_name, PermissionDenied_DenyType_value)
+	proto.RegisterEnum("MumbleProto.ContextActionModify_Context", ContextActionModify_Context_name, ContextActionModify_Context_value)
+	proto.RegisterEnum("MumbleProto.ContextActionModify_Operation", ContextActionModify_Operation_name, ContextActionModify_Operation_value)
+	proto.RegisterType((*Version)(nil), "MumbleProto.Version")
+	proto.RegisterType((*UDPTunnel)(nil), "MumbleProto.UDPTunnel")
+	proto.RegisterType((*Authenticate)(nil), "MumbleProto.Authenticate")
+	proto.RegisterType((*Ping)(nil), "MumbleProto.Ping")
+	proto.RegisterType((*Reject)(nil), "MumbleProto.Reject")
+	proto.RegisterType((*ServerSync)(nil), "MumbleProto.ServerSync")
+	proto.RegisterType((*ChannelRemove)(nil), "MumbleProto.ChannelRemove")
+	proto.RegisterType((*ChannelState)(nil), "MumbleProto.ChannelState")
+	proto.RegisterType((*UserRemove)(nil), "MumbleProto.UserRemove")
+	proto.RegisterType((*UserState)(nil), "MumbleProto.UserState")
+	proto.RegisterType((*BanList)(nil), "MumbleProto.BanList")
+	proto.RegisterType((*BanList_BanEntry)(nil), "MumbleProto.BanList.BanEntry")
+	proto.RegisterType((*TextMessage)(nil), "MumbleProto.TextMessage")
+	proto.RegisterType((*PermissionDenied)(nil), "MumbleProto.PermissionDenied")
+	proto.RegisterType((*ACL)(nil), "MumbleProto.ACL")
+	proto.RegisterType((*ACL_ChanGroup)(nil), "MumbleProto.ACL.ChanGroup")
+	proto.RegisterType((*ACL_ChanACL)(nil), "MumbleProto.ACL.ChanACL")
+	proto.RegisterType((*QueryUsers)(nil), "MumbleProto.QueryUsers")
+	proto.RegisterType((*CryptSetup)(nil), "MumbleProto.CryptSetup")
+	proto.RegisterType((*ContextActionModify)(nil), "MumbleProto.ContextActionModify")
+	proto.RegisterType((*ContextAction)(nil), "MumbleProto.ContextAction")
+	proto.RegisterType((*UserList)(nil), "MumbleProto.UserList")
+	proto.RegisterType((*UserList_User)(nil), "MumbleProto.UserList.User")
+	proto.RegisterType((*VoiceTarget)(nil), "MumbleProto.VoiceTarget")
+	proto.RegisterType((*VoiceTarget_Target)(nil), "MumbleProto.VoiceTarget.Target")
+	proto.RegisterType((*PermissionQuery)(nil), "MumbleProto.PermissionQuery")
+	proto.RegisterType((*CodecVersion)(nil), "MumbleProto.CodecVersion")
+	proto.RegisterType((*UserStats)(nil), "MumbleProto.UserStats")
+	proto.RegisterType((*UserStats_Stats)(nil), "MumbleProto.UserStats.Stats")
+	proto.RegisterType((*RequestBlob)(nil), "MumbleProto.RequestBlob")
+	proto.RegisterType((*ServerConfig)(nil), "MumbleProto.ServerConfig")
+	proto.RegisterType((*SuggestConfig)(nil), "MumbleProto.SuggestConfig")
+}
+
+func init() { proto.RegisterFile("Mumble.proto", fileDescriptor_56c09c2dce0fb003) }
+
+var fileDescriptor_56c09c2dce0fb003 = []byte{
+	// 2523 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4f, 0x6f, 0x24, 0x47,
+	0x15, 0x4f, 0xcf, 0xff, 0x79, 0x33, 0x63, 0xb7, 0x6b, 0x9d, 0x64, 0x70, 0xb2, 0x89, 0xd3, 0x0b,
+	0x89, 0x03, 0x91, 0x09, 0x56, 0x84, 0x94, 0x48, 0x1c, 0xbc, 0xde, 0x04, 0xaf, 0xb0, 0x37, 0x4b,
+	0xdb, 0xd9, 0x1c, 0x38, 0x34, 0xe5, 0xee, 0xf2, 0x4c, 0xe3, 0x9e, 0xee, 0x4e, 0x55, 0xb5, 0x77,
+	0x47, 0xe2, 0x08, 0x5c, 0xc9, 0x8d, 0x1b, 0x1f, 0x20, 0x87, 0x48, 0x7c, 0x05, 0x3e, 0x01, 0x07,
+	0x3e, 0x01, 0xe2, 0xc6, 0x0d, 0x89, 0x3b, 0x7a, 0xaf, 0xaa, 0xff, 0x79, 0x9d, 0x6c, 0xb8, 0x72,
+	0x99, 0xa9, 0xf7, 0x7b, 0xbf, 0xfa, 0xd3, 0x55, 0xef, 0x5f, 0x15, 0x4c, 0x4f, 0x8b, 0xd5, 0x45,
+	0x22, 0xf6, 0x73, 0x99, 0xe9, 0x8c, 0x4d, 0x8c, 0xf4, 0x18, 0x05, 0x2f, 0x81, 0xe1, 0x13, 0x21,
+	0x55, 0x9c, 0xa5, 0x6c, 0x0e, 0xc3, 0x6b, 0xd3, 0x9c, 0x3b, 0xbb, 0xce, 0xde, 0xcc, 0x2f, 0x45,
+	0xd4, 0x48, 0x91, 0x08, 0xae, 0xc4, 0xbc, 0xb3, 0xeb, 0xec, 0x8d, 0xfd, 0x52, 0x64, 0x1b, 0xd0,
+	0xc9, 0xd4, 0xbc, 0x4b, 0x60, 0x27, 0x53, 0xec, 0x2e, 0x40, 0xa6, 0x82, 0x72, 0x98, 0x1e, 0xe1,
+	0xe3, 0x4c, 0xd9, 0x29, 0xbc, 0x7b, 0x30, 0xfe, 0xec, 0xc1, 0xe3, 0xf3, 0x22, 0x4d, 0x45, 0xc2,
+	0x5e, 0x81, 0x41, 0xce, 0xc3, 0x2b, 0xa1, 0xe7, 0xce, 0x6e, 0x67, 0x6f, 0xea, 0x5b, 0xc9, 0xfb,
+	0xb3, 0x03, 0xd3, 0xc3, 0x42, 0x2f, 0x45, 0xaa, 0xe3, 0x90, 0x6b, 0xc1, 0x76, 0x60, 0x54, 0x28,
+	0x21, 0x53, 0xbe, 0x12, 0xb4, 0xb2, 0xb1, 0x5f, 0xc9, 0xa8, 0xcb, 0xb9, 0x52, 0x4f, 0x33, 0x19,
+	0xd9, 0xb5, 0x55, 0x32, 0x4e, 0xa0, 0xb3, 0x2b, 0x91, 0xe2, 0x02, 0xbb, 0x7b, 0x63, 0xdf, 0x4a,
+	0xec, 0x1e, 0xcc, 0x42, 0x91, 0xe8, 0x72, 0x99, 0x6a, 0xde, 0xdb, 0xed, 0xee, 0xf5, 0xfd, 0x29,
+	0x82, 0x76, 0xa5, 0x8a, 0x7d, 0x0f, 0x7a, 0x59, 0x5e, 0xa8, 0x79, 0x7f, 0xd7, 0xd9, 0x1b, 0x7d,
+	0xd4, 0xbf, 0xe4, 0x89, 0x12, 0x3e, 0x41, 0xde, 0x5f, 0x3b, 0xd0, 0x7b, 0x1c, 0xa7, 0x0b, 0xf6,
+	0x3a, 0x8c, 0x75, 0xbc, 0x12, 0x4a, 0xf3, 0x55, 0x4e, 0x2b, 0xeb, 0xf9, 0x35, 0xc0, 0x18, 0xf4,
+	0x16, 0x59, 0x66, 0x96, 0x35, 0xf3, 0xa9, 0x8d, 0x58, 0xc2, 0xb5, 0xa0, 0x1d, 0x9b, 0xf9, 0xd4,
+	0x26, 0x2c, 0x53, 0x9a, 0x76, 0x0b, 0xb1, 0x4c, 0x69, 0x5c, 0xba, 0x14, 0x6a, 0x9d, 0x86, 0x34,
+	0xff, 0xcc, 0xb7, 0x12, 0x7b, 0x13, 0x26, 0x45, 0x94, 0x07, 0x66, 0xa7, 0xd4, 0x7c, 0x40, 0x4a,
+	0x28, 0xa2, 0xfc, 0xb1, 0x41, 0x90, 0xa0, 0xc3, 0x9a, 0x30, 0x34, 0x04, 0x1d, 0x56, 0x84, 0x5d,
+	0x98, 0xd2, 0x08, 0x71, 0xba, 0x08, 0xf8, 0xf5, 0x62, 0x3e, 0xda, 0x75, 0xf6, 0x3a, 0x66, 0x88,
+	0x38, 0x5d, 0x1c, 0x5e, 0x2f, 0x5a, 0x8c, 0x6b, 0x2e, 0xe7, 0xe3, 0x16, 0xe3, 0x09, 0x97, 0xc8,
+	0xa0, 0x49, 0xca, 0x31, 0xc0, 0x30, 0x70, 0x96, 0x7a, 0x8c, 0x8a, 0x81, 0x63, 0x4c, 0x5a, 0x8c,
+	0x27, 0x5c, 0x7a, 0xbf, 0xef, 0xc0, 0xc0, 0x17, 0xbf, 0x11, 0xa1, 0x66, 0x07, 0xd0, 0xd3, 0xeb,
+	0xdc, 0x9c, 0xed, 0xc6, 0xc1, 0x1b, 0xfb, 0x0d, 0xfb, 0xdc, 0x37, 0x14, 0xfb, 0x77, 0xbe, 0xce,
+	0x85, 0x4f, 0x5c, 0xb3, 0x41, 0x5c, 0x65, 0xa9, 0x3d, 0x75, 0x2b, 0x79, 0x5f, 0x3b, 0x00, 0x35,
+	0x99, 0x8d, 0xa0, 0xf7, 0x28, 0x4b, 0x85, 0xfb, 0x12, 0x73, 0x61, 0xfa, 0xb9, 0xcc, 0xd2, 0x85,
+	0x3d, 0x60, 0xd7, 0x61, 0x77, 0x60, 0xf3, 0x61, 0x7a, 0xcd, 0x93, 0x38, 0xfa, 0xcc, 0x5a, 0x93,
+	0xdb, 0x61, 0x9b, 0x30, 0x21, 0x1a, 0x42, 0x8f, 0x3f, 0x77, 0xbb, 0x6c, 0x0b, 0x66, 0x04, 0x9c,
+	0x09, 0x79, 0x4d, 0x50, 0x0f, 0xa1, 0xb2, 0xc7, 0xc3, 0xf4, 0x33, 0x25, 0xdc, 0x3e, 0xdb, 0x00,
+	0x30, 0x84, 0x4f, 0x8a, 0x24, 0x71, 0x07, 0x48, 0x79, 0x94, 0x1d, 0x09, 0xa9, 0xe3, 0x4b, 0xb2,
+	0x61, 0x77, 0xc8, 0x5e, 0x86, 0xad, 0x86, 0x55, 0x67, 0xf2, 0x13, 0x1e, 0x27, 0xee, 0xc8, 0xfb,
+	0xd2, 0x29, 0xbb, 0x9e, 0xe1, 0x01, 0xcf, 0x61, 0xa8, 0x84, 0x6a, 0x3a, 0xa1, 0x15, 0xd1, 0x6a,
+	0x57, 0xfc, 0x59, 0x70, 0xc1, 0xd3, 0xe8, 0x69, 0x1c, 0xe9, 0xa5, 0xb5, 0xab, 0xe9, 0x8a, 0x3f,
+	0xbb, 0x5f, 0x62, 0xec, 0x2d, 0x98, 0x3e, 0x15, 0x49, 0x98, 0xad, 0x44, 0xa0, 0xc5, 0x33, 0x6d,
+	0x3d, 0x73, 0x62, 0xb1, 0x73, 0xf1, 0x4c, 0xb3, 0x5d, 0x98, 0xe4, 0x42, 0xae, 0x62, 0x55, 0xda,
+	0x3e, 0x9a, 0x6d, 0x13, 0xf2, 0xf6, 0x61, 0x76, 0xb4, 0xe4, 0xe8, 0xa3, 0xbe, 0x58, 0x65, 0xd7,
+	0x02, 0xbd, 0x3a, 0x34, 0x40, 0x10, 0x47, 0xe4, 0xad, 0x33, 0x7f, 0x6c, 0x91, 0x87, 0x91, 0xf7,
+	0x55, 0x17, 0xa6, 0xb6, 0xc3, 0x99, 0x46, 0x8b, 0xbe, 0xc9, 0x77, 0x5a, 0x7c, 0xe3, 0xf8, 0x52,
+	0xa4, 0xda, 0x7e, 0x82, 0x95, 0xd0, 0x11, 0xc8, 0xc7, 0xcd, 0xa2, 0xa9, 0xcd, 0xb6, 0xa1, 0x9f,
+	0xc4, 0xe9, 0x95, 0xf1, 0xd1, 0x99, 0x6f, 0x04, 0xfc, 0x86, 0x48, 0xa8, 0x50, 0xc6, 0xb9, 0xc6,
+	0x9d, 0xea, 0x9b, 0xaf, 0x6c, 0x40, 0xec, 0x35, 0x18, 0x13, 0x35, 0xe0, 0x51, 0x34, 0x1f, 0x50,
+	0xdf, 0x11, 0x01, 0x87, 0x51, 0x84, 0xbb, 0x64, 0x94, 0x92, 0xbe, 0x6f, 0x3e, 0x24, 0xfd, 0x84,
+	0x30, 0xfb, 0xc9, 0xf7, 0x60, 0xac, 0xc5, 0x2a, 0xcf, 0x24, 0x97, 0x6b, 0xf2, 0x91, 0x2a, 0x06,
+	0xd4, 0x38, 0xbb, 0x0b, 0xa3, 0x3c, 0x53, 0x31, 0xad, 0x01, 0xbd, 0xa4, 0xff, 0x91, 0xf3, 0xbe,
+	0x5f, 0x41, 0xec, 0x5d, 0x70, 0x1b, 0x4b, 0x0a, 0x96, 0x5c, 0x2d, 0xc9, 0x55, 0xa6, 0xfe, 0x66,
+	0x03, 0x3f, 0xe6, 0x6a, 0x89, 0xcb, 0xc5, 0xc3, 0xc5, 0xb0, 0xa6, 0xc8, 0x59, 0x66, 0xfe, 0x68,
+	0xc5, 0x9f, 0xa1, 0x99, 0x29, 0xb6, 0x0f, 0x77, 0x62, 0x15, 0x88, 0x54, 0x0b, 0x19, 0x48, 0xa1,
+	0xb4, 0x8c, 0x43, 0x2d, 0xa2, 0xf9, 0x14, 0x57, 0xe5, 0x6f, 0xc5, 0xea, 0x63, 0xd4, 0xf8, 0x95,
+	0x02, 0x07, 0x0b, 0x79, 0x6a, 0x3a, 0xcc, 0x67, 0xc4, 0x1a, 0x85, 0x3c, 0x25, 0x9a, 0x77, 0x09,
+	0x80, 0xa3, 0xda, 0xcf, 0x6c, 0x99, 0x5b, 0xa7, 0x69, 0x6e, 0xdb, 0xd0, 0xe7, 0xa1, 0xce, 0xa4,
+	0x3d, 0x23, 0x23, 0x34, 0xdc, 0xae, 0xdb, 0x74, 0x3b, 0xe6, 0x42, 0xf7, 0x82, 0x9b, 0x80, 0x3f,
+	0xf2, 0xb1, 0xe9, 0xfd, 0xb3, 0x07, 0x63, 0x9c, 0xc8, 0x58, 0xc4, 0x37, 0x9b, 0xf5, 0xed, 0xf3,
+	0xdc, 0x66, 0x0a, 0xaf, 0xc2, 0x10, 0xf7, 0x07, 0x4d, 0xca, 0x84, 0xca, 0x01, 0x8a, 0x0f, 0xa3,
+	0x1b, 0xe6, 0xd6, 0xbf, 0x69, 0x6e, 0x0c, 0x7a, 0xab, 0x42, 0x0b, 0x0a, 0x96, 0x23, 0x9f, 0xda,
+	0x88, 0x45, 0x82, 0x5f, 0x52, 0x7c, 0x1c, 0xf9, 0xd4, 0xc6, 0x54, 0xa2, 0x8a, 0x3c, 0x97, 0x42,
+	0x29, 0x73, 0xe2, 0x7e, 0x25, 0xe3, 0x96, 0x2a, 0x91, 0x5c, 0x06, 0x34, 0xd0, 0xd8, 0x2a, 0x45,
+	0x72, 0x79, 0x8a, 0x83, 0x95, 0x4a, 0x1a, 0x11, 0x6a, 0xe5, 0x03, 0x1c, 0x75, 0x0e, 0x43, 0xf4,
+	0xc4, 0x42, 0x0a, 0x3a, 0xd7, 0xa9, 0x5f, 0x8a, 0xec, 0x07, 0xb0, 0x91, 0x27, 0xc5, 0x22, 0x4e,
+	0x83, 0x30, 0x4b, 0xc9, 0x5b, 0xa7, 0x44, 0x98, 0x19, 0xf4, 0xc8, 0x80, 0xec, 0x1d, 0xd8, 0xb4,
+	0xb4, 0x38, 0xc2, 0xe0, 0xa1, 0xd7, 0x74, 0xa6, 0x63, 0xdf, 0xf6, 0x7e, 0x68, 0x51, 0x9c, 0x29,
+	0xcc, 0x56, 0x2b, 0xf4, 0xab, 0x0d, 0x93, 0xa5, 0xad, 0x88, 0x5f, 0x4b, 0xc6, 0xb7, 0x69, 0x76,
+	0x13, 0xdb, 0xe8, 0x03, 0x56, 0x6d, 0x0c, 0xd3, 0xa5, 0xb9, 0x27, 0x16, 0x3b, 0xb6, 0x14, 0xbb,
+	0x56, 0x43, 0xd9, 0x32, 0x14, 0x8b, 0x11, 0xe5, 0x5d, 0x70, 0x73, 0x19, 0x67, 0x32, 0xd6, 0xeb,
+	0x40, 0xe5, 0x82, 0x5f, 0x09, 0x39, 0x67, 0xb4, 0x03, 0x9b, 0x25, 0x7e, 0x66, 0x60, 0x4c, 0x96,
+	0x52, 0x84, 0x99, 0x8c, 0xe2, 0x74, 0x31, 0xbf, 0x43, 0x9c, 0x1a, 0x60, 0x3f, 0x85, 0x57, 0x2b,
+	0xbf, 0x0a, 0x78, 0x18, 0x0a, 0xa5, 0x02, 0x9b, 0xbc, 0xb7, 0x29, 0x79, 0xbf, 0x5c, 0xa9, 0x0f,
+	0x49, 0x7b, 0x4e, 0x4a, 0xef, 0x0f, 0x1d, 0x18, 0xde, 0xe7, 0xe9, 0x49, 0xac, 0x34, 0xfb, 0x09,
+	0xf4, 0x2e, 0x78, 0xaa, 0xe6, 0xce, 0x6e, 0x77, 0x6f, 0x72, 0x70, 0xb7, 0x95, 0x47, 0x2c, 0x07,
+	0xff, 0x3f, 0x4e, 0xb5, 0x5c, 0xfb, 0x44, 0x65, 0xaf, 0x41, 0xff, 0x8b, 0x42, 0xc8, 0x35, 0x59,
+	0x5f, 0xe5, 0xe2, 0x06, 0xdb, 0xf9, 0xca, 0x81, 0x51, 0xc9, 0xc7, 0xdd, 0xe5, 0x51, 0x44, 0xc6,
+	0x61, 0xca, 0x95, 0x52, 0x24, 0xfb, 0xe2, 0xea, 0x6a, 0xde, 0x21, 0x07, 0xa2, 0xf6, 0xad, 0xf6,
+	0x5b, 0x9e, 0x42, 0xaf, 0x71, 0x0a, 0xb5, 0x3f, 0xf5, 0x5b, 0xfe, 0xb4, 0x0d, 0x7d, 0xa5, 0xb9,
+	0xd4, 0x64, 0xb4, 0x63, 0xdf, 0x08, 0x68, 0xa1, 0x51, 0x21, 0x39, 0xc5, 0x1b, 0x93, 0xd9, 0x2b,
+	0xd9, 0xfb, 0xa3, 0x03, 0x13, 0x8c, 0xef, 0xa7, 0x42, 0x29, 0xbe, 0x10, 0xb5, 0x5f, 0x39, 0x4d,
+	0xbf, 0x6a, 0xf8, 0x61, 0x87, 0x82, 0x5e, 0xe5, 0x87, 0x6d, 0x27, 0xea, 0x92, 0xb2, 0xe1, 0x44,
+	0xaf, 0xc2, 0x50, 0x4b, 0x21, 0x8c, 0xf3, 0xa1, 0x6e, 0x80, 0xe2, 0xc3, 0x08, 0x47, 0x5c, 0x99,
+	0x29, 0xe7, 0xfd, 0xdd, 0x0e, 0x5a, 0x9d, 0x15, 0x31, 0x2d, 0xb8, 0x8f, 0xab, 0xb4, 0xf2, 0x40,
+	0xa4, 0xb1, 0x88, 0xd8, 0x1b, 0x00, 0x75, 0xaa, 0xb1, 0x6b, 0x6b, 0x20, 0x37, 0x96, 0xd1, 0xb9,
+	0xe9, 0xcb, 0x8d, 0xf5, 0x77, 0xdb, 0x71, 0xa4, 0xde, 0xc9, 0x5e, 0x6b, 0x27, 0x3f, 0xb2, 0xc5,
+	0x45, 0x9f, 0x8a, 0x8b, 0xb7, 0x5b, 0x46, 0x71, 0x73, 0x75, 0xfb, 0x0f, 0x44, 0xba, 0x6e, 0x14,
+	0x19, 0xe5, 0x29, 0x0e, 0xea, 0x53, 0xf4, 0xfe, 0xee, 0xc0, 0xa8, 0xa4, 0x61, 0x79, 0x81, 0x7b,
+	0xee, 0xbe, 0x84, 0x05, 0x40, 0x3d, 0x9a, 0xeb, 0xb0, 0x19, 0x8c, 0xcf, 0x8a, 0x5c, 0x48, 0x0c,
+	0x81, 0xa6, 0xac, 0xb0, 0x19, 0xf2, 0x11, 0xd6, 0x19, 0x5d, 0x04, 0xb0, 0xe7, 0x79, 0x96, 0x9d,
+	0x64, 0xe9, 0xc2, 0xed, 0xb1, 0x21, 0x74, 0x8f, 0x3f, 0xfc, 0x85, 0xdb, 0x67, 0xdb, 0xe0, 0x9e,
+	0x97, 0xa6, 0x6e, 0xfb, 0xb8, 0x03, 0xf6, 0x0a, 0xb0, 0x53, 0x1c, 0x3c, 0x5d, 0xb4, 0xab, 0x8a,
+	0x29, 0x8c, 0x70, 0x0a, 0x1a, 0x75, 0xd4, 0x98, 0x86, 0xea, 0x90, 0x31, 0x56, 0x3d, 0x8f, 0x84,
+	0xd2, 0x71, 0xba, 0x38, 0x89, 0x57, 0xb1, 0x76, 0x01, 0xcb, 0x10, 0x4b, 0x39, 0xca, 0x8a, 0x54,
+	0x1b, 0x78, 0xe2, 0xfd, 0xae, 0x0f, 0xdd, 0xc3, 0xa3, 0x93, 0x17, 0xa4, 0x7a, 0xf6, 0x0e, 0x4c,
+	0xe3, 0x74, 0x29, 0x64, 0xac, 0x03, 0x1e, 0x26, 0xca, 0xba, 0x4d, 0x4f, 0xcb, 0x42, 0xf8, 0x13,
+	0xab, 0x39, 0x0c, 0x13, 0xc5, 0x0e, 0x60, 0xb0, 0x90, 0x59, 0x91, 0x9b, 0xda, 0x7b, 0x72, 0xb0,
+	0xd3, 0xda, 0xf8, 0xc3, 0xa3, 0x93, 0x7d, 0x5c, 0xc5, 0xcf, 0x91, 0xe2, 0x5b, 0x26, 0x7b, 0x0f,
+	0x7a, 0x34, 0x68, 0x8f, 0x7a, 0xcc, 0x6f, 0xed, 0x71, 0x78, 0x74, 0xe2, 0x13, 0xab, 0x76, 0xdd,
+	0xfe, 0x2d, 0xae, 0xfb, 0x0f, 0x07, 0xc6, 0xd5, 0x04, 0xd5, 0x39, 0x3a, 0x64, 0xa0, 0xc6, 0x1b,
+	0x3d, 0x18, 0xdb, 0xf5, 0x8a, 0xa8, 0xf5, 0x19, 0x35, 0xcc, 0xde, 0x80, 0xa1, 0x15, 0xc8, 0xda,
+	0x4a, 0x46, 0x09, 0xb2, 0xb7, 0xa1, 0xfc, 0x66, 0x7e, 0x91, 0x08, 0x93, 0xfd, 0x6e, 0x6c, 0x06,
+	0x2a, 0x30, 0x3b, 0x62, 0x19, 0xd2, 0x27, 0xc7, 0xc1, 0xa6, 0xb1, 0x56, 0xaa, 0x3d, 0x4c, 0x6d,
+	0x62, 0x25, 0xf6, 0x23, 0xd8, 0xaa, 0xa6, 0x0f, 0x56, 0x62, 0x75, 0x81, 0xf5, 0x80, 0x29, 0x4f,
+	0xdc, 0x4a, 0x71, 0x6a, 0xf0, 0x9d, 0xbf, 0x39, 0x30, 0xb4, 0x7b, 0xc2, 0xee, 0x01, 0xf0, 0x3c,
+	0x4f, 0xd6, 0xc1, 0x52, 0x48, 0x53, 0x49, 0x57, 0xdf, 0x43, 0xf8, 0xb1, 0x90, 0xa2, 0x26, 0xa9,
+	0xe2, 0xa2, 0x7d, 0x76, 0x86, 0x74, 0x56, 0x5c, 0xa8, 0xf6, 0xc6, 0x74, 0x6f, 0xdf, 0x98, 0x6f,
+	0x4c, 0xc5, 0xdb, 0xd0, 0xa7, 0xc3, 0xb4, 0xe1, 0xcc, 0x08, 0x06, 0xe5, 0xa9, 0xb6, 0xf7, 0x15,
+	0x23, 0x98, 0x1c, 0x9c, 0xae, 0x6d, 0x24, 0xa3, 0xb6, 0xf7, 0x01, 0xc0, 0x2f, 0xf1, 0x00, 0x4d,
+	0xe1, 0xe3, 0x42, 0x37, 0x8e, 0x4c, 0x3c, 0x9f, 0xf9, 0xd8, 0xc4, 0x91, 0xf0, 0xf4, 0x14, 0x45,
+	0xaf, 0xb1, 0x6f, 0x04, 0x2f, 0x02, 0x38, 0x92, 0xeb, 0x5c, 0x9f, 0x09, 0x5d, 0xe4, 0xd8, 0xeb,
+	0x4a, 0xac, 0x69, 0x0f, 0xa6, 0x3e, 0x36, 0x29, 0xd7, 0x25, 0x31, 0xa6, 0xba, 0x34, 0x4b, 0x43,
+	0x73, 0x89, 0xc5, 0x5c, 0x47, 0xd8, 0x23, 0x84, 0x90, 0xa2, 0xa8, 0x0a, 0xb7, 0x94, 0xae, 0xa1,
+	0x18, 0x8c, 0x28, 0xde, 0x7f, 0x1c, 0xb8, 0x63, 0x93, 0xf2, 0x61, 0x88, 0x31, 0xf7, 0x34, 0x8b,
+	0xe2, 0xcb, 0x35, 0x9e, 0x25, 0x27, 0xd9, 0xda, 0x97, 0x95, 0xf0, 0xfb, 0x28, 0xab, 0x9b, 0x0b,
+	0x0a, 0xb5, 0x4d, 0x8e, 0x4e, 0xab, 0xd2, 0x7c, 0xe6, 0x97, 0x22, 0x3b, 0x86, 0x71, 0x96, 0x0b,
+	0x1b, 0xdc, 0x7b, 0x14, 0xac, 0x7e, 0xd8, 0xf2, 0x80, 0x5b, 0xa6, 0xde, 0xff, 0xb4, 0xec, 0xe1,
+	0xd7, 0x9d, 0xbd, 0xf7, 0x60, 0x58, 0xd6, 0x0e, 0x00, 0x03, 0x73, 0xb7, 0x70, 0x1d, 0x36, 0x31,
+	0xc6, 0x82, 0xe1, 0xa4, 0x83, 0x81, 0x8b, 0x22, 0x53, 0xcf, 0xdb, 0x85, 0x71, 0x35, 0x0a, 0x06,
+	0xa1, 0xc3, 0x28, 0x72, 0x5f, 0xc2, 0x8e, 0xa6, 0x42, 0x74, 0x1d, 0xef, 0xd7, 0x30, 0x6b, 0xcd,
+	0xfd, 0x2d, 0xc5, 0xdc, 0x0b, 0xa2, 0x77, 0xbd, 0x53, 0xdd, 0xe6, 0x4e, 0x79, 0x7f, 0x71, 0x4c,
+	0x14, 0xa3, 0x2c, 0xfe, 0x3e, 0xf4, 0x4d, 0x19, 0xec, 0xdc, 0x12, 0x38, 0x4a, 0x16, 0x35, 0x7c,
+	0x43, 0xdc, 0x51, 0xe6, 0x63, 0x9a, 0x56, 0x69, 0x02, 0x57, 0x69, 0x95, 0xa5, 0xff, 0x77, 0x1a,
+	0xd9, 0x18, 0x2f, 0x08, 0x5c, 0xe9, 0x40, 0x09, 0x51, 0x16, 0xb3, 0x23, 0x04, 0xce, 0x84, 0x48,
+	0xe9, 0x82, 0x80, 0x4a, 0xbb, 0x74, 0x6b, 0xe4, 0x13, 0xc4, 0xec, 0x1e, 0x7a, 0xff, 0x76, 0x60,
+	0xf2, 0x24, 0x8b, 0x43, 0x71, 0xce, 0xe5, 0x42, 0x68, 0xb6, 0x01, 0x9d, 0xea, 0xae, 0xd3, 0x89,
+	0x23, 0xf6, 0x21, 0x0c, 0x35, 0x69, 0x8c, 0xad, 0x4e, 0x0e, 0xde, 0x6c, 0x7d, 0x48, 0xa3, 0xeb,
+	0xbe, 0xf9, 0xf3, 0x4b, 0xfe, 0xce, 0x9f, 0x1c, 0x18, 0xd8, 0x51, 0x5b, 0x5b, 0xdd, 0xfd, 0x1f,
+	0xb6, 0xba, 0x72, 0xc4, 0x6e, 0xd3, 0x11, 0x5f, 0xab, 0x6f, 0x53, 0xcd, 0x98, 0x69, 0x2e, 0x55,
+	0x6f, 0xc1, 0x28, 0x5c, 0xc6, 0x49, 0x24, 0x45, 0xda, 0x8e, 0xa9, 0x15, 0xec, 0x65, 0xb0, 0x59,
+	0x67, 0x39, 0x72, 0xd4, 0x17, 0xdd, 0xf5, 0x6e, 0xdc, 0x36, 0xcd, 0x3a, 0x9b, 0x10, 0xae, 0xe9,
+	0x32, 0x29, 0xd4, 0xd2, 0xc6, 0x9a, 0x72, 0x4d, 0x84, 0x79, 0xbf, 0x85, 0xe9, 0x51, 0x16, 0x89,
+	0xb0, 0x7c, 0xa3, 0xc2, 0xaa, 0x26, 0xc9, 0x97, 0x9c, 0x0e, 0xb8, 0xef, 0x1b, 0x01, 0xcf, 0xf7,
+	0x42, 0x68, 0x4e, 0x15, 0x58, 0xdf, 0xa7, 0x36, 0x66, 0xaa, 0x5c, 0x8a, 0x4b, 0x21, 0x03, 0xd3,
+	0x01, 0x2d, 0xae, 0x0a, 0xce, 0x46, 0x73, 0x48, 0x9d, 0xcb, 0x87, 0x9e, 0xde, 0xf3, 0x0f, 0x3d,
+	0x5f, 0x0f, 0xea, 0x3b, 0x8c, 0xfa, 0x16, 0xb3, 0xff, 0x3e, 0x80, 0x42, 0x4a, 0x90, 0xa5, 0xc9,
+	0x8d, 0x52, 0x72, 0x4c, 0x8a, 0x4f, 0xd3, 0x64, 0xcd, 0x3c, 0x98, 0x86, 0x75, 0xee, 0x36, 0x89,
+	0x71, 0xea, 0xb7, 0x30, 0xf6, 0x33, 0x98, 0x5c, 0xca, 0x6c, 0x15, 0x98, 0xd0, 0x44, 0x6b, 0x9a,
+	0x1c, 0xbc, 0xfe, 0x9c, 0x0b, 0xd0, 0x82, 0xf6, 0xe9, 0xd7, 0x07, 0xec, 0x70, 0x44, 0xfc, 0xaa,
+	0xbb, 0x09, 0x5b, 0x74, 0x8a, 0xdf, 0xa9, 0xbb, 0x09, 0x12, 0xff, 0x3f, 0xaf, 0x4b, 0x6c, 0xbf,
+	0x7e, 0xcb, 0x9c, 0xd2, 0x26, 0x6c, 0xb7, 0xbd, 0xcf, 0xe8, 0xea, 0x17, 0xce, 0xe7, 0x9e, 0x04,
+	0x67, 0xb7, 0x3c, 0x09, 0x36, 0xae, 0x00, 0x1b, 0xe6, 0x2a, 0x57, 0x5e, 0x01, 0x5e, 0x87, 0x71,
+	0xfd, 0x2e, 0xb3, 0x69, 0x7c, 0xa0, 0x02, 0xb0, 0xe6, 0xcd, 0xd2, 0x24, 0x4e, 0x85, 0x12, 0xa1,
+	0xa2, 0x8b, 0xd6, 0xcc, 0x6f, 0x20, 0x58, 0xd6, 0xc7, 0x51, 0x62, 0xb4, 0x5b, 0xa6, 0xac, 0x2f,
+	0x65, 0xf6, 0x01, 0x30, 0xa5, 0x65, 0x96, 0x2e, 0x82, 0x86, 0x9d, 0x98, 0x2b, 0x56, 0x69, 0x62,
+	0x5b, 0x86, 0xd0, 0xa8, 0x0b, 0x2b, 0x9b, 0xbe, 0xf3, 0x9c, 0x4d, 0xef, 0xfc, 0x0a, 0xfa, 0xc6,
+	0x9c, 0xcb, 0xe7, 0x49, 0xe7, 0x96, 0xe7, 0xc9, 0xce, 0x2d, 0xcf, 0x93, 0xdd, 0x5b, 0x9f, 0x27,
+	0x7b, 0xcd, 0xe7, 0x49, 0xef, 0x4b, 0x07, 0x26, 0xbe, 0xf8, 0xa2, 0x10, 0x4a, 0xdf, 0x4f, 0xb2,
+	0x0b, 0xbc, 0xbb, 0x5a, 0x1f, 0x09, 0xca, 0x4b, 0xb0, 0x09, 0x63, 0x1b, 0x16, 0x3e, 0xb7, 0x77,
+	0xe1, 0x06, 0xb1, 0xbc, 0xc3, 0x76, 0x5a, 0xc4, 0x23, 0x7b, 0x95, 0xfd, 0x31, 0xdc, 0x29, 0xc3,
+	0x4d, 0xf3, 0x05, 0xc8, 0xdc, 0x57, 0x98, 0x55, 0x3d, 0xa8, 0x35, 0xde, 0xbf, 0x1c, 0x98, 0x1a,
+	0xf3, 0x3e, 0xca, 0xd2, 0xcb, 0x78, 0xf1, 0xfc, 0x3b, 0x9a, 0xf3, 0x1d, 0xde, 0xd1, 0x3a, 0xcf,
+	0xbf, 0xa3, 0xdd, 0x05, 0xe0, 0x49, 0x92, 0x3d, 0x0d, 0x96, 0x7a, 0x95, 0x98, 0xe0, 0xe5, 0x8f,
+	0x09, 0x39, 0xd6, 0xab, 0x04, 0x6f, 0xf7, 0xf6, 0x22, 0x14, 0x24, 0x22, 0x5d, 0xe8, 0xa5, 0xdd,
+	0xaa, 0x99, 0x45, 0x4f, 0x08, 0x64, 0xef, 0xc3, 0x76, 0xbc, 0x42, 0xd2, 0x0d, 0xb2, 0x79, 0xc5,
+	0x60, 0xa4, 0x3b, 0x6d, 0xf5, 0x68, 0x3d, 0x15, 0x0d, 0xda, 0x4f, 0x45, 0xde, 0x15, 0xcc, 0xce,
+	0x8a, 0xc5, 0x42, 0x28, 0x6d, 0xbf, 0xf6, 0x9b, 0x1f, 0xf5, 0xf1, 0x26, 0x66, 0x5f, 0xaa, 0x78,
+	0x62, 0x82, 0x96, 0xdf, 0x40, 0xd0, 0xc9, 0xf2, 0x42, 0x2d, 0x03, 0x9d, 0x05, 0x9a, 0x27, 0x57,
+	0xf6, 0x0b, 0x01, 0xb1, 0xf3, 0xec, 0x9c, 0x27, 0x57, 0xf7, 0x3b, 0xc7, 0xce, 0x7f, 0x03, 0x00,
+	0x00, 0xff, 0xff, 0x86, 0xf1, 0xdf, 0x29, 0x5b, 0x18, 0x00, 0x00,
+}
diff --git a/vendor/layeh.com/gumble/gumble/MumbleProto/generate.go b/vendor/layeh.com/gumble/gumble/MumbleProto/generate.go
new file mode 100644
index 00000000..37ecfaf4
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/MumbleProto/generate.go
@@ -0,0 +1,2 @@
+//go:generate go run generate_main.go
+package MumbleProto
diff --git a/vendor/layeh.com/gumble/gumble/accesstokens.go b/vendor/layeh.com/gumble/gumble/accesstokens.go
new file mode 100644
index 00000000..3bcbaa45
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/accesstokens.go
@@ -0,0 +1,16 @@
+package gumble
+
+import (
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// AccessTokens are additional passwords that can be provided to the server to
+// gain access to restricted channels.
+type AccessTokens []string
+
+func (a AccessTokens) writeMessage(client *Client) error {
+	packet := MumbleProto.Authenticate{
+		Tokens: a,
+	}
+	return client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/acl.go b/vendor/layeh.com/gumble/gumble/acl.go
new file mode 100644
index 00000000..beb167c4
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/acl.go
@@ -0,0 +1,116 @@
+package gumble
+
+import (
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// ACL contains a list of ACLGroups and ACLRules linked to a channel.
+type ACL struct {
+	// The channel to which the ACL belongs.
+	Channel *Channel
+	// The ACL's groups.
+	Groups []*ACLGroup
+	// The ACL's rules.
+	Rules []*ACLRule
+	// Does the ACL inherits the parent channel's ACLs?
+	Inherits bool
+}
+
+func (a *ACL) writeMessage(client *Client) error {
+	packet := MumbleProto.ACL{
+		ChannelId:   &a.Channel.ID,
+		Groups:      make([]*MumbleProto.ACL_ChanGroup, len(a.Groups)),
+		Acls:        make([]*MumbleProto.ACL_ChanACL, len(a.Rules)),
+		InheritAcls: &a.Inherits,
+		Query:       proto.Bool(false),
+	}
+
+	for i, group := range a.Groups {
+		packet.Groups[i] = &MumbleProto.ACL_ChanGroup{
+			Name:        &group.Name,
+			Inherit:     &group.InheritUsers,
+			Inheritable: &group.Inheritable,
+			Add:         make([]uint32, 0, len(group.UsersAdd)),
+			Remove:      make([]uint32, 0, len(group.UsersRemove)),
+		}
+		for _, user := range group.UsersAdd {
+			packet.Groups[i].Add = append(packet.Groups[i].Add, user.UserID)
+		}
+		for _, user := range group.UsersRemove {
+			packet.Groups[i].Remove = append(packet.Groups[i].Remove, user.UserID)
+		}
+	}
+
+	for i, rule := range a.Rules {
+		packet.Acls[i] = &MumbleProto.ACL_ChanACL{
+			ApplyHere: &rule.AppliesCurrent,
+			ApplySubs: &rule.AppliesChildren,
+			Grant:     proto.Uint32(uint32(rule.Granted)),
+			Deny:      proto.Uint32(uint32(rule.Denied)),
+		}
+		if rule.User != nil {
+			packet.Acls[i].UserId = &rule.User.UserID
+		}
+		if rule.Group != nil {
+			packet.Acls[i].Group = &rule.Group.Name
+		}
+	}
+
+	return client.Conn.WriteProto(&packet)
+}
+
+// ACLUser is a registered user who is part of or can be part of an ACL group
+// or rule.
+type ACLUser struct {
+	// The user ID of the user.
+	UserID uint32
+	// The name of the user.
+	Name string
+}
+
+// ACLGroup is a named group of registered users which can be used in an
+// ACLRule.
+type ACLGroup struct {
+	// The ACL group name.
+	Name string
+	// Is the group inherited from the parent channel's ACL?
+	Inherited bool
+	// Are group members are inherited from the parent channel's ACL?
+	InheritUsers bool
+	// Can the group be inherited by child channels?
+	Inheritable bool
+	// The users who are explicitly added to, explicitly removed from, and
+	// inherited into the group.
+	UsersAdd, UsersRemove, UsersInherited map[uint32]*ACLUser
+}
+
+// ACL group names that are built-in.
+const (
+	ACLGroupEveryone       = "all"
+	ACLGroupAuthenticated  = "auth"
+	ACLGroupInsideChannel  = "in"
+	ACLGroupOutsideChannel = "out"
+)
+
+// ACLRule is a set of granted and denied permissions given to an ACLUser or
+// ACLGroup.
+type ACLRule struct {
+	// Does the rule apply to the channel in which the rule is defined?
+	AppliesCurrent bool
+	// Does the rule apply to the children of the channel in which the rule is
+	// defined?
+	AppliesChildren bool
+	// Is the rule inherited from the parent channel's ACL?
+	Inherited bool
+
+	// The permissions granted by the rule.
+	Granted Permission
+	// The permissions denied by the rule.
+	Denied Permission
+
+	// The ACL user the rule applies to. Can be nil.
+	User *ACLUser
+	// The ACL group the rule applies to. Can be nil.
+	Group *ACLGroup
+}
diff --git a/vendor/layeh.com/gumble/gumble/audio.go b/vendor/layeh.com/gumble/gumble/audio.go
new file mode 100644
index 00000000..e3ce8260
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/audio.go
@@ -0,0 +1,85 @@
+package gumble
+
+import (
+	"time"
+)
+
+const (
+	// AudioSampleRate is the audio sample rate (in hertz) for incoming and
+	// outgoing audio.
+	AudioSampleRate = 48000
+
+	// AudioDefaultInterval is the default interval that audio packets are sent
+	// at.
+	AudioDefaultInterval = 10 * time.Millisecond
+
+	// AudioDefaultFrameSize is the number of audio frames that should be sent in
+	// a 10ms window.
+	AudioDefaultFrameSize = AudioSampleRate / 100
+
+	// AudioMaximumFrameSize is the maximum audio frame size from another user
+	// that will be processed.
+	AudioMaximumFrameSize = AudioSampleRate / 1000 * 60
+
+	// AudioDefaultDataBytes is the default number of bytes that an audio frame
+	// can use.
+	AudioDefaultDataBytes = 40
+
+	// AudioChannels is the number of audio channels that are contained in an
+	// audio stream.
+	AudioChannels = 1
+)
+
+// AudioListener is the interface that must be implemented by types wishing to
+// receive incoming audio data from the server.
+//
+// OnAudioStream is called when an audio stream for a user starts. It is the
+// implementer's responsibility to continuously process AudioStreamEvent.C
+// until it is closed.
+type AudioListener interface {
+	OnAudioStream(e *AudioStreamEvent)
+}
+
+// AudioStreamEvent is event that is passed to AudioListener.OnAudioStream.
+type AudioStreamEvent struct {
+	Client *Client
+	User   *User
+	C      <-chan *AudioPacket
+}
+
+// AudioBuffer is a slice of PCM audio samples.
+type AudioBuffer []int16
+
+func (a AudioBuffer) writeAudio(client *Client, seq int64, final bool) error {
+	encoder := client.AudioEncoder
+	if encoder == nil {
+		return nil
+	}
+	dataBytes := client.Config.AudioDataBytes
+	raw, err := encoder.Encode(a, len(a), dataBytes)
+	if final {
+		defer encoder.Reset()
+	}
+	if err != nil {
+		return err
+	}
+
+	var targetID byte
+	if target := client.VoiceTarget; target != nil {
+		targetID = byte(target.ID)
+	}
+	// TODO: re-enable positional audio
+	return client.Conn.WriteAudio(byte(4), targetID, seq, final, raw, nil, nil, nil)
+}
+
+// AudioPacket contains incoming audio samples and information.
+type AudioPacket struct {
+	Client *Client
+	Sender *User
+	Target *VoiceTarget
+
+	AudioBuffer
+
+	HasPosition bool
+	X, Y, Z     float32
+}
diff --git a/vendor/layeh.com/gumble/gumble/audiocodec.go b/vendor/layeh.com/gumble/gumble/audiocodec.go
new file mode 100644
index 00000000..9f4883ed
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/audiocodec.go
@@ -0,0 +1,55 @@
+package gumble
+
+import (
+	"sync"
+)
+
+const (
+	audioCodecIDOpus = 4
+)
+
+var (
+	audioCodecsLock sync.Mutex
+	audioCodecs     [8]AudioCodec
+)
+
+// RegisterAudioCodec registers an audio codec that can be used for encoding
+// and decoding outgoing and incoming audio data. The function panics if the
+// ID is invalid.
+func RegisterAudioCodec(id int, codec AudioCodec) {
+	audioCodecsLock.Lock()
+	defer audioCodecsLock.Unlock()
+
+	if id < 0 || id >= len(audioCodecs) {
+		panic("id out of range")
+	}
+	audioCodecs[id] = codec
+}
+
+func getAudioCodec(id int) AudioCodec {
+	audioCodecsLock.Lock()
+	defer audioCodecsLock.Unlock()
+	return audioCodecs[id]
+}
+
+// AudioCodec can create a encoder and a decoder for outgoing and incoming
+// data.
+type AudioCodec interface {
+	ID() int
+	NewEncoder() AudioEncoder
+	NewDecoder() AudioDecoder
+}
+
+// AudioEncoder encodes a chunk of PCM audio samples to a certain type.
+type AudioEncoder interface {
+	ID() int
+	Encode(pcm []int16, mframeSize, maxDataBytes int) ([]byte, error)
+	Reset()
+}
+
+// AudioDecoder decodes an encoded byte slice to a chunk of PCM audio samples.
+type AudioDecoder interface {
+	ID() int
+	Decode(data []byte, frameSize int) ([]int16, error)
+	Reset()
+}
diff --git a/vendor/layeh.com/gumble/gumble/audiolisteners.go b/vendor/layeh.com/gumble/gumble/audiolisteners.go
new file mode 100644
index 00000000..7bf0e80d
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/audiolisteners.go
@@ -0,0 +1,46 @@
+package gumble
+
+type audioEventItem struct {
+	parent     *AudioListeners
+	prev, next *audioEventItem
+	listener   AudioListener
+	streams    map[*User]chan *AudioPacket
+}
+
+func (e *audioEventItem) Detach() {
+	if e.prev == nil {
+		e.parent.head = e.next
+	} else {
+		e.prev.next = e.next
+	}
+	if e.next == nil {
+		e.parent.tail = e.prev
+	} else {
+		e.next.prev = e.prev
+	}
+}
+
+// AudioListeners is a list of audio listeners. Each attached listener is
+// called in sequence when a new user audio stream begins.
+type AudioListeners struct {
+	head, tail *audioEventItem
+}
+
+// Attach adds a new audio listener to the end of the current list of listeners.
+func (e *AudioListeners) Attach(listener AudioListener) Detacher {
+	item := &audioEventItem{
+		parent:   e,
+		prev:     e.tail,
+		listener: listener,
+		streams:  make(map[*User]chan *AudioPacket),
+	}
+	if e.head == nil {
+		e.head = item
+	}
+	if e.tail == nil {
+		e.tail = item
+	} else {
+		e.tail.next = item
+	}
+	return item
+}
diff --git a/vendor/layeh.com/gumble/gumble/bans.go b/vendor/layeh.com/gumble/gumble/bans.go
new file mode 100644
index 00000000..d1fd9cb7
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/bans.go
@@ -0,0 +1,101 @@
+package gumble
+
+import (
+	"net"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// BanList is a list of server ban entries.
+//
+// Whenever a ban is changed, it does not come into effect until the ban list
+// is sent back to the server.
+type BanList []*Ban
+
+// Add creates a new ban list entry with the given parameters.
+func (b *BanList) Add(address net.IP, mask net.IPMask, reason string, duration time.Duration) *Ban {
+	ban := &Ban{
+		Address:  address,
+		Mask:     mask,
+		Reason:   reason,
+		Duration: duration,
+	}
+	*b = append(*b, ban)
+	return ban
+}
+
+// Ban represents an entry in the server ban list.
+//
+// This type should not be initialized manually. Instead, create new ban
+// entries using BanList.Add().
+type Ban struct {
+	// The banned IP address.
+	Address net.IP
+	// The IP mask that the ban applies to.
+	Mask net.IPMask
+	// The name of the banned user.
+	Name string
+	// The certificate hash of the banned user.
+	Hash string
+	// The reason for the ban.
+	Reason string
+	// The start time from which the ban applies.
+	Start time.Time
+	// How long the ban is for.
+	Duration time.Duration
+
+	unban bool
+}
+
+// SetAddress sets the banned IP address.
+func (b *Ban) SetAddress(address net.IP) {
+	b.Address = address
+}
+
+// SetMask sets the IP mask that the ban applies to.
+func (b *Ban) SetMask(mask net.IPMask) {
+	b.Mask = mask
+}
+
+// SetReason changes the reason for the ban.
+func (b *Ban) SetReason(reason string) {
+	b.Reason = reason
+}
+
+// SetDuration changes the duration of the ban.
+func (b *Ban) SetDuration(duration time.Duration) {
+	b.Duration = duration
+}
+
+// Unban will unban the user from the server.
+func (b *Ban) Unban() {
+	b.unban = true
+}
+
+// Ban will ban the user from the server. This is only useful if Unban() was
+// called on the ban entry.
+func (b *Ban) Ban() {
+	b.unban = false
+}
+
+func (b BanList) writeMessage(client *Client) error {
+	packet := MumbleProto.BanList{
+		Query: proto.Bool(false),
+	}
+
+	for _, ban := range b {
+		if !ban.unban {
+			maskSize, _ := ban.Mask.Size()
+			packet.Bans = append(packet.Bans, &MumbleProto.BanList_BanEntry{
+				Address:  ban.Address,
+				Mask:     proto.Uint32(uint32(maskSize)),
+				Reason:   &ban.Reason,
+				Duration: proto.Uint32(uint32(ban.Duration / time.Second)),
+			})
+		}
+	}
+
+	return client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/channel.go b/vendor/layeh.com/gumble/gumble/channel.go
new file mode 100644
index 00000000..0179e3ca
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/channel.go
@@ -0,0 +1,207 @@
+package gumble
+
+import (
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// Channel represents a channel in the server's channel tree.
+type Channel struct {
+	// The channel's unique ID.
+	ID uint32
+	// The channel's name.
+	Name string
+	// The channel's parent. nil if the channel is the root channel.
+	Parent *Channel
+	// The channels directly underneath the channel.
+	Children Channels
+	// The channels that are linked to the channel.
+	Links Channels
+	// The users currently in the channel.
+	Users Users
+	// The channel's description. Contains the empty string if the channel does
+	// not have a description, or if it needs to be requested.
+	Description string
+	// The channel's description hash. nil if Channel.Description has
+	// been populated.
+	DescriptionHash []byte
+	// The maximum number of users allowed in the channel. If the value is zero,
+	// the maximum number of users per-channel is dictated by the server's
+	// "usersperchannel" setting.
+	MaxUsers uint32
+	// The position at which the channel should be displayed in an ordered list.
+	Position int32
+	// Is the channel temporary?
+	Temporary bool
+
+	client *Client
+}
+
+// IsRoot returns true if the channel is the server's root channel.
+func (c *Channel) IsRoot() bool {
+	return c.ID == 0
+}
+
+// Add will add a sub-channel to the given channel.
+func (c *Channel) Add(name string, temporary bool) {
+	packet := MumbleProto.ChannelState{
+		Parent:    &c.ID,
+		Name:      &name,
+		Temporary: &temporary,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// Remove will remove the given channel and all sub-channels from the server's
+// channel tree.
+func (c *Channel) Remove() {
+	packet := MumbleProto.ChannelRemove{
+		ChannelId: &c.ID,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// SetName will set the name of the channel. This will have no effect if the
+// channel is the server's root channel.
+func (c *Channel) SetName(name string) {
+	packet := MumbleProto.ChannelState{
+		ChannelId: &c.ID,
+		Name:      &name,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// SetDescription will set the description of the channel.
+func (c *Channel) SetDescription(description string) {
+	packet := MumbleProto.ChannelState{
+		ChannelId:   &c.ID,
+		Description: &description,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// SetPosition will set the position of the channel.
+func (c *Channel) SetPosition(position int32) {
+	packet := MumbleProto.ChannelState{
+		ChannelId: &c.ID,
+		Position:  &position,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// SetMaxUsers will set the maximum number of users allowed in the channel.
+func (c *Channel) SetMaxUsers(maxUsers uint32) {
+	packet := MumbleProto.ChannelState{
+		ChannelId: &c.ID,
+		MaxUsers:  &maxUsers,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// Find returns a channel whose path (by channel name) from the current channel
+// is equal to the arguments passed.
+//
+// For example, given the following server channel tree:
+//         Root
+//           Child 1
+//           Child 2
+//             Child 2.1
+//             Child 2.2
+//               Child 2.2.1
+//           Child 3
+// To get the "Child 2.2.1" channel:
+//         root.Find("Child 2", "Child 2.2", "Child 2.2.1")
+func (c *Channel) Find(names ...string) *Channel {
+	if len(names) == 0 {
+		return c
+	}
+	for _, child := range c.Children {
+		if child.Name == names[0] {
+			return child.Find(names[1:]...)
+		}
+	}
+	return nil
+}
+
+// RequestDescription requests that the actual channel description
+// (i.e. non-hashed) be sent to the client.
+func (c *Channel) RequestDescription() {
+	packet := MumbleProto.RequestBlob{
+		ChannelDescription: []uint32{c.ID},
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// RequestACL requests that the channel's ACL to be sent to the client.
+func (c *Channel) RequestACL() {
+	packet := MumbleProto.ACL{
+		ChannelId: &c.ID,
+		Query:     proto.Bool(true),
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// RequestPermission requests that the channel's permission information to be
+// sent to the client.
+//
+// Note: the server will not reply to the request if the client has up-to-date
+// permission information.
+func (c *Channel) RequestPermission() {
+	packet := MumbleProto.PermissionQuery{
+		ChannelId: &c.ID,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// Send will send a text message to the channel.
+func (c *Channel) Send(message string, recursive bool) {
+	textMessage := TextMessage{
+		Message: message,
+	}
+	if recursive {
+		textMessage.Trees = []*Channel{c}
+	} else {
+		textMessage.Channels = []*Channel{c}
+	}
+	c.client.Send(&textMessage)
+}
+
+// Permission returns the permissions the user has in the channel, or nil if
+// the permissions are unknown.
+func (c *Channel) Permission() *Permission {
+	return c.client.permissions[c.ID]
+}
+
+// Link links the given channels to the channel.
+func (c *Channel) Link(channel ...*Channel) {
+	packet := MumbleProto.ChannelState{
+		ChannelId: &c.ID,
+		LinksAdd:  make([]uint32, len(channel)),
+	}
+	for i, ch := range channel {
+		packet.LinksAdd[i] = ch.ID
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// Unlink unlinks the given channels from the channel. If no arguments are
+// passed, all linked channels are unlinked.
+func (c *Channel) Unlink(channel ...*Channel) {
+	packet := MumbleProto.ChannelState{
+		ChannelId: &c.ID,
+	}
+	if len(channel) == 0 {
+		packet.LinksRemove = make([]uint32, len(c.Links))
+		i := 0
+		for channelID := range c.Links {
+			packet.LinksRemove[i] = channelID
+			i++
+		}
+	} else {
+		packet.LinksRemove = make([]uint32, len(channel))
+		for i, ch := range channel {
+			packet.LinksRemove[i] = ch.ID
+		}
+	}
+	c.client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/channels.go b/vendor/layeh.com/gumble/gumble/channels.go
new file mode 100644
index 00000000..2058b0b1
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/channels.go
@@ -0,0 +1,28 @@
+package gumble
+
+// Channels is a map of server channels.
+type Channels map[uint32]*Channel
+
+// create adds a new channel with the given id to the collection. If a channel
+// with the given id already exists, it is overwritten.
+func (c Channels) create(id uint32) *Channel {
+	channel := &Channel{
+		ID:       id,
+		Links:    Channels{},
+		Children: Channels{},
+		Users:    Users{},
+	}
+	c[id] = channel
+	return channel
+}
+
+// Find returns a channel whose path (by channel name) from the server root
+// channel is equal to the arguments passed. nil is returned if c does not
+// containt the root channel.
+func (c Channels) Find(names ...string) *Channel {
+	root := c[0]
+	if names == nil || root == nil {
+		return root
+	}
+	return root.Find(names...)
+}
diff --git a/vendor/layeh.com/gumble/gumble/client.go b/vendor/layeh.com/gumble/gumble/client.go
new file mode 100644
index 00000000..2256f5fb
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/client.go
@@ -0,0 +1,289 @@
+package gumble
+
+import (
+	"crypto/tls"
+	"errors"
+	"math"
+	"net"
+	"runtime"
+	"sync/atomic"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// State is the current state of the client's connection to the server.
+type State int
+
+const (
+	// StateDisconnected means the client is no longer connected to the server.
+	StateDisconnected State = iota
+
+	// StateConnected means the client is connected to the server and is
+	// syncing initial information. This is an internal state that will
+	// never be returned by Client.State().
+	StateConnected
+
+	// StateSynced means the client is connected to a server and has been sent
+	// the server state.
+	StateSynced
+)
+
+// ClientVersion is the protocol version that Client implements.
+const ClientVersion = 1<<16 | 3<<8 | 0
+
+// Client is the type used to create a connection to a server.
+type Client struct {
+	// The User associated with the client.
+	Self *User
+	// The client's configuration.
+	Config *Config
+	// The underlying Conn to the server.
+	Conn *Conn
+
+	// The users currently connected to the server.
+	Users Users
+	// The connected server's channels.
+	Channels    Channels
+	permissions map[uint32]*Permission
+	tmpACL      *ACL
+
+	// Ping stats
+	tcpPacketsReceived uint32
+	tcpPingTimes       [12]float32
+	tcpPingAvg         uint32
+	tcpPingVar         uint32
+
+	// A collection containing the server's context actions.
+	ContextActions ContextActions
+
+	// The audio encoder used when sending audio to the server.
+	AudioEncoder AudioEncoder
+	audioCodec   AudioCodec
+	// To whom transmitted audio will be sent. The VoiceTarget must have already
+	// been sent to the server for targeting to work correctly. Setting to nil
+	// will disable voice targeting (i.e. switch back to regular speaking).
+	VoiceTarget *VoiceTarget
+
+	state uint32
+
+	// volatile is held by the client when the internal data structures are being
+	// modified.
+	volatile rpwMutex
+
+	connect         chan *RejectError
+	end             chan struct{}
+	disconnectEvent DisconnectEvent
+}
+
+// Dial is an alias of DialWithDialer(new(net.Dialer), addr, config, nil).
+func Dial(addr string, config *Config) (*Client, error) {
+	return DialWithDialer(new(net.Dialer), addr, config, nil)
+}
+
+// DialWithDialer connects to the Mumble server at the given address.
+//
+// The function returns after the connection has been established, the initial
+// server information has been synced, and the OnConnect handlers have been
+// called.
+//
+// nil and an error is returned if server synchronization does not complete by
+// min(time.Now() + dialer.Timeout, dialer.Deadline), or if the server rejects
+// the client.
+func DialWithDialer(dialer *net.Dialer, addr string, config *Config, tlsConfig *tls.Config) (*Client, error) {
+	start := time.Now()
+
+	conn, err := tls.DialWithDialer(dialer, "tcp", addr, tlsConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	client := &Client{
+		Conn:     NewConn(conn),
+		Config:   config,
+		Users:    make(Users),
+		Channels: make(Channels),
+
+		permissions: make(map[uint32]*Permission),
+
+		state: uint32(StateConnected),
+
+		connect: make(chan *RejectError),
+		end:     make(chan struct{}),
+	}
+
+	go client.readRoutine()
+
+	// Initial packets
+	versionPacket := MumbleProto.Version{
+		Version:   proto.Uint32(ClientVersion),
+		Release:   proto.String("gumble"),
+		Os:        proto.String(runtime.GOOS),
+		OsVersion: proto.String(runtime.GOARCH),
+	}
+	authenticationPacket := MumbleProto.Authenticate{
+		Username: &client.Config.Username,
+		Password: &client.Config.Password,
+		Opus:     proto.Bool(getAudioCodec(audioCodecIDOpus) != nil),
+		Tokens:   client.Config.Tokens,
+	}
+	client.Conn.WriteProto(&versionPacket)
+	client.Conn.WriteProto(&authenticationPacket)
+
+	go client.pingRoutine()
+
+	var timeout <-chan time.Time
+	{
+		var deadline time.Time
+		if !dialer.Deadline.IsZero() {
+			deadline = dialer.Deadline
+		}
+		if dialer.Timeout > 0 {
+			diff := start.Add(dialer.Timeout)
+			if deadline.IsZero() || diff.Before(deadline) {
+				deadline = diff
+			}
+		}
+		if !deadline.IsZero() {
+			timer := time.NewTimer(deadline.Sub(start))
+			defer timer.Stop()
+			timeout = timer.C
+		}
+	}
+
+	select {
+	case <-timeout:
+		client.Conn.Close()
+		return nil, errors.New("gumble: synchronization timeout")
+	case err := <-client.connect:
+		if err != nil {
+			client.Conn.Close()
+			return nil, err
+		}
+
+		return client, nil
+	}
+}
+
+// State returns the current state of the client.
+func (c *Client) State() State {
+	return State(atomic.LoadUint32(&c.state))
+}
+
+// AudioOutgoing creates a new channel that outgoing audio data can be written
+// to. The channel must be closed after the audio stream is completed. Only
+// a single channel should be open at any given time (i.e. close the channel
+// before opening another).
+func (c *Client) AudioOutgoing() chan<- AudioBuffer {
+	ch := make(chan AudioBuffer)
+	go func() {
+		var seq int64
+		previous := <-ch
+		for p := range ch {
+			previous.writeAudio(c, seq, false)
+			previous = p
+			seq = (seq + 1) % math.MaxInt32
+		}
+		if previous != nil {
+			previous.writeAudio(c, seq, true)
+		}
+	}()
+	return ch
+}
+
+// pingRoutine sends ping packets to the server at regular intervals.
+func (c *Client) pingRoutine() {
+	ticker := time.NewTicker(time.Second * 5)
+	defer ticker.Stop()
+
+	var timestamp uint64
+	var tcpPingAvg float32
+	var tcpPingVar float32
+	packet := MumbleProto.Ping{
+		Timestamp:  &timestamp,
+		TcpPackets: &c.tcpPacketsReceived,
+		TcpPingAvg: &tcpPingAvg,
+		TcpPingVar: &tcpPingVar,
+	}
+
+	t := time.Now()
+	for {
+		timestamp = uint64(t.UnixNano())
+		tcpPingAvg = math.Float32frombits(atomic.LoadUint32(&c.tcpPingAvg))
+		tcpPingVar = math.Float32frombits(atomic.LoadUint32(&c.tcpPingVar))
+		c.Conn.WriteProto(&packet)
+
+		select {
+		case <-c.end:
+			return
+		case t = <-ticker.C:
+			// continue to top of loop
+		}
+	}
+}
+
+// readRoutine reads protocol buffer messages from the server.
+func (c *Client) readRoutine() {
+	c.disconnectEvent = DisconnectEvent{
+		Client: c,
+		Type:   DisconnectError,
+	}
+
+	for {
+		pType, data, err := c.Conn.ReadPacket()
+		if err != nil {
+			break
+		}
+		if int(pType) < len(handlers) {
+			handlers[pType](c, data)
+		}
+	}
+
+	wasSynced := c.State() == StateSynced
+	atomic.StoreUint32(&c.state, uint32(StateDisconnected))
+	close(c.end)
+	if wasSynced {
+		c.Config.Listeners.onDisconnect(&c.disconnectEvent)
+	}
+}
+
+// RequestUserList requests that the server's registered user list be sent to
+// the client.
+func (c *Client) RequestUserList() {
+	packet := MumbleProto.UserList{}
+	c.Conn.WriteProto(&packet)
+}
+
+// RequestBanList requests that the server's ban list be sent to the client.
+func (c *Client) RequestBanList() {
+	packet := MumbleProto.BanList{
+		Query: proto.Bool(true),
+	}
+	c.Conn.WriteProto(&packet)
+}
+
+// Disconnect disconnects the client from the server.
+func (c *Client) Disconnect() error {
+	if c.State() == StateDisconnected {
+		return errors.New("gumble: client is already disconnected")
+	}
+	c.disconnectEvent.Type = DisconnectUser
+	c.Conn.Close()
+	return nil
+}
+
+// Do executes f in a thread-safe manner. It ensures that Client and its
+// associated data will not be changed during the lifetime of the function
+// call.
+func (c *Client) Do(f func()) {
+	c.volatile.RLock()
+	defer c.volatile.RUnlock()
+
+	f()
+}
+
+// Send will send a Message to the server.
+func (c *Client) Send(message Message) {
+	message.writeMessage(c)
+}
diff --git a/vendor/layeh.com/gumble/gumble/config.go b/vendor/layeh.com/gumble/gumble/config.go
new file mode 100644
index 00000000..49603886
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/config.go
@@ -0,0 +1,53 @@
+package gumble
+
+import (
+	"time"
+)
+
+// Config holds the Mumble configuration used by Client. A single Config should
+// not be shared between multiple Client instances.
+type Config struct {
+	// User name used when authenticating with the server.
+	Username string
+	// Password used when authenticating with the server. A password is not
+	// usually required to connect to a server.
+	Password string
+	// The initial access tokens to the send to the server. Access tokens can be
+	// resent to the server using:
+	//  client.Send(config.Tokens)
+	Tokens AccessTokens
+
+	// AudioInterval is the interval at which audio packets are sent. Valid
+	// values are: 10ms, 20ms, 40ms, and 60ms.
+	AudioInterval time.Duration
+	// AudioDataBytes is the number of bytes that an audio frame can use.
+	AudioDataBytes int
+
+	// The event listeners used when client events are triggered.
+	Listeners      Listeners
+	AudioListeners AudioListeners
+}
+
+// NewConfig returns a new Config struct with default values set.
+func NewConfig() *Config {
+	return &Config{
+		AudioInterval:  AudioDefaultInterval,
+		AudioDataBytes: AudioDefaultDataBytes,
+	}
+}
+
+// Attach is an alias of c.Listeners.Attach.
+func (c *Config) Attach(l EventListener) Detacher {
+	return c.Listeners.Attach(l)
+}
+
+// AttachAudio is an alias of c.AudioListeners.Attach.
+func (c *Config) AttachAudio(l AudioListener) Detacher {
+	return c.AudioListeners.Attach(l)
+}
+
+// AudioFrameSize returns the appropriate audio frame size, based off of the
+// audio interval.
+func (c *Config) AudioFrameSize() int {
+	return int(c.AudioInterval/AudioDefaultInterval) * AudioDefaultFrameSize
+}
diff --git a/vendor/layeh.com/gumble/gumble/conn.go b/vendor/layeh.com/gumble/gumble/conn.go
new file mode 100644
index 00000000..11e87489
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/conn.go
@@ -0,0 +1,200 @@
+package gumble
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+	"layeh.com/gumble/gumble/varint"
+)
+
+// DefaultPort is the default port on which Mumble servers listen.
+const DefaultPort = 64738
+
+// Conn represents a control protocol connection to a Mumble client/server.
+type Conn struct {
+	sync.Mutex
+	net.Conn
+
+	MaximumPacketBytes int
+	Timeout            time.Duration
+
+	buffer []byte
+}
+
+// NewConn creates a new Conn with the given net.Conn.
+func NewConn(conn net.Conn) *Conn {
+	return &Conn{
+		Conn:               conn,
+		Timeout:            time.Second * 20,
+		MaximumPacketBytes: 1024 * 1024 * 10,
+	}
+}
+
+// ReadPacket reads a packet from the server. Returns the packet type, the
+// packet data, and nil on success.
+//
+// This function should only be called by a single go routine.
+func (c *Conn) ReadPacket() (uint16, []byte, error) {
+	c.Conn.SetReadDeadline(time.Now().Add(c.Timeout))
+	var header [6]byte
+	if _, err := io.ReadFull(c.Conn, header[:]); err != nil {
+		return 0, nil, err
+	}
+	pType := binary.BigEndian.Uint16(header[:])
+	pLength := binary.BigEndian.Uint32(header[2:])
+	pLengthInt := int(pLength)
+	if pLengthInt > c.MaximumPacketBytes {
+		return 0, nil, errors.New("gumble: packet larger than maximum allowed size")
+	}
+	if pLengthInt > len(c.buffer) {
+		c.buffer = make([]byte, pLengthInt)
+	}
+	if _, err := io.ReadFull(c.Conn, c.buffer[:pLengthInt]); err != nil {
+		return 0, nil, err
+	}
+	return pType, c.buffer[:pLengthInt], nil
+}
+
+// WriteAudio writes an audio packet to the connection.
+func (c *Conn) WriteAudio(format, target byte, sequence int64, final bool, data []byte, X, Y, Z *float32) error {
+	var buff [1 + varint.MaxVarintLen*2]byte
+	buff[0] = (format << 5) | target
+	n := varint.Encode(buff[1:], sequence)
+	if n == 0 {
+		return errors.New("gumble: varint out of range")
+	}
+	l := int64(len(data))
+	if final {
+		l |= 0x2000
+	}
+	m := varint.Encode(buff[1+n:], l)
+	if m == 0 {
+		return errors.New("gumble: varint out of range")
+	}
+	header := buff[:1+n+m]
+
+	var positionalLength int
+	if X != nil {
+		positionalLength = 3 * 4
+	}
+
+	c.Lock()
+	defer c.Unlock()
+
+	if err := c.writeHeader(1, uint32(len(header)+len(data)+positionalLength)); err != nil {
+		return err
+	}
+	if _, err := c.Conn.Write(header); err != nil {
+		return err
+	}
+	if _, err := c.Conn.Write(data); err != nil {
+		return err
+	}
+
+	if positionalLength > 0 {
+		if err := binary.Write(c.Conn, binary.LittleEndian, *X); err != nil {
+			return err
+		}
+		if err := binary.Write(c.Conn, binary.LittleEndian, *Y); err != nil {
+			return err
+		}
+		if err := binary.Write(c.Conn, binary.LittleEndian, *Z); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// WritePacket writes a data packet of the given type to the connection.
+func (c *Conn) WritePacket(ptype uint16, data []byte) error {
+	c.Lock()
+	defer c.Unlock()
+	if err := c.writeHeader(uint16(ptype), uint32(len(data))); err != nil {
+		return err
+	}
+	if _, err := c.Conn.Write(data); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Conn) writeHeader(pType uint16, pLength uint32) error {
+	var header [6]byte
+	binary.BigEndian.PutUint16(header[:], pType)
+	binary.BigEndian.PutUint32(header[2:], pLength)
+	if _, err := c.Conn.Write(header[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+// WriteProto writes a protocol buffer message to the connection.
+func (c *Conn) WriteProto(message proto.Message) error {
+	var protoType uint16
+	switch message.(type) {
+	case *MumbleProto.Version:
+		protoType = 0
+	case *MumbleProto.Authenticate:
+		protoType = 2
+	case *MumbleProto.Ping:
+		protoType = 3
+	case *MumbleProto.Reject:
+		protoType = 4
+	case *MumbleProto.ServerSync:
+		protoType = 5
+	case *MumbleProto.ChannelRemove:
+		protoType = 6
+	case *MumbleProto.ChannelState:
+		protoType = 7
+	case *MumbleProto.UserRemove:
+		protoType = 8
+	case *MumbleProto.UserState:
+		protoType = 9
+	case *MumbleProto.BanList:
+		protoType = 10
+	case *MumbleProto.TextMessage:
+		protoType = 11
+	case *MumbleProto.PermissionDenied:
+		protoType = 12
+	case *MumbleProto.ACL:
+		protoType = 13
+	case *MumbleProto.QueryUsers:
+		protoType = 14
+	case *MumbleProto.CryptSetup:
+		protoType = 15
+	case *MumbleProto.ContextActionModify:
+		protoType = 16
+	case *MumbleProto.ContextAction:
+		protoType = 17
+	case *MumbleProto.UserList:
+		protoType = 18
+	case *MumbleProto.VoiceTarget:
+		protoType = 19
+	case *MumbleProto.PermissionQuery:
+		protoType = 20
+	case *MumbleProto.CodecVersion:
+		protoType = 21
+	case *MumbleProto.UserStats:
+		protoType = 22
+	case *MumbleProto.RequestBlob:
+		protoType = 23
+	case *MumbleProto.ServerConfig:
+		protoType = 24
+	case *MumbleProto.SuggestConfig:
+		protoType = 25
+	default:
+		return errors.New("gumble: unknown message type")
+	}
+	data, err := proto.Marshal(message)
+	if err != nil {
+		return err
+	}
+	return c.WritePacket(protoType, data)
+}
diff --git a/vendor/layeh.com/gumble/gumble/contextaction.go b/vendor/layeh.com/gumble/gumble/contextaction.go
new file mode 100644
index 00000000..bee6b755
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/contextaction.go
@@ -0,0 +1,57 @@
+package gumble
+
+import (
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// ContextActionType is a bitmask of contexts where a ContextAction can be
+// triggered.
+type ContextActionType int
+
+// Supported ContextAction contexts.
+const (
+	ContextActionServer  ContextActionType = ContextActionType(MumbleProto.ContextActionModify_Server)
+	ContextActionChannel ContextActionType = ContextActionType(MumbleProto.ContextActionModify_Channel)
+	ContextActionUser    ContextActionType = ContextActionType(MumbleProto.ContextActionModify_User)
+)
+
+// ContextAction is an triggerable item that has been added by a server-side
+// plugin.
+type ContextAction struct {
+	// The context action type.
+	Type ContextActionType
+	// The name of the context action.
+	Name string
+	// The user-friendly description of the context action.
+	Label string
+
+	client *Client
+}
+
+// Trigger will trigger the context action in the context of the server.
+func (c *ContextAction) Trigger() {
+	packet := MumbleProto.ContextAction{
+		Action: &c.Name,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// TriggerUser will trigger the context action in the context of the given
+// user.
+func (c *ContextAction) TriggerUser(user *User) {
+	packet := MumbleProto.ContextAction{
+		Session: &user.Session,
+		Action:  &c.Name,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
+
+// TriggerChannel will trigger the context action in the context of the given
+// channel.
+func (c *ContextAction) TriggerChannel(channel *Channel) {
+	packet := MumbleProto.ContextAction{
+		ChannelId: &channel.ID,
+		Action:    &c.Name,
+	}
+	c.client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/contextactions.go b/vendor/layeh.com/gumble/gumble/contextactions.go
new file mode 100644
index 00000000..6dd0c169
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/contextactions.go
@@ -0,0 +1,12 @@
+package gumble
+
+// ContextActions is a map of ContextActions.
+type ContextActions map[string]*ContextAction
+
+func (c ContextActions) create(action string) *ContextAction {
+	contextAction := &ContextAction{
+		Name: action,
+	}
+	c[action] = contextAction
+	return contextAction
+}
diff --git a/vendor/layeh.com/gumble/gumble/detacher.go b/vendor/layeh.com/gumble/gumble/detacher.go
new file mode 100644
index 00000000..0594caac
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/detacher.go
@@ -0,0 +1,7 @@
+package gumble
+
+// Detacher is an interface that event listeners implement. After the Detach
+// method is called, the listener will no longer receive events.
+type Detacher interface {
+	Detach()
+}
diff --git a/vendor/layeh.com/gumble/gumble/doc.go b/vendor/layeh.com/gumble/gumble/doc.go
new file mode 100644
index 00000000..29115423
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/doc.go
@@ -0,0 +1,45 @@
+// Package gumble is a client for the Mumble voice chat software.
+//
+// Getting started
+//
+// 1. Create a new Config to hold your connection settings:
+//
+//        config := gumble.NewConfig()
+//        config.Username = "gumble-test"
+//
+// 2. Attach event listeners to the configuration:
+//
+//        config.Attach(gumbleutil.Listener{
+//            TextMessage: func(e *gumble.TextMessageEvent) {
+//                fmt.Printf("Received text message: %s\n", e.Message)
+//            },
+//        })
+//
+// 3. Connect to the server:
+//
+//        client, err := gumble.Dial("example.com:64738", config)
+//        if err != nil {
+//            panic(err)
+//        }
+//
+// Audio codecs
+//
+// Currently, only the Opus codec (https://www.opus-codec.org/) is supported
+// for transmitting and receiving audio. It can be enabled by importing the
+// following package for its side effect:
+//  import (
+//      _ "layeh.com/gumble/opus"
+//  )
+//
+// To ensure that gumble clients can always transmit and receive audio to and
+// from your server, add the following line to your murmur configuration file:
+//
+//  opusthreshold=0
+//
+// Thread safety
+//
+// As a general rule, a Client everything that is associated with it
+// (Users, Channels, Config, etc.), is thread-unsafe. Accessing or modifying
+// those structures should only be done from inside of an event listener or via
+// Client.Do.
+package gumble
diff --git a/vendor/layeh.com/gumble/gumble/event.go b/vendor/layeh.com/gumble/gumble/event.go
new file mode 100644
index 00000000..cc088673
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/event.go
@@ -0,0 +1,223 @@
+package gumble
+
+import (
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// EventListener is the interface that must be implemented by a type if it
+// wishes to be notified of Client events.
+//
+// Listener methods are executed synchronously as event happen. They also block
+// network reads from happening until all handlers for an event are called.
+// Therefore, it is not recommended to do any long processing from inside of
+// these methods.
+type EventListener interface {
+	OnConnect(e *ConnectEvent)
+	OnDisconnect(e *DisconnectEvent)
+	OnTextMessage(e *TextMessageEvent)
+	OnUserChange(e *UserChangeEvent)
+	OnChannelChange(e *ChannelChangeEvent)
+	OnPermissionDenied(e *PermissionDeniedEvent)
+	OnUserList(e *UserListEvent)
+	OnACL(e *ACLEvent)
+	OnBanList(e *BanListEvent)
+	OnContextActionChange(e *ContextActionChangeEvent)
+	OnServerConfig(e *ServerConfigEvent)
+}
+
+// ConnectEvent is the event that is passed to EventListener.OnConnect.
+type ConnectEvent struct {
+	Client         *Client
+	WelcomeMessage *string
+	MaximumBitrate *int
+}
+
+// DisconnectType specifies why a Client disconnected from a server.
+type DisconnectType int
+
+// Client disconnect reasons.
+const (
+	DisconnectError DisconnectType = iota + 1
+	DisconnectKicked
+	DisconnectBanned
+	DisconnectUser
+)
+
+// Has returns true if the DisconnectType has changeType part of its bitmask.
+func (d DisconnectType) Has(changeType DisconnectType) bool {
+	return d&changeType == changeType
+}
+
+// DisconnectEvent is the event that is passed to EventListener.OnDisconnect.
+type DisconnectEvent struct {
+	Client *Client
+	Type   DisconnectType
+
+	String string
+}
+
+// TextMessageEvent is the event that is passed to EventListener.OnTextMessage.
+type TextMessageEvent struct {
+	Client *Client
+	TextMessage
+}
+
+// UserChangeType is a bitmask of items that changed for a user.
+type UserChangeType int
+
+// User change items.
+const (
+	UserChangeConnected UserChangeType = 1 << iota
+	UserChangeDisconnected
+	UserChangeKicked
+	UserChangeBanned
+	UserChangeRegistered
+	UserChangeUnregistered
+	UserChangeName
+	UserChangeChannel
+	UserChangeComment
+	UserChangeAudio
+	UserChangeTexture
+	UserChangePrioritySpeaker
+	UserChangeRecording
+	UserChangeStats
+)
+
+// Has returns true if the UserChangeType has changeType part of its bitmask.
+func (u UserChangeType) Has(changeType UserChangeType) bool {
+	return u&changeType == changeType
+}
+
+// UserChangeEvent is the event that is passed to EventListener.OnUserChange.
+type UserChangeEvent struct {
+	Client *Client
+	Type   UserChangeType
+	User   *User
+	Actor  *User
+
+	String string
+}
+
+// ChannelChangeType is a bitmask of items that changed for a channel.
+type ChannelChangeType int
+
+// Channel change items.
+const (
+	ChannelChangeCreated ChannelChangeType = 1 << iota
+	ChannelChangeRemoved
+	ChannelChangeMoved
+	ChannelChangeName
+	ChannelChangeLinks
+	ChannelChangeDescription
+	ChannelChangePosition
+	ChannelChangePermission
+	ChannelChangeMaxUsers
+)
+
+// Has returns true if the ChannelChangeType has changeType part of its
+// bitmask.
+func (c ChannelChangeType) Has(changeType ChannelChangeType) bool {
+	return c&changeType == changeType
+}
+
+// ChannelChangeEvent is the event that is passed to
+// EventListener.OnChannelChange.
+type ChannelChangeEvent struct {
+	Client  *Client
+	Type    ChannelChangeType
+	Channel *Channel
+}
+
+// PermissionDeniedType specifies why a Client was denied permission to perform
+// a particular action.
+type PermissionDeniedType int
+
+// Permission denied types.
+const (
+	PermissionDeniedOther              PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_Text)
+	PermissionDeniedPermission         PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_Permission)
+	PermissionDeniedSuperUser          PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_SuperUser)
+	PermissionDeniedInvalidChannelName PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_ChannelName)
+	PermissionDeniedTextTooLong        PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_TextTooLong)
+	PermissionDeniedTemporaryChannel   PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_TemporaryChannel)
+	PermissionDeniedMissingCertificate PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_MissingCertificate)
+	PermissionDeniedInvalidUserName    PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_UserName)
+	PermissionDeniedChannelFull        PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_ChannelFull)
+	PermissionDeniedNestingLimit       PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_NestingLimit)
+	PermissionDeniedChannelCountLimit  PermissionDeniedType = PermissionDeniedType(MumbleProto.PermissionDenied_ChannelCountLimit)
+)
+
+// Has returns true if the PermissionDeniedType has changeType part of its
+// bitmask.
+func (p PermissionDeniedType) Has(changeType PermissionDeniedType) bool {
+	return p&changeType == changeType
+}
+
+// PermissionDeniedEvent is the event that is passed to
+// EventListener.OnPermissionDenied.
+type PermissionDeniedEvent struct {
+	Client  *Client
+	Type    PermissionDeniedType
+	Channel *Channel
+	User    *User
+
+	Permission Permission
+	String     string
+}
+
+// UserListEvent is the event that is passed to EventListener.OnUserList.
+type UserListEvent struct {
+	Client   *Client
+	UserList RegisteredUsers
+}
+
+// ACLEvent is the event that is passed to EventListener.OnACL.
+type ACLEvent struct {
+	Client *Client
+	ACL    *ACL
+}
+
+// BanListEvent is the event that is passed to EventListener.OnBanList.
+type BanListEvent struct {
+	Client  *Client
+	BanList BanList
+}
+
+// ContextActionChangeType specifies how a ContextAction changed.
+type ContextActionChangeType int
+
+// ContextAction change types.
+const (
+	ContextActionAdd    ContextActionChangeType = ContextActionChangeType(MumbleProto.ContextActionModify_Add)
+	ContextActionRemove ContextActionChangeType = ContextActionChangeType(MumbleProto.ContextActionModify_Remove)
+)
+
+// ContextActionChangeEvent is the event that is passed to
+// EventListener.OnContextActionChange.
+type ContextActionChangeEvent struct {
+	Client        *Client
+	Type          ContextActionChangeType
+	ContextAction *ContextAction
+}
+
+// ServerConfigEvent is the event that is passed to
+// EventListener.OnServerConfig.
+type ServerConfigEvent struct {
+	Client *Client
+
+	MaximumBitrate            *int
+	WelcomeMessage            *string
+	AllowHTML                 *bool
+	MaximumMessageLength      *int
+	MaximumImageMessageLength *int
+	MaximumUsers              *int
+
+	CodecAlpha       *int32
+	CodecBeta        *int32
+	CodecPreferAlpha *bool
+	CodecOpus        *bool
+
+	SuggestVersion    *Version
+	SuggestPositional *bool
+	SuggestPushToTalk *bool
+}
diff --git a/vendor/layeh.com/gumble/gumble/handlers.go b/vendor/layeh.com/gumble/gumble/handlers.go
new file mode 100644
index 00000000..a5b012d6
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/handlers.go
@@ -0,0 +1,1261 @@
+package gumble
+
+import (
+	"crypto/x509"
+	"encoding/binary"
+	"errors"
+	"math"
+	"net"
+	"sync/atomic"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+	"layeh.com/gumble/gumble/varint"
+)
+
+var (
+	errUnimplementedHandler = errors.New("gumble: the handler has not been implemented")
+	errIncompleteProtobuf   = errors.New("gumble: protobuf message is missing a required field")
+	errInvalidProtobuf      = errors.New("gumble: protobuf message has an invalid field")
+	errUnsupportedAudio     = errors.New("gumble: unsupported audio codec")
+	errNoCodec              = errors.New("gumble: no audio codec")
+)
+
+var handlers = [...]func(*Client, []byte) error{
+	(*Client).handleVersion,
+	(*Client).handleUDPTunnel,
+	(*Client).handleAuthenticate,
+	(*Client).handlePing,
+	(*Client).handleReject,
+	(*Client).handleServerSync,
+	(*Client).handleChannelRemove,
+	(*Client).handleChannelState,
+	(*Client).handleUserRemove,
+	(*Client).handleUserState,
+	(*Client).handleBanList,
+	(*Client).handleTextMessage,
+	(*Client).handlePermissionDenied,
+	(*Client).handleACL,
+	(*Client).handleQueryUsers,
+	(*Client).handleCryptSetup,
+	(*Client).handleContextActionModify,
+	(*Client).handleContextAction,
+	(*Client).handleUserList,
+	(*Client).handleVoiceTarget,
+	(*Client).handlePermissionQuery,
+	(*Client).handleCodecVersion,
+	(*Client).handleUserStats,
+	(*Client).handleRequestBlob,
+	(*Client).handleServerConfig,
+	(*Client).handleSuggestConfig,
+}
+
+func parseVersion(packet *MumbleProto.Version) Version {
+	var version Version
+	if packet.Version != nil {
+		version.Version = *packet.Version
+	}
+	if packet.Release != nil {
+		version.Release = *packet.Release
+	}
+	if packet.Os != nil {
+		version.OS = *packet.Os
+	}
+	if packet.OsVersion != nil {
+		version.OSVersion = *packet.OsVersion
+	}
+	return version
+}
+
+func (c *Client) handleVersion(buffer []byte) error {
+	var packet MumbleProto.Version
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Client) handleUDPTunnel(buffer []byte) error {
+	if len(buffer) < 1 {
+		return errInvalidProtobuf
+	}
+	audioType := (buffer[0] >> 5) & 0x7
+	audioTarget := buffer[0] & 0x1F
+
+	// Opus only
+	// TODO: add handling for other packet types
+	if audioType != audioCodecIDOpus {
+		return errUnsupportedAudio
+	}
+
+	// Session
+	buffer = buffer[1:]
+	session, n := varint.Decode(buffer)
+	if n <= 0 {
+		return errInvalidProtobuf
+	}
+	buffer = buffer[n:]
+	user := c.Users[uint32(session)]
+	if user == nil {
+		return errInvalidProtobuf
+	}
+	decoder := user.decoder
+	if decoder == nil {
+		// TODO: decoder pool
+		// TODO: de-reference after stream is done
+		codec := c.audioCodec
+		if codec == nil {
+			return errNoCodec
+		}
+		decoder = codec.NewDecoder()
+		user.decoder = decoder
+	}
+
+	// Sequence
+	// TODO: use in jitter buffer
+	_, n = varint.Decode(buffer)
+	if n <= 0 {
+		return errInvalidProtobuf
+	}
+	buffer = buffer[n:]
+
+	// Length
+	length, n := varint.Decode(buffer)
+	if n <= 0 {
+		return errInvalidProtobuf
+	}
+	buffer = buffer[n:]
+	// Opus audio packets set the 13th bit in the size field as the terminator.
+	audioLength := int(length) &^ 0x2000
+	if audioLength > len(buffer) {
+		return errInvalidProtobuf
+	}
+
+	pcm, err := decoder.Decode(buffer[:audioLength], AudioMaximumFrameSize)
+	if err != nil {
+		return err
+	}
+
+	event := AudioPacket{
+		Client: c,
+		Sender: user,
+		Target: &VoiceTarget{
+			ID: uint32(audioTarget),
+		},
+		AudioBuffer: AudioBuffer(pcm),
+	}
+
+	if len(buffer)-audioLength == 3*4 {
+		// the packet has positional audio data; 3x float32
+		buffer = buffer[audioLength:]
+
+		event.X = math.Float32frombits(binary.LittleEndian.Uint32(buffer))
+		event.Y = math.Float32frombits(binary.LittleEndian.Uint32(buffer[4:]))
+		event.Z = math.Float32frombits(binary.LittleEndian.Uint32(buffer[8:]))
+		event.HasPosition = true
+	}
+
+	c.volatile.Lock()
+	for item := c.Config.AudioListeners.head; item != nil; item = item.next {
+		c.volatile.Unlock()
+		ch := item.streams[user]
+		if ch == nil {
+			ch = make(chan *AudioPacket)
+			item.streams[user] = ch
+			event := AudioStreamEvent{
+				Client: c,
+				User:   user,
+				C:      ch,
+			}
+			item.listener.OnAudioStream(&event)
+		}
+		ch <- &event
+		c.volatile.Lock()
+	}
+	c.volatile.Unlock()
+
+	return nil
+}
+
+func (c *Client) handleAuthenticate(buffer []byte) error {
+	return errUnimplementedHandler
+}
+
+func (c *Client) handlePing(buffer []byte) error {
+	var packet MumbleProto.Ping
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	atomic.AddUint32(&c.tcpPacketsReceived, 1)
+
+	if packet.Timestamp != nil {
+		diff := time.Since(time.Unix(0, int64(*packet.Timestamp)))
+
+		index := int(c.tcpPacketsReceived) - 1
+		if index >= len(c.tcpPingTimes) {
+			for i := 1; i < len(c.tcpPingTimes); i++ {
+				c.tcpPingTimes[i-1] = c.tcpPingTimes[i]
+			}
+			index = len(c.tcpPingTimes) - 1
+		}
+
+		// average is in milliseconds
+		ping := float32(diff.Seconds() * 1000)
+		c.tcpPingTimes[index] = ping
+
+		var sum float32
+		for i := 0; i <= index; i++ {
+			sum += c.tcpPingTimes[i]
+		}
+		avg := sum / float32(index+1)
+
+		sum = 0
+		for i := 0; i <= index; i++ {
+			sum += (avg - c.tcpPingTimes[i]) * (avg - c.tcpPingTimes[i])
+		}
+		variance := sum / float32(index+1)
+
+		atomic.StoreUint32(&c.tcpPingAvg, math.Float32bits(avg))
+		atomic.StoreUint32(&c.tcpPingVar, math.Float32bits(variance))
+	}
+	return nil
+}
+
+func (c *Client) handleReject(buffer []byte) error {
+	var packet MumbleProto.Reject
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if c.State() != StateConnected {
+		return errInvalidProtobuf
+	}
+
+	err := &RejectError{}
+
+	if packet.Type != nil {
+		err.Type = RejectType(*packet.Type)
+	}
+	if packet.Reason != nil {
+		err.Reason = *packet.Reason
+	}
+	c.connect <- err
+	c.Conn.Close()
+	return nil
+}
+
+func (c *Client) handleServerSync(buffer []byte) error {
+	var packet MumbleProto.ServerSync
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+	event := ConnectEvent{
+		Client: c,
+	}
+
+	if packet.Session != nil {
+		{
+			c.volatile.Lock()
+
+			c.Self = c.Users[*packet.Session]
+
+			c.volatile.Unlock()
+		}
+	}
+	if packet.WelcomeText != nil {
+		event.WelcomeMessage = packet.WelcomeText
+	}
+	if packet.MaxBandwidth != nil {
+		val := int(*packet.MaxBandwidth)
+		event.MaximumBitrate = &val
+	}
+	atomic.StoreUint32(&c.state, uint32(StateSynced))
+	c.Config.Listeners.onConnect(&event)
+	close(c.connect)
+	return nil
+}
+
+func (c *Client) handleChannelRemove(buffer []byte) error {
+	var packet MumbleProto.ChannelRemove
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.ChannelId == nil {
+		return errIncompleteProtobuf
+	}
+
+	var channel *Channel
+	{
+		c.volatile.Lock()
+
+		channelID := *packet.ChannelId
+		channel = c.Channels[channelID]
+		if channel == nil {
+			c.volatile.Unlock()
+			return errInvalidProtobuf
+		}
+		channel.client = nil
+		delete(c.Channels, channelID)
+		delete(c.permissions, channelID)
+		if parent := channel.Parent; parent != nil {
+			delete(parent.Children, channel.ID)
+		}
+		for _, link := range channel.Links {
+			delete(link.Links, channelID)
+		}
+
+		c.volatile.Unlock()
+	}
+
+	if c.State() == StateSynced {
+		event := ChannelChangeEvent{
+			Client:  c,
+			Type:    ChannelChangeRemoved,
+			Channel: channel,
+		}
+		c.Config.Listeners.onChannelChange(&event)
+	}
+	return nil
+}
+
+func (c *Client) handleChannelState(buffer []byte) error {
+	var packet MumbleProto.ChannelState
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.ChannelId == nil {
+		return errIncompleteProtobuf
+	}
+	event := ChannelChangeEvent{
+		Client: c,
+	}
+
+	{
+		c.volatile.Lock()
+
+		channelID := *packet.ChannelId
+		channel := c.Channels[channelID]
+		if channel == nil {
+			channel = c.Channels.create(channelID)
+			channel.client = c
+
+			event.Type |= ChannelChangeCreated
+		}
+		event.Channel = channel
+		if packet.Parent != nil {
+			if channel.Parent != nil {
+				delete(channel.Parent.Children, channelID)
+			}
+			newParent := c.Channels[*packet.Parent]
+			if newParent != channel.Parent {
+				event.Type |= ChannelChangeMoved
+			}
+			channel.Parent = newParent
+			if channel.Parent != nil {
+				channel.Parent.Children[channel.ID] = channel
+			}
+		}
+		if packet.Name != nil {
+			if *packet.Name != channel.Name {
+				event.Type |= ChannelChangeName
+			}
+			channel.Name = *packet.Name
+		}
+		if packet.Links != nil {
+			channel.Links = make(Channels)
+			event.Type |= ChannelChangeLinks
+			for _, channelID := range packet.Links {
+				if c := c.Channels[channelID]; c != nil {
+					channel.Links[channelID] = c
+				}
+			}
+		}
+		for _, channelID := range packet.LinksAdd {
+			if c := c.Channels[channelID]; c != nil {
+				event.Type |= ChannelChangeLinks
+				channel.Links[channelID] = c
+				c.Links[channel.ID] = channel
+			}
+		}
+		for _, channelID := range packet.LinksRemove {
+			if c := c.Channels[channelID]; c != nil {
+				event.Type |= ChannelChangeLinks
+				delete(channel.Links, channelID)
+				delete(c.Links, channel.ID)
+			}
+		}
+		if packet.Description != nil {
+			if *packet.Description != channel.Description {
+				event.Type |= ChannelChangeDescription
+			}
+			channel.Description = *packet.Description
+			channel.DescriptionHash = nil
+		}
+		if packet.Temporary != nil {
+			channel.Temporary = *packet.Temporary
+		}
+		if packet.Position != nil {
+			if *packet.Position != channel.Position {
+				event.Type |= ChannelChangePosition
+			}
+			channel.Position = *packet.Position
+		}
+		if packet.DescriptionHash != nil {
+			event.Type |= ChannelChangeDescription
+			channel.DescriptionHash = packet.DescriptionHash
+			channel.Description = ""
+		}
+		if packet.MaxUsers != nil {
+			event.Type |= ChannelChangeMaxUsers
+			channel.MaxUsers = *packet.MaxUsers
+		}
+
+		c.volatile.Unlock()
+	}
+
+	if c.State() == StateSynced {
+		c.Config.Listeners.onChannelChange(&event)
+	}
+	return nil
+}
+
+func (c *Client) handleUserRemove(buffer []byte) error {
+	var packet MumbleProto.UserRemove
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.Session == nil {
+		return errIncompleteProtobuf
+	}
+	event := UserChangeEvent{
+		Client: c,
+		Type:   UserChangeDisconnected,
+	}
+
+	{
+		c.volatile.Lock()
+
+		session := *packet.Session
+		event.User = c.Users[session]
+		if event.User == nil {
+			c.volatile.Unlock()
+			return errInvalidProtobuf
+		}
+		if packet.Actor != nil {
+			event.Actor = c.Users[*packet.Actor]
+			if event.Actor == nil {
+				c.volatile.Unlock()
+				return errInvalidProtobuf
+			}
+			event.Type |= UserChangeKicked
+		}
+
+		event.User.client = nil
+		if event.User.Channel != nil {
+			delete(event.User.Channel.Users, session)
+		}
+		delete(c.Users, session)
+		if packet.Reason != nil {
+			event.String = *packet.Reason
+		}
+		if packet.Ban != nil && *packet.Ban {
+			event.Type |= UserChangeBanned
+		}
+		if event.User == c.Self {
+			if packet.Ban != nil && *packet.Ban {
+				c.disconnectEvent.Type = DisconnectBanned
+			} else {
+				c.disconnectEvent.Type = DisconnectKicked
+			}
+		}
+
+		c.volatile.Unlock()
+	}
+
+	if c.State() == StateSynced {
+		c.Config.Listeners.onUserChange(&event)
+	}
+	return nil
+}
+
+func (c *Client) handleUserState(buffer []byte) error {
+	var packet MumbleProto.UserState
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.Session == nil {
+		return errIncompleteProtobuf
+	}
+	event := UserChangeEvent{
+		Client: c,
+	}
+	var user, actor *User
+	{
+		c.volatile.Lock()
+
+		session := *packet.Session
+		user = c.Users[session]
+		if user == nil {
+			user = c.Users.create(session)
+			user.Channel = c.Channels[0]
+			user.client = c
+
+			event.Type |= UserChangeConnected
+
+			if user.Channel == nil {
+				c.volatile.Unlock()
+				return errInvalidProtobuf
+			}
+			event.Type |= UserChangeChannel
+			user.Channel.Users[session] = user
+		}
+
+		event.User = user
+		if packet.Actor != nil {
+			actor = c.Users[*packet.Actor]
+			if actor == nil {
+				c.volatile.Unlock()
+				return errInvalidProtobuf
+			}
+			event.Actor = actor
+		}
+		if packet.Name != nil {
+			if *packet.Name != user.Name {
+				event.Type |= UserChangeName
+			}
+			user.Name = *packet.Name
+		}
+		if packet.UserId != nil {
+			if *packet.UserId != user.UserID && !event.Type.Has(UserChangeConnected) {
+				if *packet.UserId != math.MaxUint32 {
+					event.Type |= UserChangeRegistered
+					user.UserID = *packet.UserId
+				} else {
+					event.Type |= UserChangeUnregistered
+					user.UserID = 0
+				}
+			} else {
+				user.UserID = *packet.UserId
+			}
+		}
+		if packet.ChannelId != nil {
+			if user.Channel != nil {
+				delete(user.Channel.Users, user.Session)
+			}
+			newChannel := c.Channels[*packet.ChannelId]
+			if newChannel == nil {
+				c.volatile.Lock()
+				return errInvalidProtobuf
+			}
+			if newChannel != user.Channel {
+				event.Type |= UserChangeChannel
+				user.Channel = newChannel
+			}
+			user.Channel.Users[user.Session] = user
+		}
+		if packet.Mute != nil {
+			if *packet.Mute != user.Muted {
+				event.Type |= UserChangeAudio
+			}
+			user.Muted = *packet.Mute
+		}
+		if packet.Deaf != nil {
+			if *packet.Deaf != user.Deafened {
+				event.Type |= UserChangeAudio
+			}
+			user.Deafened = *packet.Deaf
+		}
+		if packet.Suppress != nil {
+			if *packet.Suppress != user.Suppressed {
+				event.Type |= UserChangeAudio
+			}
+			user.Suppressed = *packet.Suppress
+		}
+		if packet.SelfMute != nil {
+			if *packet.SelfMute != user.SelfMuted {
+				event.Type |= UserChangeAudio
+			}
+			user.SelfMuted = *packet.SelfMute
+		}
+		if packet.SelfDeaf != nil {
+			if *packet.SelfDeaf != user.SelfDeafened {
+				event.Type |= UserChangeAudio
+			}
+			user.SelfDeafened = *packet.SelfDeaf
+		}
+		if packet.Texture != nil {
+			event.Type |= UserChangeTexture
+			user.Texture = packet.Texture
+			user.TextureHash = nil
+		}
+		if packet.Comment != nil {
+			if *packet.Comment != user.Comment {
+				event.Type |= UserChangeComment
+			}
+			user.Comment = *packet.Comment
+			user.CommentHash = nil
+		}
+		if packet.Hash != nil {
+			user.Hash = *packet.Hash
+		}
+		if packet.CommentHash != nil {
+			event.Type |= UserChangeComment
+			user.CommentHash = packet.CommentHash
+			user.Comment = ""
+		}
+		if packet.TextureHash != nil {
+			event.Type |= UserChangeTexture
+			user.TextureHash = packet.TextureHash
+			user.Texture = nil
+		}
+		if packet.PrioritySpeaker != nil {
+			if *packet.PrioritySpeaker != user.PrioritySpeaker {
+				event.Type |= UserChangePrioritySpeaker
+			}
+			user.PrioritySpeaker = *packet.PrioritySpeaker
+		}
+		if packet.Recording != nil {
+			if *packet.Recording != user.Recording {
+				event.Type |= UserChangeRecording
+			}
+			user.Recording = *packet.Recording
+		}
+
+		c.volatile.Unlock()
+	}
+
+	if c.State() == StateSynced {
+		c.Config.Listeners.onUserChange(&event)
+	}
+	return nil
+}
+
+func (c *Client) handleBanList(buffer []byte) error {
+	var packet MumbleProto.BanList
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	event := BanListEvent{
+		Client:  c,
+		BanList: make(BanList, 0, len(packet.Bans)),
+	}
+
+	for _, banPacket := range packet.Bans {
+		ban := &Ban{
+			Address: net.IP(banPacket.Address),
+		}
+		if banPacket.Mask != nil {
+			size := net.IPv4len * 8
+			if len(ban.Address) == net.IPv6len {
+				size = net.IPv6len * 8
+			}
+			ban.Mask = net.CIDRMask(int(*banPacket.Mask), size)
+		}
+		if banPacket.Name != nil {
+			ban.Name = *banPacket.Name
+		}
+		if banPacket.Hash != nil {
+			ban.Hash = *banPacket.Hash
+		}
+		if banPacket.Reason != nil {
+			ban.Reason = *banPacket.Reason
+		}
+		if banPacket.Start != nil {
+			ban.Start, _ = time.Parse(time.RFC3339, *banPacket.Start)
+		}
+		if banPacket.Duration != nil {
+			ban.Duration = time.Duration(*banPacket.Duration) * time.Second
+		}
+		event.BanList = append(event.BanList, ban)
+	}
+
+	c.Config.Listeners.onBanList(&event)
+	return nil
+}
+
+func (c *Client) handleTextMessage(buffer []byte) error {
+	var packet MumbleProto.TextMessage
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	event := TextMessageEvent{
+		Client: c,
+	}
+	if packet.Actor != nil {
+		event.Sender = c.Users[*packet.Actor]
+	}
+	if packet.Session != nil {
+		event.Users = make([]*User, 0, len(packet.Session))
+		for _, session := range packet.Session {
+			if user := c.Users[session]; user != nil {
+				event.Users = append(event.Users, user)
+			}
+		}
+	}
+	if packet.ChannelId != nil {
+		event.Channels = make([]*Channel, 0, len(packet.ChannelId))
+		for _, id := range packet.ChannelId {
+			if channel := c.Channels[id]; channel != nil {
+				event.Channels = append(event.Channels, channel)
+			}
+		}
+	}
+	if packet.TreeId != nil {
+		event.Trees = make([]*Channel, 0, len(packet.TreeId))
+		for _, id := range packet.TreeId {
+			if channel := c.Channels[id]; channel != nil {
+				event.Trees = append(event.Trees, channel)
+			}
+		}
+	}
+	if packet.Message != nil {
+		event.Message = *packet.Message
+	}
+
+	c.Config.Listeners.onTextMessage(&event)
+	return nil
+}
+
+func (c *Client) handlePermissionDenied(buffer []byte) error {
+	var packet MumbleProto.PermissionDenied
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.Type == nil || *packet.Type == MumbleProto.PermissionDenied_H9K {
+		return errInvalidProtobuf
+	}
+
+	event := PermissionDeniedEvent{
+		Client: c,
+		Type:   PermissionDeniedType(*packet.Type),
+	}
+	if packet.Reason != nil {
+		event.String = *packet.Reason
+	}
+	if packet.Name != nil {
+		event.String = *packet.Name
+	}
+	if packet.Session != nil {
+		event.User = c.Users[*packet.Session]
+		if event.User == nil {
+			return errInvalidProtobuf
+		}
+	}
+	if packet.ChannelId != nil {
+		event.Channel = c.Channels[*packet.ChannelId]
+		if event.Channel == nil {
+			return errInvalidProtobuf
+		}
+	}
+	if packet.Permission != nil {
+		event.Permission = Permission(*packet.Permission)
+	}
+
+	c.Config.Listeners.onPermissionDenied(&event)
+	return nil
+}
+
+func (c *Client) handleACL(buffer []byte) error {
+	var packet MumbleProto.ACL
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	acl := &ACL{
+		Inherits: packet.GetInheritAcls(),
+	}
+	if packet.ChannelId == nil {
+		return errInvalidProtobuf
+	}
+	acl.Channel = c.Channels[*packet.ChannelId]
+	if acl.Channel == nil {
+		return errInvalidProtobuf
+	}
+
+	if packet.Groups != nil {
+		acl.Groups = make([]*ACLGroup, 0, len(packet.Groups))
+		for _, group := range packet.Groups {
+			aclGroup := &ACLGroup{
+				Name:         *group.Name,
+				Inherited:    group.GetInherited(),
+				InheritUsers: group.GetInherit(),
+				Inheritable:  group.GetInheritable(),
+			}
+			if group.Add != nil {
+				aclGroup.UsersAdd = make(map[uint32]*ACLUser)
+				for _, userID := range group.Add {
+					aclGroup.UsersAdd[userID] = &ACLUser{
+						UserID: userID,
+					}
+				}
+			}
+			if group.Remove != nil {
+				aclGroup.UsersRemove = make(map[uint32]*ACLUser)
+				for _, userID := range group.Remove {
+					aclGroup.UsersRemove[userID] = &ACLUser{
+						UserID: userID,
+					}
+				}
+			}
+			if group.InheritedMembers != nil {
+				aclGroup.UsersInherited = make(map[uint32]*ACLUser)
+				for _, userID := range group.InheritedMembers {
+					aclGroup.UsersInherited[userID] = &ACLUser{
+						UserID: userID,
+					}
+				}
+			}
+			acl.Groups = append(acl.Groups, aclGroup)
+		}
+	}
+	if packet.Acls != nil {
+		acl.Rules = make([]*ACLRule, 0, len(packet.Acls))
+		for _, rule := range packet.Acls {
+			aclRule := &ACLRule{
+				AppliesCurrent:  rule.GetApplyHere(),
+				AppliesChildren: rule.GetApplySubs(),
+				Inherited:       rule.GetInherited(),
+				Granted:         Permission(rule.GetGrant()),
+				Denied:          Permission(rule.GetDeny()),
+			}
+			if rule.UserId != nil {
+				aclRule.User = &ACLUser{
+					UserID: *rule.UserId,
+				}
+			} else if rule.Group != nil {
+				var group *ACLGroup
+				for _, g := range acl.Groups {
+					if g.Name == *rule.Group {
+						group = g
+						break
+					}
+				}
+				if group == nil {
+					group = &ACLGroup{
+						Name: *rule.Group,
+					}
+				}
+				aclRule.Group = group
+			}
+			acl.Rules = append(acl.Rules, aclRule)
+		}
+	}
+	c.tmpACL = acl
+	return nil
+}
+
+func (c *Client) handleQueryUsers(buffer []byte) error {
+	var packet MumbleProto.QueryUsers
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	acl := c.tmpACL
+	if acl == nil {
+		return errIncompleteProtobuf
+	}
+	c.tmpACL = nil
+
+	userMap := make(map[uint32]string)
+	for i := 0; i < len(packet.Ids) && i < len(packet.Names); i++ {
+		userMap[packet.Ids[i]] = packet.Names[i]
+	}
+
+	for _, group := range acl.Groups {
+		for _, user := range group.UsersAdd {
+			user.Name = userMap[user.UserID]
+		}
+		for _, user := range group.UsersRemove {
+			user.Name = userMap[user.UserID]
+		}
+		for _, user := range group.UsersInherited {
+			user.Name = userMap[user.UserID]
+		}
+	}
+	for _, rule := range acl.Rules {
+		if rule.User != nil {
+			rule.User.Name = userMap[rule.User.UserID]
+		}
+	}
+
+	event := ACLEvent{
+		Client: c,
+		ACL:    acl,
+	}
+	c.Config.Listeners.onACL(&event)
+	return nil
+}
+
+func (c *Client) handleCryptSetup(buffer []byte) error {
+	return errUnimplementedHandler
+}
+
+func (c *Client) handleContextActionModify(buffer []byte) error {
+	var packet MumbleProto.ContextActionModify
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.Action == nil || packet.Operation == nil {
+		return errInvalidProtobuf
+	}
+
+	event := ContextActionChangeEvent{
+		Client: c,
+	}
+
+	{
+		c.volatile.Lock()
+
+		switch *packet.Operation {
+		case MumbleProto.ContextActionModify_Add:
+			if ca := c.ContextActions[*packet.Action]; ca != nil {
+				c.volatile.Unlock()
+				return nil
+			}
+			event.Type = ContextActionAdd
+			contextAction := c.ContextActions.create(*packet.Action)
+			if packet.Text != nil {
+				contextAction.Label = *packet.Text
+			}
+			if packet.Context != nil {
+				contextAction.Type = ContextActionType(*packet.Context)
+			}
+			event.ContextAction = contextAction
+		case MumbleProto.ContextActionModify_Remove:
+			contextAction := c.ContextActions[*packet.Action]
+			if contextAction == nil {
+				c.volatile.Unlock()
+				return nil
+			}
+			event.Type = ContextActionRemove
+			delete(c.ContextActions, *packet.Action)
+			event.ContextAction = contextAction
+		default:
+			c.volatile.Unlock()
+			return errInvalidProtobuf
+		}
+
+		c.volatile.Unlock()
+	}
+
+	c.Config.Listeners.onContextActionChange(&event)
+	return nil
+}
+
+func (c *Client) handleContextAction(buffer []byte) error {
+	return errUnimplementedHandler
+}
+
+func (c *Client) handleUserList(buffer []byte) error {
+	var packet MumbleProto.UserList
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	event := UserListEvent{
+		Client:   c,
+		UserList: make(RegisteredUsers, 0, len(packet.Users)),
+	}
+
+	for _, user := range packet.Users {
+		registeredUser := &RegisteredUser{
+			UserID: *user.UserId,
+		}
+		if user.Name != nil {
+			registeredUser.Name = *user.Name
+		}
+		if user.LastSeen != nil {
+			registeredUser.LastSeen, _ = time.ParseInLocation(time.RFC3339, *user.LastSeen, nil)
+		}
+		if user.LastChannel != nil {
+			if lastChannel := c.Channels[*user.LastChannel]; lastChannel != nil {
+				registeredUser.LastChannel = lastChannel
+			}
+		}
+		event.UserList = append(event.UserList, registeredUser)
+	}
+
+	c.Config.Listeners.onUserList(&event)
+	return nil
+}
+
+func (c *Client) handleVoiceTarget(buffer []byte) error {
+	return errUnimplementedHandler
+}
+
+func (c *Client) handlePermissionQuery(buffer []byte) error {
+	var packet MumbleProto.PermissionQuery
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	var singleChannel *Channel
+	if packet.ChannelId != nil && packet.Permissions != nil {
+		singleChannel = c.Channels[*packet.ChannelId]
+		if singleChannel == nil {
+			return errInvalidProtobuf
+		}
+	}
+
+	var changedChannels []*Channel
+
+	{
+		c.volatile.Lock()
+
+		if packet.GetFlush() {
+			oldPermissions := c.permissions
+			c.permissions = make(map[uint32]*Permission)
+			changedChannels = make([]*Channel, 0, len(oldPermissions))
+			for channelID := range oldPermissions {
+				changedChannels = append(changedChannels, c.Channels[channelID])
+			}
+		}
+
+		if singleChannel != nil {
+			p := Permission(*packet.Permissions)
+			c.permissions[singleChannel.ID] = &p
+			changedChannels = append(changedChannels, singleChannel)
+		}
+
+		c.volatile.Unlock()
+	}
+
+	for _, channel := range changedChannels {
+		event := ChannelChangeEvent{
+			Client:  c,
+			Type:    ChannelChangePermission,
+			Channel: channel,
+		}
+		c.Config.Listeners.onChannelChange(&event)
+	}
+
+	return nil
+}
+
+func (c *Client) handleCodecVersion(buffer []byte) error {
+	var packet MumbleProto.CodecVersion
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+	event := ServerConfigEvent{
+		Client: c,
+	}
+	event.CodecAlpha = packet.Alpha
+	event.CodecBeta = packet.Beta
+	{
+		val := packet.GetPreferAlpha()
+		event.CodecPreferAlpha = &val
+	}
+	{
+		val := packet.GetOpus()
+		event.CodecOpus = &val
+	}
+
+	var codec AudioCodec
+	switch {
+	case *event.CodecOpus:
+		codec = getAudioCodec(audioCodecIDOpus)
+	}
+	if codec != nil {
+		c.audioCodec = codec
+
+		{
+			c.volatile.Lock()
+
+			c.AudioEncoder = codec.NewEncoder()
+
+			c.volatile.Unlock()
+		}
+	}
+
+	c.Config.Listeners.onServerConfig(&event)
+	return nil
+}
+
+func (c *Client) handleUserStats(buffer []byte) error {
+	var packet MumbleProto.UserStats
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+
+	if packet.Session == nil {
+		return errIncompleteProtobuf
+	}
+	user := c.Users[*packet.Session]
+	if user == nil {
+		return errInvalidProtobuf
+	}
+
+	{
+		c.volatile.Lock()
+
+		if user.Stats == nil {
+			user.Stats = &UserStats{}
+		}
+		*user.Stats = UserStats{
+			User: user,
+		}
+		stats := user.Stats
+
+		if packet.FromClient != nil {
+			if packet.FromClient.Good != nil {
+				stats.FromClient.Good = *packet.FromClient.Good
+			}
+			if packet.FromClient.Late != nil {
+				stats.FromClient.Late = *packet.FromClient.Late
+			}
+			if packet.FromClient.Lost != nil {
+				stats.FromClient.Lost = *packet.FromClient.Lost
+			}
+			if packet.FromClient.Resync != nil {
+				stats.FromClient.Resync = *packet.FromClient.Resync
+			}
+		}
+		if packet.FromServer != nil {
+			if packet.FromServer.Good != nil {
+				stats.FromServer.Good = *packet.FromServer.Good
+			}
+			if packet.FromClient.Late != nil {
+				stats.FromServer.Late = *packet.FromServer.Late
+			}
+			if packet.FromClient.Lost != nil {
+				stats.FromServer.Lost = *packet.FromServer.Lost
+			}
+			if packet.FromClient.Resync != nil {
+				stats.FromServer.Resync = *packet.FromServer.Resync
+			}
+		}
+
+		if packet.UdpPackets != nil {
+			stats.UDPPackets = *packet.UdpPackets
+		}
+		if packet.UdpPingAvg != nil {
+			stats.UDPPingAverage = *packet.UdpPingAvg
+		}
+		if packet.UdpPingVar != nil {
+			stats.UDPPingVariance = *packet.UdpPingVar
+		}
+		if packet.TcpPackets != nil {
+			stats.TCPPackets = *packet.TcpPackets
+		}
+		if packet.TcpPingAvg != nil {
+			stats.TCPPingAverage = *packet.TcpPingAvg
+		}
+		if packet.TcpPingVar != nil {
+			stats.TCPPingVariance = *packet.TcpPingVar
+		}
+
+		if packet.Version != nil {
+			stats.Version = parseVersion(packet.Version)
+		}
+		if packet.Onlinesecs != nil {
+			stats.Connected = time.Now().Add(time.Duration(*packet.Onlinesecs) * -time.Second)
+		}
+		if packet.Idlesecs != nil {
+			stats.Idle = time.Duration(*packet.Idlesecs) * time.Second
+		}
+		if packet.Bandwidth != nil {
+			stats.Bandwidth = int(*packet.Bandwidth)
+		}
+		if packet.Address != nil {
+			stats.IP = net.IP(packet.Address)
+		}
+		if packet.Certificates != nil {
+			stats.Certificates = make([]*x509.Certificate, 0, len(packet.Certificates))
+			for _, data := range packet.Certificates {
+				if data != nil {
+					if cert, err := x509.ParseCertificate(data); err == nil {
+						stats.Certificates = append(stats.Certificates, cert)
+					}
+				}
+			}
+		}
+		stats.StrongCertificate = packet.GetStrongCertificate()
+		stats.CELTVersions = packet.GetCeltVersions()
+		if packet.Opus != nil {
+			stats.Opus = *packet.Opus
+		}
+
+		c.volatile.Unlock()
+	}
+
+	event := UserChangeEvent{
+		Client: c,
+		Type:   UserChangeStats,
+		User:   user,
+	}
+
+	c.Config.Listeners.onUserChange(&event)
+	return nil
+}
+
+func (c *Client) handleRequestBlob(buffer []byte) error {
+	return errUnimplementedHandler
+}
+
+func (c *Client) handleServerConfig(buffer []byte) error {
+	var packet MumbleProto.ServerConfig
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+	event := ServerConfigEvent{
+		Client: c,
+	}
+	if packet.MaxBandwidth != nil {
+		val := int(*packet.MaxBandwidth)
+		event.MaximumBitrate = &val
+	}
+	if packet.WelcomeText != nil {
+		event.WelcomeMessage = packet.WelcomeText
+	}
+	if packet.AllowHtml != nil {
+		event.AllowHTML = packet.AllowHtml
+	}
+	if packet.MessageLength != nil {
+		val := int(*packet.MessageLength)
+		event.MaximumMessageLength = &val
+	}
+	if packet.ImageMessageLength != nil {
+		val := int(*packet.ImageMessageLength)
+		event.MaximumImageMessageLength = &val
+	}
+	if packet.MaxUsers != nil {
+		val := int(*packet.MaxUsers)
+		event.MaximumUsers = &val
+	}
+	c.Config.Listeners.onServerConfig(&event)
+	return nil
+}
+
+func (c *Client) handleSuggestConfig(buffer []byte) error {
+	var packet MumbleProto.SuggestConfig
+	if err := proto.Unmarshal(buffer, &packet); err != nil {
+		return err
+	}
+	event := ServerConfigEvent{
+		Client: c,
+	}
+	if packet.Version != nil {
+		event.SuggestVersion = &Version{
+			Version: packet.GetVersion(),
+		}
+	}
+	if packet.Positional != nil {
+		event.SuggestPositional = packet.Positional
+	}
+	if packet.PushToTalk != nil {
+		event.SuggestPushToTalk = packet.PushToTalk
+	}
+	c.Config.Listeners.onServerConfig(&event)
+	return nil
+}
diff --git a/vendor/layeh.com/gumble/gumble/listeners.go b/vendor/layeh.com/gumble/gumble/listeners.go
new file mode 100644
index 00000000..3d100c01
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/listeners.go
@@ -0,0 +1,153 @@
+package gumble
+
+type eventItem struct {
+	parent     *Listeners
+	prev, next *eventItem
+	listener   EventListener
+}
+
+func (e *eventItem) Detach() {
+	if e.prev == nil {
+		e.parent.head = e.next
+	} else {
+		e.prev.next = e.next
+	}
+	if e.next == nil {
+		e.parent.tail = e.prev
+	} else {
+		e.next.prev = e.prev
+	}
+}
+
+// Listeners is a list of event listeners. Each attached listener is called in
+// sequence when a Client event is triggered.
+type Listeners struct {
+	head, tail *eventItem
+}
+
+// Attach adds a new event listener to the end of the current list of listeners.
+func (e *Listeners) Attach(listener EventListener) Detacher {
+	item := &eventItem{
+		parent:   e,
+		prev:     e.tail,
+		listener: listener,
+	}
+	if e.head == nil {
+		e.head = item
+	}
+	if e.tail != nil {
+		e.tail.next = item
+	}
+	e.tail = item
+	return item
+}
+
+func (e *Listeners) onConnect(event *ConnectEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnConnect(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onDisconnect(event *DisconnectEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnDisconnect(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onTextMessage(event *TextMessageEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnTextMessage(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onUserChange(event *UserChangeEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnUserChange(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onChannelChange(event *ChannelChangeEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnChannelChange(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onPermissionDenied(event *PermissionDeniedEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnPermissionDenied(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onUserList(event *UserListEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnUserList(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onACL(event *ACLEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnACL(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onBanList(event *BanListEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnBanList(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onContextActionChange(event *ContextActionChangeEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnContextActionChange(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
+
+func (e *Listeners) onServerConfig(event *ServerConfigEvent) {
+	event.Client.volatile.Lock()
+	for item := e.head; item != nil; item = item.next {
+		event.Client.volatile.Unlock()
+		item.listener.OnServerConfig(event)
+		event.Client.volatile.Lock()
+	}
+	event.Client.volatile.Unlock()
+}
diff --git a/vendor/layeh.com/gumble/gumble/message.go b/vendor/layeh.com/gumble/gumble/message.go
new file mode 100644
index 00000000..a2309661
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/message.go
@@ -0,0 +1,13 @@
+package gumble
+
+// Message is data that be encoded and sent to the server. The following
+// types implement this interface:
+//  AccessTokens
+//  ACL
+//  BanList
+//  RegisteredUsers
+//  TextMessage
+//  VoiceTarget
+type Message interface {
+	writeMessage(client *Client) error
+}
diff --git a/vendor/layeh.com/gumble/gumble/permission.go b/vendor/layeh.com/gumble/gumble/permission.go
new file mode 100644
index 00000000..b467a641
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/permission.go
@@ -0,0 +1,33 @@
+package gumble
+
+// Permission is a bitmask of permissions given to a certain user.
+type Permission int
+
+// Permissions that can be applied in any channel.
+const (
+	PermissionWrite Permission = 1 << iota
+	PermissionTraverse
+	PermissionEnter
+	PermissionSpeak
+	PermissionMuteDeafen
+	PermissionMove
+	PermissionMakeChannel
+	PermissionLinkChannel
+	PermissionWhisper
+	PermissionTextMessage
+	PermissionMakeTemporaryChannel
+)
+
+// Permissions that can only be applied in the root channel.
+const (
+	PermissionKick Permission = 0x10000 << iota
+	PermissionBan
+	PermissionRegister
+	PermissionRegisterSelf
+)
+
+// Has returns true if the Permission p contains Permission o has part of its
+// bitmask.
+func (p Permission) Has(o Permission) bool {
+	return p&o == o
+}
diff --git a/vendor/layeh.com/gumble/gumble/ping.go b/vendor/layeh.com/gumble/gumble/ping.go
new file mode 100644
index 00000000..ad9c804e
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/ping.go
@@ -0,0 +1,108 @@
+package gumble
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+	"sync"
+	"time"
+)
+
+// PingResponse contains information about a server that responded to a UDP
+// ping packet.
+type PingResponse struct {
+	// The address of the pinged server.
+	Address *net.UDPAddr
+	// The round-trip time from the client to the server.
+	Ping time.Duration
+	// The server's version. Only the Version field and SemanticVersion method of
+	// the value will be valid.
+	Version Version
+	// The number users currently connected to the server.
+	ConnectedUsers int
+	// The maximum number of users that can connect to the server.
+	MaximumUsers int
+	// The maximum audio bitrate per user for the server.
+	MaximumBitrate int
+}
+
+// Ping sends a UDP ping packet to the given server. If interval is positive,
+// the packet is retransmitted at every interval.
+//
+// Returns a PingResponse and nil on success. The function will return nil and
+// an error if a valid response is not received after the given timeout.
+func Ping(address string, interval, timeout time.Duration) (*PingResponse, error) {
+	if timeout < 0 {
+		return nil, errors.New("gumble: timeout must be positive")
+	}
+	deadline := time.Now().Add(timeout)
+	conn, err := net.DialTimeout("udp", address, timeout)
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+	conn.SetReadDeadline(deadline)
+
+	var (
+		idsLock sync.Mutex
+		ids     = make(map[string]time.Time)
+	)
+
+	buildSendPacket := func() {
+		var packet [12]byte
+		if _, err := rand.Read(packet[4:]); err != nil {
+			return
+		}
+		id := string(packet[4:])
+		idsLock.Lock()
+		ids[id] = time.Now()
+		idsLock.Unlock()
+		conn.Write(packet[:])
+	}
+
+	if interval > 0 {
+		end := make(chan struct{})
+		defer close(end)
+		go func() {
+			ticker := time.NewTicker(interval)
+			defer ticker.Stop()
+			for {
+				select {
+				case <-ticker.C:
+					buildSendPacket()
+				case <-end:
+					return
+				}
+			}
+		}()
+	}
+
+	buildSendPacket()
+
+	for {
+		var incoming [24]byte
+		if _, err := io.ReadFull(conn, incoming[:]); err != nil {
+			return nil, err
+		}
+		id := string(incoming[4:12])
+		idsLock.Lock()
+		sendTime, ok := ids[id]
+		idsLock.Unlock()
+		if !ok {
+			continue
+		}
+
+		return &PingResponse{
+			Address: conn.RemoteAddr().(*net.UDPAddr),
+			Ping:    time.Since(sendTime),
+			Version: Version{
+				Version: binary.BigEndian.Uint32(incoming[0:]),
+			},
+			ConnectedUsers: int(binary.BigEndian.Uint32(incoming[12:])),
+			MaximumUsers:   int(binary.BigEndian.Uint32(incoming[16:])),
+			MaximumBitrate: int(binary.BigEndian.Uint32(incoming[20:])),
+		}, nil
+	}
+}
diff --git a/vendor/layeh.com/gumble/gumble/reject.go b/vendor/layeh.com/gumble/gumble/reject.go
new file mode 100644
index 00000000..f110982e
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/reject.go
@@ -0,0 +1,61 @@
+package gumble
+
+import (
+	"strconv"
+
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// RejectType describes why a client connection was rejected by the server.
+type RejectType int
+
+// The possible reason why a client connection was rejected by the server.
+const (
+	RejectNone              RejectType = RejectType(MumbleProto.Reject_None)
+	RejectVersion           RejectType = RejectType(MumbleProto.Reject_WrongVersion)
+	RejectUserName          RejectType = RejectType(MumbleProto.Reject_InvalidUsername)
+	RejectUserCredentials   RejectType = RejectType(MumbleProto.Reject_WrongUserPW)
+	RejectServerPassword    RejectType = RejectType(MumbleProto.Reject_WrongServerPW)
+	RejectUsernameInUse     RejectType = RejectType(MumbleProto.Reject_UsernameInUse)
+	RejectServerFull        RejectType = RejectType(MumbleProto.Reject_ServerFull)
+	RejectNoCertificate     RejectType = RejectType(MumbleProto.Reject_NoCertificate)
+	RejectAuthenticatorFail RejectType = RejectType(MumbleProto.Reject_AuthenticatorFail)
+)
+
+// RejectError is returned by DialWithDialer when the server rejects the client
+// connection.
+type RejectError struct {
+	Type   RejectType
+	Reason string
+}
+
+// Error implements error.
+func (e RejectError) Error() string {
+	var msg string
+	switch e.Type {
+	case RejectNone:
+		msg = "none"
+	case RejectVersion:
+		msg = "wrong client version"
+	case RejectUserName:
+		msg = "invalid username"
+	case RejectUserCredentials:
+		msg = "incorrect user credentials"
+	case RejectServerPassword:
+		msg = "incorrect server password"
+	case RejectUsernameInUse:
+		msg = "username in use"
+	case RejectServerFull:
+		msg = "server full"
+	case RejectNoCertificate:
+		msg = "no certificate"
+	case RejectAuthenticatorFail:
+		msg = "authenticator fail"
+	default:
+		msg = "unknown type " + strconv.Itoa(int(e.Type))
+	}
+	if e.Reason != "" {
+		msg += ": " + e.Reason
+	}
+	return msg
+}
diff --git a/vendor/layeh.com/gumble/gumble/rpwmutex.go b/vendor/layeh.com/gumble/gumble/rpwmutex.go
new file mode 100644
index 00000000..ca881a62
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/rpwmutex.go
@@ -0,0 +1,36 @@
+package gumble
+
+import "sync"
+
+// rpwMutex is a reader-preferred RWMutex.
+type rpwMutex struct {
+	w sync.Mutex
+	r sync.Mutex
+	n int
+}
+
+func (m *rpwMutex) Lock() {
+	m.w.Lock()
+}
+
+func (m *rpwMutex) Unlock() {
+	m.w.Unlock()
+}
+
+func (m *rpwMutex) RLock() {
+	m.r.Lock()
+	m.n++
+	if m.n == 1 {
+		m.w.Lock()
+	}
+	m.r.Unlock()
+}
+
+func (m *rpwMutex) RUnlock() {
+	m.r.Lock()
+	m.n--
+	if m.n == 0 {
+		m.w.Unlock()
+	}
+	m.r.Unlock()
+}
diff --git a/vendor/layeh.com/gumble/gumble/textmessage.go b/vendor/layeh.com/gumble/gumble/textmessage.go
new file mode 100644
index 00000000..0f69cbd5
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/textmessage.go
@@ -0,0 +1,45 @@
+package gumble
+
+import (
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// TextMessage is a chat message that can be received from and sent to the
+// server.
+type TextMessage struct {
+	// User who sent the message (can be nil).
+	Sender *User
+	// Users that receive the message.
+	Users []*User
+	// Channels that receive the message.
+	Channels []*Channel
+	// Channels that receive the message and send it recursively to sub-channels.
+	Trees []*Channel
+	// Chat message.
+	Message string
+}
+
+func (t *TextMessage) writeMessage(client *Client) error {
+	packet := MumbleProto.TextMessage{
+		Message: &t.Message,
+	}
+	if t.Users != nil {
+		packet.Session = make([]uint32, len(t.Users))
+		for i, user := range t.Users {
+			packet.Session[i] = user.Session
+		}
+	}
+	if t.Channels != nil {
+		packet.ChannelId = make([]uint32, len(t.Channels))
+		for i, channel := range t.Channels {
+			packet.ChannelId[i] = channel.ID
+		}
+	}
+	if t.Trees != nil {
+		packet.TreeId = make([]uint32, len(t.Trees))
+		for i, channel := range t.Trees {
+			packet.TreeId[i] = channel.ID
+		}
+	}
+	return client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/user.go b/vendor/layeh.com/gumble/gumble/user.go
new file mode 100644
index 00000000..6274d443
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/user.go
@@ -0,0 +1,233 @@
+package gumble
+
+import (
+	"github.com/golang/protobuf/proto"
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// User represents a user that is currently connected to the server.
+type User struct {
+	// The user's unique session ID.
+	Session uint32
+	// The user's ID. Contains an invalid value if the user is not registered.
+	UserID uint32
+	// The user's name.
+	Name string
+	// The channel that the user is currently in.
+	Channel *Channel
+
+	// Has the user has been muted?
+	Muted bool
+	// Has the user been deafened?
+	Deafened bool
+	// Has the user been suppressed?
+	Suppressed bool
+	// Has the user been muted by him/herself?
+	SelfMuted bool
+	// Has the user been deafened by him/herself?
+	SelfDeafened bool
+	// Is the user a priority speaker in the channel?
+	PrioritySpeaker bool
+	// Is the user recording audio?
+	Recording bool
+
+	// The user's comment. Contains the empty string if the user does not have a
+	// comment, or if the comment needs to be requested.
+	Comment string
+	// The user's comment hash. nil if User.Comment has been populated.
+	CommentHash []byte
+	// The hash of the user's certificate (can be empty).
+	Hash string
+	// The user's texture (avatar). nil if the user does not have a
+	// texture, or if the texture needs to be requested.
+	Texture []byte
+	// The user's texture hash. nil if User.Texture has been populated.
+	TextureHash []byte
+
+	// The user's stats. Contains nil if the stats have not yet been requested.
+	Stats *UserStats
+
+	client  *Client
+	decoder AudioDecoder
+}
+
+// SetTexture sets the user's texture.
+func (u *User) SetTexture(texture []byte) {
+	packet := MumbleProto.UserState{
+		Session: &u.Session,
+		Texture: texture,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetPrioritySpeaker sets if the user is a priority speaker in the channel.
+func (u *User) SetPrioritySpeaker(prioritySpeaker bool) {
+	packet := MumbleProto.UserState{
+		Session:         &u.Session,
+		PrioritySpeaker: &prioritySpeaker,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetRecording sets if the user is recording audio.
+func (u *User) SetRecording(recording bool) {
+	packet := MumbleProto.UserState{
+		Session:   &u.Session,
+		Recording: &recording,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// IsRegistered returns true if the user's certificate has been registered with
+// the server. A registered user will have a valid user ID.
+func (u *User) IsRegistered() bool {
+	return u.UserID > 0
+}
+
+// Register will register the user with the server. If the client has
+// permission to do so, the user will shortly be given a UserID.
+func (u *User) Register() {
+	packet := MumbleProto.UserState{
+		Session: &u.Session,
+		UserId:  proto.Uint32(0),
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetComment will set the user's comment to the given string. The user's
+// comment will be erased if the comment is set to the empty string.
+func (u *User) SetComment(comment string) {
+	packet := MumbleProto.UserState{
+		Session: &u.Session,
+		Comment: &comment,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// Move will move the user to the given channel.
+func (u *User) Move(channel *Channel) {
+	packet := MumbleProto.UserState{
+		Session:   &u.Session,
+		ChannelId: &channel.ID,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// Kick will kick the user from the server.
+func (u *User) Kick(reason string) {
+	packet := MumbleProto.UserRemove{
+		Session: &u.Session,
+		Reason:  &reason,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// Ban will ban the user from the server.
+func (u *User) Ban(reason string) {
+	packet := MumbleProto.UserRemove{
+		Session: &u.Session,
+		Reason:  &reason,
+		Ban:     proto.Bool(true),
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetMuted sets whether the user can transmit audio or not.
+func (u *User) SetMuted(muted bool) {
+	packet := MumbleProto.UserState{
+		Session: &u.Session,
+		Mute:    &muted,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetSuppressed sets whether the user is suppressed by the server or not.
+func (u *User) SetSuppressed(supressed bool) {
+	packet := MumbleProto.UserState{
+		Session:  &u.Session,
+		Suppress: &supressed,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetDeafened sets whether the user can receive audio or not.
+func (u *User) SetDeafened(muted bool) {
+	packet := MumbleProto.UserState{
+		Session: &u.Session,
+		Deaf:    &muted,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetSelfMuted sets whether the user can transmit audio or not.
+//
+// This method should only be called on Client.Self().
+func (u *User) SetSelfMuted(muted bool) {
+	packet := MumbleProto.UserState{
+		Session:  &u.Session,
+		SelfMute: &muted,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// SetSelfDeafened sets whether the user can receive audio or not.
+//
+// This method should only be called on Client.Self().
+func (u *User) SetSelfDeafened(muted bool) {
+	packet := MumbleProto.UserState{
+		Session:  &u.Session,
+		SelfDeaf: &muted,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// RequestStats requests that the user's stats be sent to the client.
+func (u *User) RequestStats() {
+	packet := MumbleProto.UserStats{
+		Session: &u.Session,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// RequestTexture requests that the user's actual texture (i.e. non-hashed) be
+// sent to the client.
+func (u *User) RequestTexture() {
+	packet := MumbleProto.RequestBlob{
+		SessionTexture: []uint32{u.Session},
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// RequestComment requests that the user's actual comment (i.e. non-hashed) be
+// sent to the client.
+func (u *User) RequestComment() {
+	packet := MumbleProto.RequestBlob{
+		SessionComment: []uint32{u.Session},
+	}
+	u.client.Conn.WriteProto(&packet)
+}
+
+// Send will send a text message to the user.
+func (u *User) Send(message string) {
+	textMessage := TextMessage{
+		Users:   []*User{u},
+		Message: message,
+	}
+	u.client.Send(&textMessage)
+}
+
+// SetPlugin sets the user's plugin data.
+//
+// Plugins are currently only used for positional audio. Clients will receive
+// positional audio information from other users if their plugin context is the
+// same. The official Mumble client sets the context to:
+//
+//  PluginShortName + "\x00" + AdditionalContextInformation
+func (u *User) SetPlugin(context []byte, identity string) {
+	packet := MumbleProto.UserState{
+		Session:        &u.Session,
+		PluginContext:  context,
+		PluginIdentity: &identity,
+	}
+	u.client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/userlist.go b/vendor/layeh.com/gumble/gumble/userlist.go
new file mode 100644
index 00000000..1837abda
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/userlist.go
@@ -0,0 +1,74 @@
+package gumble
+
+import (
+	"time"
+
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// RegisteredUser represents a registered user on the server.
+type RegisteredUser struct {
+	// The registered user's ID.
+	UserID uint32
+	// The registered user's name.
+	Name string
+	// The last time the user was seen by the server.
+	LastSeen time.Time
+	// The last channel the user was seen in.
+	LastChannel *Channel
+
+	changed    bool
+	deregister bool
+}
+
+// SetName sets the new name for the user.
+func (r *RegisteredUser) SetName(name string) {
+	r.Name = name
+	r.changed = true
+}
+
+// Deregister will remove the registered user from the server.
+func (r *RegisteredUser) Deregister() {
+	r.deregister = true
+}
+
+// Register will keep the user registered on the server. This is only useful if
+// Deregister() was called on the registered user.
+func (r *RegisteredUser) Register() {
+	r.deregister = false
+}
+
+// ACLUser returns an ACLUser for the given registered user.
+func (r *RegisteredUser) ACLUser() *ACLUser {
+	return &ACLUser{
+		UserID: r.UserID,
+		Name:   r.Name,
+	}
+}
+
+// RegisteredUsers is a list of users who are registered on the server.
+//
+// Whenever a registered user is changed, it does not come into effect until
+// the registered user list is sent back to the server.
+type RegisteredUsers []*RegisteredUser
+
+func (r RegisteredUsers) writeMessage(client *Client) error {
+	packet := MumbleProto.UserList{}
+
+	for _, user := range r {
+		if user.deregister || user.changed {
+			userListUser := &MumbleProto.UserList_User{
+				UserId: &user.UserID,
+			}
+			if !user.deregister {
+				userListUser.Name = &user.Name
+			}
+			packet.Users = append(packet.Users, userListUser)
+		}
+	}
+
+	if len(packet.Users) <= 0 {
+		return nil
+	}
+	return client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumble/users.go b/vendor/layeh.com/gumble/gumble/users.go
new file mode 100644
index 00000000..c2725915
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/users.go
@@ -0,0 +1,30 @@
+package gumble
+
+// Users is a map of server users.
+//
+// When accessed through client.Users, it contains all users currently on the
+// server. When accessed through a specific channel
+// (e.g. client.Channels[0].Users), it contains only the users in the
+// channel.
+type Users map[uint32]*User
+
+// create adds a new user with the given session to the collection. If a user
+// with the given session already exists, it is overwritten.
+func (u Users) create(session uint32) *User {
+	user := &User{
+		Session: session,
+	}
+	u[session] = user
+	return user
+}
+
+// Find returns the user with the given name. nil is returned if no user exists
+// with the given name.
+func (u Users) Find(name string) *User {
+	for _, user := range u {
+		if user.Name == name {
+			return user
+		}
+	}
+	return nil
+}
diff --git a/vendor/layeh.com/gumble/gumble/userstats.go b/vendor/layeh.com/gumble/gumble/userstats.go
new file mode 100644
index 00000000..15f04518
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/userstats.go
@@ -0,0 +1,62 @@
+package gumble
+
+import (
+	"crypto/x509"
+	"net"
+	"time"
+)
+
+// UserStats contains additional information about a user.
+type UserStats struct {
+	// The owner of the stats.
+	User *User
+
+	// Stats about UDP packets sent from the client.
+	FromClient UserStatsUDP
+	// Stats about UDP packets sent by the server.
+	FromServer UserStatsUDP
+
+	// Number of UDP packets sent by the user.
+	UDPPackets uint32
+	// Average UDP ping.
+	UDPPingAverage float32
+	// UDP ping variance.
+	UDPPingVariance float32
+
+	// Number of TCP packets sent by the user.
+	TCPPackets uint32
+	// Average TCP ping.
+	TCPPingAverage float32
+	// TCP ping variance.
+	TCPPingVariance float32
+
+	// The user's version.
+	Version Version
+	// When the user connected to the server.
+	Connected time.Time
+	// How long the user has been idle.
+	Idle time.Duration
+	// How much bandwidth the user is current using.
+	Bandwidth int
+	// The user's certificate chain.
+	Certificates []*x509.Certificate
+	// Does the user have a strong certificate? A strong certificate is one that
+	// is not self signed, nor expired, etc.
+	StrongCertificate bool
+	// A list of CELT versions supported by the user's client.
+	CELTVersions []int32
+	// Does the user's client supports the Opus audio codec?
+	Opus bool
+
+	// The user's IP address.
+	IP net.IP
+}
+
+// UserStatsUDP contains stats about UDP packets that have been sent to or from
+// the server.
+type UserStatsUDP struct {
+	Good   uint32
+	Late   uint32
+	Lost   uint32
+	Resync uint32
+}
diff --git a/vendor/layeh.com/gumble/gumble/varint/read.go b/vendor/layeh.com/gumble/gumble/varint/read.go
new file mode 100644
index 00000000..6b5820d3
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/varint/read.go
@@ -0,0 +1,52 @@
+package varint
+
+import (
+	"encoding/binary"
+)
+
+// Decode reads the first varint encoded number from the given buffer.
+//
+// On success, the function returns the varint as an int64, and the number of
+// bytes read (0 if there was an error).
+func Decode(b []byte) (int64, int) {
+	if len(b) == 0 {
+		return 0, 0
+	}
+	// 0xxxxxxx 7-bit positive number
+	if (b[0] & 0x80) == 0 {
+		return int64(b[0]), 1
+	}
+	// 10xxxxxx + 1 byte 14-bit positive number
+	if (b[0]&0xC0) == 0x80 && len(b) >= 2 {
+		return int64(b[0]&0x3F)<<8 | int64(b[1]), 2
+	}
+	// 110xxxxx + 2 bytes 21-bit positive number
+	if (b[0]&0xE0) == 0xC0 && len(b) >= 3 {
+		return int64(b[0]&0x1F)<<16 | int64(b[1])<<8 | int64(b[2]), 3
+	}
+	// 1110xxxx + 3 bytes 28-bit positive number
+	if (b[0]&0xF0) == 0xE0 && len(b) >= 4 {
+		return int64(b[0]&0xF)<<24 | int64(b[1])<<16 | int64(b[2])<<8 | int64(b[3]), 4
+	}
+	// 111100__ + int (32-bit) 32-bit positive number
+	if (b[0]&0xFC) == 0xF0 && len(b) >= 5 {
+		return int64(binary.BigEndian.Uint32(b[1:])), 5
+	}
+	// 111101__ + long (64-bit) 64-bit number
+	if (b[0]&0xFC) == 0xF4 && len(b) >= 9 {
+		return int64(binary.BigEndian.Uint64(b[1:])), 9
+	}
+	// 111110__ + varint Negative recursive varint
+	if b[0]&0xFC == 0xF8 {
+		if v, n := Decode(b[1:]); n > 0 {
+			return -v, n + 1
+		}
+		return 0, 0
+	}
+	// 111111xx Byte-inverted negative two bit number (~xx)
+	if b[0]&0xFC == 0xFC {
+		return ^int64(b[0] & 0x03), 1
+	}
+
+	return 0, 0
+}
diff --git a/vendor/layeh.com/gumble/gumble/varint/write.go b/vendor/layeh.com/gumble/gumble/varint/write.go
new file mode 100644
index 00000000..29d931bc
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/varint/write.go
@@ -0,0 +1,64 @@
+package varint
+
+import (
+	"encoding/binary"
+	"math"
+)
+
+// MaxVarintLen is the maximum number of bytes required to encode a varint
+// number.
+const MaxVarintLen = 10
+
+// Encode encodes the given value to varint format.
+func Encode(b []byte, value int64) int {
+	// 111111xx Byte-inverted negative two bit number (~xx)
+	if value <= -1 && value >= -4 {
+		b[0] = 0xFC | byte(^value&0xFF)
+		return 1
+	}
+	// 111110__ + varint Negative recursive varint
+	if value < 0 {
+		b[0] = 0xF8
+		return 1 + Encode(b[1:], -value)
+	}
+	// 0xxxxxxx 7-bit positive number
+	if value <= 0x7F {
+		b[0] = byte(value)
+		return 1
+	}
+	// 10xxxxxx + 1 byte 14-bit positive number
+	if value <= 0x3FFF {
+		b[0] = byte(((value >> 8) & 0x3F) | 0x80)
+		b[1] = byte(value & 0xFF)
+		return 2
+	}
+	// 110xxxxx + 2 bytes 21-bit positive number
+	if value <= 0x1FFFFF {
+		b[0] = byte((value>>16)&0x1F | 0xC0)
+		b[1] = byte((value >> 8) & 0xFF)
+		b[2] = byte(value & 0xFF)
+		return 3
+	}
+	// 1110xxxx + 3 bytes 28-bit positive number
+	if value <= 0xFFFFFFF {
+		b[0] = byte((value>>24)&0xF | 0xE0)
+		b[1] = byte((value >> 16) & 0xFF)
+		b[2] = byte((value >> 8) & 0xFF)
+		b[3] = byte(value & 0xFF)
+		return 4
+	}
+	// 111100__ + int (32-bit) 32-bit positive number
+	if value <= math.MaxInt32 {
+		b[0] = 0xF0
+		binary.BigEndian.PutUint32(b[1:], uint32(value))
+		return 5
+	}
+	// 111101__ + long (64-bit) 64-bit number
+	if value <= math.MaxInt64 {
+		b[0] = 0xF4
+		binary.BigEndian.PutUint64(b[1:], uint64(value))
+		return 9
+	}
+
+	return 0
+}
diff --git a/vendor/layeh.com/gumble/gumble/version.go b/vendor/layeh.com/gumble/gumble/version.go
new file mode 100644
index 00000000..5203b9d2
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/version.go
@@ -0,0 +1,24 @@
+package gumble
+
+// Version represents a Mumble client or server version.
+type Version struct {
+	// The semantic version information as a single unsigned integer.
+	//
+	// Bits 0-15 are the major version, bits 16-23 are the minor version, and
+	// bits 24-31 are the patch version.
+	Version uint32
+	// The name of the client.
+	Release string
+	// The operating system name.
+	OS string
+	// The operating system version.
+	OSVersion string
+}
+
+// SemanticVersion returns the version's semantic version components.
+func (v *Version) SemanticVersion() (major uint16, minor, patch uint8) {
+	major = uint16(v.Version>>16) & 0xFFFF
+	minor = uint8(v.Version>>8) & 0xFF
+	patch = uint8(v.Version) & 0xFF
+	return
+}
diff --git a/vendor/layeh.com/gumble/gumble/voicetarget.go b/vendor/layeh.com/gumble/gumble/voicetarget.go
new file mode 100644
index 00000000..914dcfb5
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumble/voicetarget.go
@@ -0,0 +1,76 @@
+package gumble
+
+import (
+	"layeh.com/gumble/gumble/MumbleProto"
+)
+
+// VoiceTargetLoopback is a special voice target which causes any audio sent to
+// the server to be returned to the client.
+//
+// Its ID should not be modified, and it does not have to to be sent to the
+// server before use.
+var VoiceTargetLoopback *VoiceTarget = &VoiceTarget{
+	ID: 31,
+}
+
+type voiceTargetChannel struct {
+	channel          *Channel
+	links, recursive bool
+	group            string
+}
+
+// VoiceTarget represents a set of users and/or channels that the client can
+// whisper to.
+type VoiceTarget struct {
+	// The voice target ID. This value must be in the range [1, 30].
+	ID       uint32
+	users    []*User
+	channels []*voiceTargetChannel
+}
+
+// Clear removes all users and channels from the voice target.
+func (v *VoiceTarget) Clear() {
+	v.users = nil
+	v.channels = nil
+}
+
+// AddUser adds a user to the voice target.
+func (v *VoiceTarget) AddUser(user *User) {
+	v.users = append(v.users, user)
+}
+
+// AddChannel adds a user to the voice target. If group is non-empty, only
+// users belonging to that ACL group will be targeted.
+func (v *VoiceTarget) AddChannel(channel *Channel, recursive, links bool, group string) {
+	v.channels = append(v.channels, &voiceTargetChannel{
+		channel:   channel,
+		links:     links,
+		recursive: recursive,
+		group:     group,
+	})
+}
+
+func (v *VoiceTarget) writeMessage(client *Client) error {
+	packet := MumbleProto.VoiceTarget{
+		Id:      &v.ID,
+		Targets: make([]*MumbleProto.VoiceTarget_Target, 0, len(v.users)+len(v.channels)),
+	}
+	for _, user := range v.users {
+		packet.Targets = append(packet.Targets, &MumbleProto.VoiceTarget_Target{
+			Session: []uint32{user.Session},
+		})
+	}
+	for _, vtChannel := range v.channels {
+		target := &MumbleProto.VoiceTarget_Target{
+			ChannelId: &vtChannel.channel.ID,
+			Links:     &vtChannel.links,
+			Children:  &vtChannel.recursive,
+		}
+		if vtChannel.group != "" {
+			target.Group = &vtChannel.group
+		}
+		packet.Targets = append(packet.Targets, target)
+	}
+
+	return client.Conn.WriteProto(&packet)
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/acl.go b/vendor/layeh.com/gumble/gumbleutil/acl.go
new file mode 100644
index 00000000..67cd86d5
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/acl.go
@@ -0,0 +1,55 @@
+package gumbleutil
+
+import (
+	"layeh.com/gumble/gumble"
+)
+
+// UserGroups fetches the group names the given user belongs to in the given
+// channel. The slice of group names sent via the returned channel. On error,
+// the returned channel is closed without without sending a slice.
+func UserGroups(client *gumble.Client, user *gumble.User, channel *gumble.Channel) <-chan []string {
+	ch := make(chan []string)
+
+	if !user.IsRegistered() {
+		close(ch)
+		return ch
+	}
+
+	var detacher gumble.Detacher
+	listener := Listener{
+		Disconnect: func(e *gumble.DisconnectEvent) {
+			detacher.Detach()
+			close(ch)
+		},
+		ChannelChange: func(e *gumble.ChannelChangeEvent) {
+			if e.Channel == channel && e.Type.Has(gumble.ChannelChangeRemoved) {
+				detacher.Detach()
+				close(ch)
+			}
+		},
+		PermissionDenied: func(e *gumble.PermissionDeniedEvent) {
+			if e.Channel == channel && e.Type == gumble.PermissionDeniedPermission && (e.Permission&gumble.PermissionWrite) != 0 {
+				detacher.Detach()
+				close(ch)
+			}
+		},
+		ACL: func(e *gumble.ACLEvent) {
+			if e.ACL.Channel != channel {
+				return
+			}
+			var names []string
+			for _, g := range e.ACL.Groups {
+				if (g.UsersAdd[user.UserID] != nil || g.UsersInherited[user.UserID] != nil) && g.UsersRemove[user.UserID] == nil {
+					names = append(names, g.Name)
+				}
+			}
+			detacher.Detach()
+			ch <- names
+			close(ch)
+		},
+	}
+	detacher = client.Config.Attach(&listener)
+	channel.RequestACL()
+
+	return ch
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/bitrate.go b/vendor/layeh.com/gumble/gumbleutil/bitrate.go
new file mode 100644
index 00000000..6b93caa9
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/bitrate.go
@@ -0,0 +1,27 @@
+package gumbleutil
+
+import (
+	"time"
+
+	"layeh.com/gumble/gumble"
+)
+
+var autoBitrate = &Listener{
+	Connect: func(e *gumble.ConnectEvent) {
+		if e.MaximumBitrate != nil {
+			const safety = 5
+			interval := e.Client.Config.AudioInterval
+			dataBytes := (*e.MaximumBitrate / (8 * (int(time.Second/interval) + safety))) - 32 - 10
+
+			e.Client.Config.AudioDataBytes = dataBytes
+		}
+	},
+}
+
+// AutoBitrate is a gumble.EventListener that automatically sets the client's
+// AudioDataBytes to suitable value, based on the server's bitrate.
+var AutoBitrate gumble.EventListener
+
+func init() {
+	AutoBitrate = autoBitrate
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/channel.go b/vendor/layeh.com/gumble/gumbleutil/channel.go
new file mode 100644
index 00000000..ecf8bbef
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/channel.go
@@ -0,0 +1,18 @@
+package gumbleutil
+
+import (
+	"layeh.com/gumble/gumble"
+)
+
+// ChannelPath returns a slice of channel names, starting from the root channel
+// to the given channel.
+func ChannelPath(channel *gumble.Channel) []string {
+	var pieces []string
+	for ; channel != nil; channel = channel.Parent {
+		pieces = append(pieces, channel.Name)
+	}
+	for i := 0; i < (len(pieces) / 2); i++ {
+		pieces[len(pieces)-1-i], pieces[i] = pieces[i], pieces[len(pieces)-1-i]
+	}
+	return pieces
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/doc.go b/vendor/layeh.com/gumble/gumbleutil/doc.go
new file mode 100644
index 00000000..864a3b89
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/doc.go
@@ -0,0 +1,2 @@
+// Package gumbleutil provides extras that can make working with gumble easier.
+package gumbleutil
diff --git a/vendor/layeh.com/gumble/gumbleutil/listener.go b/vendor/layeh.com/gumble/gumbleutil/listener.go
new file mode 100644
index 00000000..5bc3167d
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/listener.go
@@ -0,0 +1,100 @@
+package gumbleutil
+
+import (
+	"layeh.com/gumble/gumble"
+)
+
+// Listener is a struct that implements the gumble.EventListener interface. The
+// corresponding event function in the struct is called if it is non-nil.
+type Listener struct {
+	Connect             func(e *gumble.ConnectEvent)
+	Disconnect          func(e *gumble.DisconnectEvent)
+	TextMessage         func(e *gumble.TextMessageEvent)
+	UserChange          func(e *gumble.UserChangeEvent)
+	ChannelChange       func(e *gumble.ChannelChangeEvent)
+	PermissionDenied    func(e *gumble.PermissionDeniedEvent)
+	UserList            func(e *gumble.UserListEvent)
+	ACL                 func(e *gumble.ACLEvent)
+	BanList             func(e *gumble.BanListEvent)
+	ContextActionChange func(e *gumble.ContextActionChangeEvent)
+	ServerConfig        func(e *gumble.ServerConfigEvent)
+}
+
+var _ gumble.EventListener = (*Listener)(nil)
+
+// OnConnect implements gumble.EventListener.OnConnect.
+func (l Listener) OnConnect(e *gumble.ConnectEvent) {
+	if l.Connect != nil {
+		l.Connect(e)
+	}
+}
+
+// OnDisconnect implements gumble.EventListener.OnDisconnect.
+func (l Listener) OnDisconnect(e *gumble.DisconnectEvent) {
+	if l.Disconnect != nil {
+		l.Disconnect(e)
+	}
+}
+
+// OnTextMessage implements gumble.EventListener.OnTextMessage.
+func (l Listener) OnTextMessage(e *gumble.TextMessageEvent) {
+	if l.TextMessage != nil {
+		l.TextMessage(e)
+	}
+}
+
+// OnUserChange implements gumble.EventListener.OnUserChange.
+func (l Listener) OnUserChange(e *gumble.UserChangeEvent) {
+	if l.UserChange != nil {
+		l.UserChange(e)
+	}
+}
+
+// OnChannelChange implements gumble.EventListener.OnChannelChange.
+func (l Listener) OnChannelChange(e *gumble.ChannelChangeEvent) {
+	if l.ChannelChange != nil {
+		l.ChannelChange(e)
+	}
+}
+
+// OnPermissionDenied implements gumble.EventListener.OnPermissionDenied.
+func (l Listener) OnPermissionDenied(e *gumble.PermissionDeniedEvent) {
+	if l.PermissionDenied != nil {
+		l.PermissionDenied(e)
+	}
+}
+
+// OnUserList implements gumble.EventListener.OnUserList.
+func (l Listener) OnUserList(e *gumble.UserListEvent) {
+	if l.UserList != nil {
+		l.UserList(e)
+	}
+}
+
+// OnACL implements gumble.EventListener.OnACL.
+func (l Listener) OnACL(e *gumble.ACLEvent) {
+	if l.ACL != nil {
+		l.ACL(e)
+	}
+}
+
+// OnBanList implements gumble.EventListener.OnBanList.
+func (l Listener) OnBanList(e *gumble.BanListEvent) {
+	if l.BanList != nil {
+		l.BanList(e)
+	}
+}
+
+// OnContextActionChange implements gumble.EventListener.OnContextActionChange.
+func (l Listener) OnContextActionChange(e *gumble.ContextActionChangeEvent) {
+	if l.ContextActionChange != nil {
+		l.ContextActionChange(e)
+	}
+}
+
+// OnServerConfig implements gumble.EventListener.OnServerConfig.
+func (l Listener) OnServerConfig(e *gumble.ServerConfigEvent) {
+	if l.ServerConfig != nil {
+		l.ServerConfig(e)
+	}
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/listenerfunc.go b/vendor/layeh.com/gumble/gumbleutil/listenerfunc.go
new file mode 100644
index 00000000..14af0d10
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/listenerfunc.go
@@ -0,0 +1,80 @@
+package gumbleutil
+
+import (
+	"layeh.com/gumble/gumble"
+)
+
+// ListenerFunc is a single listener function that implements the
+// gumble.EventListener interface. This is useful if you would like to use a
+// type-switch for handling the different event types.
+//
+// Example:
+//  handler := func(e interface{}) {
+//    switch e.(type) {
+//    case *gumble.ConnectEvent:
+//      println("Connected")
+//    case *gumble.DisconnectEvent:
+//      println("Disconnected")
+//    // ...
+//    }
+//  }
+//
+//  client.Attach(gumbleutil.ListenerFunc(handler))
+type ListenerFunc func(e interface{})
+
+var _ gumble.EventListener = ListenerFunc(nil)
+
+// OnConnect implements gumble.EventListener.OnConnect.
+func (lf ListenerFunc) OnConnect(e *gumble.ConnectEvent) {
+	lf(e)
+}
+
+// OnDisconnect implements gumble.EventListener.OnDisconnect.
+func (lf ListenerFunc) OnDisconnect(e *gumble.DisconnectEvent) {
+	lf(e)
+}
+
+// OnTextMessage implements gumble.EventListener.OnTextMessage.
+func (lf ListenerFunc) OnTextMessage(e *gumble.TextMessageEvent) {
+	lf(e)
+}
+
+// OnUserChange implements gumble.EventListener.OnUserChange.
+func (lf ListenerFunc) OnUserChange(e *gumble.UserChangeEvent) {
+	lf(e)
+}
+
+// OnChannelChange implements gumble.EventListener.OnChannelChange.
+func (lf ListenerFunc) OnChannelChange(e *gumble.ChannelChangeEvent) {
+	lf(e)
+}
+
+// OnPermissionDenied implements gumble.EventListener.OnPermissionDenied.
+func (lf ListenerFunc) OnPermissionDenied(e *gumble.PermissionDeniedEvent) {
+	lf(e)
+}
+
+// OnUserList implements gumble.EventListener.OnUserList.
+func (lf ListenerFunc) OnUserList(e *gumble.UserListEvent) {
+	lf(e)
+}
+
+// OnACL implements gumble.EventListener.OnACL.
+func (lf ListenerFunc) OnACL(e *gumble.ACLEvent) {
+	lf(e)
+}
+
+// OnBanList implements gumble.EventListener.OnBanList.
+func (lf ListenerFunc) OnBanList(e *gumble.BanListEvent) {
+	lf(e)
+}
+
+// OnContextActionChange implements gumble.EventListener.OnContextActionChange.
+func (lf ListenerFunc) OnContextActionChange(e *gumble.ContextActionChangeEvent) {
+	lf(e)
+}
+
+// OnServerConfig implements gumble.EventListener.OnServerConfig.
+func (lf ListenerFunc) OnServerConfig(e *gumble.ServerConfigEvent) {
+	lf(e)
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/main.go b/vendor/layeh.com/gumble/gumbleutil/main.go
new file mode 100644
index 00000000..36419ea6
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/main.go
@@ -0,0 +1,79 @@
+package gumbleutil
+
+import (
+	"crypto/tls"
+	"flag"
+	"fmt"
+	"net"
+	"os"
+	"strconv"
+
+	"layeh.com/gumble/gumble"
+)
+
+// Main aids in the creation of a basic command line gumble bot. It accepts the
+// following flag arguments:
+//  --server
+//  --username
+//  --password
+//  --insecure
+//  --certificate
+//  --key
+func Main(listeners ...gumble.EventListener) {
+	server := flag.String("server", "localhost:64738", "Mumble server address")
+	username := flag.String("username", "gumble-bot", "client username")
+	password := flag.String("password", "", "client password")
+	insecure := flag.Bool("insecure", false, "skip server certificate verification")
+	certificateFile := flag.String("certificate", "", "user certificate file (PEM)")
+	keyFile := flag.String("key", "", "user certificate key file (PEM)")
+
+	if !flag.Parsed() {
+		flag.Parse()
+	}
+
+	host, port, err := net.SplitHostPort(*server)
+	if err != nil {
+		host = *server
+		port = strconv.Itoa(gumble.DefaultPort)
+	}
+
+	keepAlive := make(chan bool)
+
+	config := gumble.NewConfig()
+	config.Username = *username
+	config.Password = *password
+	address := net.JoinHostPort(host, port)
+
+	var tlsConfig tls.Config
+
+	if *insecure {
+		tlsConfig.InsecureSkipVerify = true
+	}
+	if *certificateFile != "" {
+		if *keyFile == "" {
+			keyFile = certificateFile
+		}
+		if certificate, err := tls.LoadX509KeyPair(*certificateFile, *keyFile); err != nil {
+			fmt.Fprintf(os.Stderr, "%s: %s\n", os.Args[0], err)
+			os.Exit(1)
+		} else {
+			tlsConfig.Certificates = append(tlsConfig.Certificates, certificate)
+		}
+	}
+	config.Attach(AutoBitrate)
+	for _, listener := range listeners {
+		config.Attach(listener)
+	}
+	config.Attach(Listener{
+		Disconnect: func(e *gumble.DisconnectEvent) {
+			keepAlive <- true
+		},
+	})
+	_, err = gumble.DialWithDialer(new(net.Dialer), address, config, &tlsConfig)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s: %s\n", os.Args[0], err)
+		os.Exit(1)
+	}
+
+	<-keepAlive
+}
diff --git a/vendor/layeh.com/gumble/gumbleutil/textmessage.go b/vendor/layeh.com/gumble/gumbleutil/textmessage.go
new file mode 100644
index 00000000..1ccb62b4
--- /dev/null
+++ b/vendor/layeh.com/gumble/gumbleutil/textmessage.go
@@ -0,0 +1,45 @@
+package gumbleutil
+
+import (
+	"bytes"
+	"encoding/xml"
+	"strings"
+
+	"layeh.com/gumble/gumble"
+)
+
+// PlainText returns the Message string without HTML tags or entities.
+func PlainText(tm *gumble.TextMessage) string {
+	d := xml.NewDecoder(strings.NewReader(tm.Message))
+	d.Strict = false
+	d.AutoClose = xml.HTMLAutoClose
+	d.Entity = xml.HTMLEntity
+
+	var b bytes.Buffer
+	newline := false
+	for {
+		t, _ := d.Token()
+		if t == nil {
+			break
+		}
+		switch node := t.(type) {
+		case xml.CharData:
+			if len(node) > 0 {
+				b.Write(node)
+				newline = false
+			}
+		case xml.StartElement:
+			switch node.Name.Local {
+			case "address", "article", "aside", "audio", "blockquote", "canvas", "dd", "div", "dl", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "noscript", "ol", "output", "p", "pre", "section", "table", "tfoot", "ul", "video":
+				if !newline {
+					b.WriteByte('\n')
+					newline = true
+				}
+			case "br":
+				b.WriteByte('\n')
+				newline = true
+			}
+		}
+	}
+	return b.String()
+}