CEF/grumble
1
0
Fork 0
forked from External/grumble
Code Pull requests Activity

Add message numbers to mumbleproto package.

Browse source
This commit is contained in:
Mikkel Krautz 2011-09-07 16:12:07 +02:00
parent 4d5b897d66
commit 7482d5cb19
6 changed files with 112 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

32
client.go
View file

@ -5,16 +5,16 @@
package main
import (
"net"
"bufio"
"log"
"os"
"encoding/binary"
"goprotobuf.googlecode.com/hg/proto"
"mumbleproto"
"grumble/blobstore"
"grumble/cryptstate"
"grumble/mumbleproto"
"io"
"log"
"net"
"os"
"packetdatastream"
"time"
)
@ -187,7 +187,7 @@ func (client *Client) RejectAuth(kind, reason string) {
reasonString = proto.String(reason)
}
client.sendProtoMessage(MessageReject, &mumbleproto.Reject{
client.sendProtoMessage(mumbleproto.MessageReject, &mumbleproto.Reject{
Type: mumbleproto.NewReject_RejectType(mumbleproto.Reject_RejectType_value[kind]),
Reason: reasonString,
})
@ -265,7 +265,7 @@ func (c *Client) sendPermissionDeniedTypeUser(kind string, user *Client) {
}
c.msgchan <- &Message{
buf: d,
kind: MessagePermissionDenied,
kind: mumbleproto.MessagePermissionDenied,
}
} else {
c.Panicf("Unknown permission denied type.")
@ -285,7 +285,7 @@ func (c *Client) sendPermissionDenied(who *Client, where *Channel, what Permissi
}
c.msgchan <- &Message{
buf: d,
kind: MessagePermissionDenied,
kind: mumbleproto.MessagePermissionDenied,
}
}
@ -307,11 +307,11 @@ func (client *Client) udpreceiver() {
kind := (buf[0] >> 5) & 0x07
switch kind {
case UDPMessageVoiceSpeex:
case mumbleproto.UDPMessageVoiceSpeex:
fallthrough
case UDPMessageVoiceCELTAlpha:
case mumbleproto.UDPMessageVoiceCELTAlpha:
fallthrough
case UDPMessageVoiceCELTBeta:
case mumbleproto.UDPMessageVoiceCELTBeta:
kind := buf[0] & 0xe0
target := buf[0] & 0x1f
var counter uint8
@ -348,7 +348,7 @@ func (client *Client) udpreceiver() {
})
}
case UDPMessagePing:
case mumbleproto.UDPMessagePing:
client.server.udpsend <- &Message{
buf: buf,
client: client,
@ -363,7 +363,7 @@ func (client *Client) sendUdp(msg *Message) {
client.server.udpsend <- msg
} else {
client.Printf("Sent TCP!")
msg.kind = MessageUDPTunnel
msg.kind = mumbleproto.MessageUDPTunnel
client.msgchan <- msg
}
}
@ -445,7 +445,7 @@ func (client *Client) receiver() {
}
// Special case UDPTunnel messages. They're high priority and shouldn't
// go through our synchronous path.
if msg.kind == MessageUDPTunnel {
if msg.kind == mumbleproto.MessageUDPTunnel {
client.udp = false
client.udprecv <- msg.buf
} else {
@ -485,7 +485,7 @@ func (client *Client) receiver() {
// information we must send it our version information so it knows
// what version of the protocol it should speak.
if client.state == StateClientConnected {
client.sendProtoMessage(MessageVersion, &mumbleproto.Version{
client.sendProtoMessage(mumbleproto.MessageVersion, &mumbleproto.Version{
Version: proto.Uint32(0x10203),
Release: proto.String("Grumble"),
})
@ -575,7 +575,7 @@ func (client *Client) sendChannelTree(channel *Channel) {
}
chanstate.Links = links
err := client.sendProtoMessage(MessageChannelState, chanstate)
err := client.sendProtoMessage(mumbleproto.MessageChannelState, chanstate)
if err != nil {
client.Panicf("%v", err)
}
@ -593,7 +593,7 @@ func (client *Client) cryptResync() {
if requestElapsed > 5 {
client.lastResync = time.Seconds()
cryptsetup := &mumbleproto.CryptSetup{}
err := client.sendProtoMessage(MessageCryptSetup, cryptsetup)
err := client.sendProtoMessage(mumbleproto.MessageCryptSetup, cryptsetup)
if err != nil {
client.Panicf("%v", err)
}

2
freeze.go
View file

@ -8,10 +8,10 @@ import (
"goprotobuf.googlecode.com/hg/proto"
"grumble/ban"
"grumble/freezer"
"grumble/mumbleproto"
"grumble/serverconf"
"io/ioutil"
"log"
"mumbleproto"
"os"
"path/filepath"
"strconv"

83
message.go
View file

@ -12,48 +12,11 @@ import (
"grumble/ban"
"grumble/blobstore"
"grumble/freezer"
"mumbleproto"
"grumble/mumbleproto"
"net"
"time"
)
// These are the different kinds of messages
// that are defined for the Mumble protocol
const (
MessageVersion = iota
MessageUDPTunnel
MessageAuthenticate
MessagePing
MessageReject
MessageServerSync
MessageChannelRemove
MessageChannelState
MessageUserRemove
MessageUserState
MessageBanList
MessageTextMessage
MessagePermissionDenied
MessageACL
MessageQueryUsers
MessageCryptSetup
MessageContextActionAdd
MessageContextAction
MessageUserList
MessageVoiceTarget
MessagePermissionQuery
MessageCodecVersion
MessageUserStats
MessageRequestBlob
MessageServerConfig
)
const (
UDPMessageVoiceCELTAlpha = iota
UDPMessagePing
UDPMessageVoiceSpeex
UDPMessageVoiceCELTBeta
)
type Message struct {
buf []byte
@ -94,7 +57,7 @@ func (server *Server) handleCryptSetup(client *Client, msg *Message) {
if copy(cs.ClientNonce, client.crypt.EncryptIV[0:]) != aes.BlockSize {
return
}
client.sendProtoMessage(MessageCryptSetup, cs)
client.sendProtoMessage(mumbleproto.MessageCryptSetup, cs)
} else {
client.Printf("Received client nonce")
if len(cs.ClientNonce) != aes.BlockSize {
@ -150,7 +113,7 @@ func (server *Server) handlePingMessage(client *Client, msg *Message) {
client.TcpPackets = *ping.TcpPackets
}
client.sendProtoMessage(MessagePing, &mumbleproto.Ping{
client.sendProtoMessage(mumbleproto.MessagePing, &mumbleproto.Ping{
Timestamp: ping.Timestamp,
Good: proto.Uint32(uint32(client.crypt.Good)),
Late: proto.Uint32(uint32(client.crypt.Late)),
@ -339,7 +302,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
chanstate.ChannelId = proto.Uint32(uint32(channel.Id))
// Broadcast channel add
server.broadcastProtoMessageWithPredicate(MessageChannelState, chanstate, func(client *Client) bool {
server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool {
return client.Version < 0x10202
})
@ -348,7 +311,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
chanstate.Description = nil
chanstate.DescriptionHash = channel.DescriptionBlobHashBytes()
}
server.broadcastProtoMessageWithPredicate(MessageChannelState, chanstate, func(client *Client) bool {
server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool {
return client.Version >= 0x10202
})
@ -358,7 +321,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
userstate.Session = proto.Uint32(client.Session)
userstate.ChannelId = proto.Uint32(uint32(channel.Id))
server.userEnterChannel(client, channel, userstate)
server.broadcastProtoMessage(MessageUserState, userstate)
server.broadcastProtoMessage(mumbleproto.MessageUserState, userstate)
}
} else {
// Edit existing channel.
@ -503,7 +466,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
}
// Broadcast the update
server.broadcastProtoMessageWithPredicate(MessageChannelState, chanstate, func(client *Client) bool {
server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool {
return client.Version < 0x10202
})
@ -513,7 +476,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
chanstate.DescriptionHash = channel.DescriptionBlobHashBytes()
}
chanstate.DescriptionHash = channel.DescriptionBlobHashBytes()
server.broadcastProtoMessageWithPredicate(MessageChannelState, chanstate, func(client *Client) bool {
server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool {
return client.Version >= 0x10202
})
}
@ -574,7 +537,7 @@ func (server *Server) handleUserRemoveMessage(client *Client, msg *Message) {
}
userremove.Actor = proto.Uint32(uint32(client.Session))
if err = server.broadcastProtoMessage(MessageUserRemove, userremove); err != nil {
if err = server.broadcastProtoMessage(mumbleproto.MessageUserRemove, userremove); err != nil {
server.Panicf("Unable to broadcast UserRemove message")
return
}
@ -823,7 +786,7 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
txtmsg.Message = proto.String(fmt.Sprintf("User '%s' stopped recording", target.ShownName()))
}
server.broadcastProtoMessageWithPredicate(MessageTextMessage, txtmsg, func(client *Client) bool {
server.broadcastProtoMessageWithPredicate(mumbleproto.MessageTextMessage, txtmsg, func(client *Client) bool {
return client.Version < 0x10203
})
@ -866,7 +829,7 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
// The sent texture is a new-style texture. Strip it from the message
// we send to pre-1.2.2 clients.
userstate.Texture = nil
err := server.broadcastProtoMessageWithPredicate(MessageUserState, userstate, func(client *Client) bool {
err := server.broadcastProtoMessageWithPredicate(mumbleproto.MessageUserState, userstate, func(client *Client) bool {
return client.Version < 0x10202
})
if err != nil {
@ -876,7 +839,7 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
userstate.Texture = texture
} else {
// Old style texture. We can send the message as-is.
err := server.broadcastProtoMessageWithPredicate(MessageUserState, userstate, func(client *Client) bool {
err := server.broadcastProtoMessageWithPredicate(mumbleproto.MessageUserState, userstate, func(client *Client) bool {
return client.Version < 0x10202
})
if err != nil {
@ -908,7 +871,7 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
server.ClearACLCache()
}
err := server.broadcastProtoMessageWithPredicate(MessageUserState, userstate, func(client *Client) bool {
err := server.broadcastProtoMessageWithPredicate(mumbleproto.MessageUserState, userstate, func(client *Client) bool {
return client.Version >= 0x10203
})
if err != nil {
@ -951,7 +914,7 @@ func (server *Server) handleBanListMessage(client *Client, msg *Message) {
entry.Duration = proto.Uint32(ban.Duration)
banlist.Bans = append(banlist.Bans, entry)
}
if err := client.sendProtoMessage(MessageBanList, banlist); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageBanList, banlist); err != nil {
client.Panic("Unable to send BanList")
}
} else {
@ -1051,7 +1014,7 @@ func (server *Server) handleTextMessage(client *Client, msg *Message) {
clients[client.Session] = nil, false
for _, target := range clients {
target.sendProtoMessage(MessageTextMessage, &mumbleproto.TextMessage{
target.sendProtoMessage(mumbleproto.MessageTextMessage, &mumbleproto.TextMessage{
Actor: proto.Uint32(client.Session),
Message: txtmsg.Message,
})
@ -1180,7 +1143,7 @@ func (server *Server) handleAclMessage(client *Client, msg *Message) {
reply.Groups = append(reply.Groups, mpgroup)
}
if err := client.sendProtoMessage(MessageACL, reply); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageACL, reply); err != nil {
client.Panic(err.String())
}
@ -1196,7 +1159,7 @@ func (server *Server) handleAclMessage(client *Client, msg *Message) {
queryusers.Names = append(queryusers.Names, user.Name)
}
if len(queryusers.Ids) > 0 {
client.sendProtoMessage(MessageQueryUsers, queryusers)
client.sendProtoMessage(mumbleproto.MessageQueryUsers, queryusers)
}
// Set new groups and ACLs
@ -1303,7 +1266,7 @@ func (server *Server) handleQueryUsers(client *Client, msg *Message) {
}
}
if err := client.sendProtoMessage(MessageQueryUsers, reply); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageQueryUsers, reply); err != nil {
client.Panic(err.String())
return
}
@ -1407,7 +1370,7 @@ func (server *Server) handleUserStatsMessage(client *Client, msg *Message) {
// fixme(mkrautz): we don't do bandwidth tracking yet
if err := client.sendProtoMessage(MessageUserStats, stats); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageUserStats, stats); err != nil {
client.Panic(err.String())
return
}
@ -1455,7 +1418,7 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
userstate.Reset()
userstate.Session = proto.Uint32(uint32(target.Session))
userstate.Texture = buf
if err := client.sendProtoMessage(MessageUserState, userstate); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageUserState, userstate); err != nil {
client.Panic(err.String())
return
}
@ -1479,7 +1442,7 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
userstate.Reset()
userstate.Session = proto.Uint32(uint32(target.Session))
userstate.Comment = proto.String(string(buf))
if err := client.sendProtoMessage(MessageUserState, userstate); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageUserState, userstate); err != nil {
client.Panic(err.String())
return
}
@ -1502,7 +1465,7 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
}
chanstate.ChannelId = proto.Uint32(uint32(channel.Id))
chanstate.Description = proto.String(string(buf))
if err := client.sendProtoMessage(MessageChannelState, chanstate); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageChannelState, chanstate); err != nil {
client.Panic(err.String())
return
}
@ -1538,7 +1501,7 @@ func (server *Server) handleUserList(client *Client, msg *Message) {
Name: proto.String(user.Name),
})
}
if err := client.sendProtoMessage(MessageUserList, userlist); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageUserList, userlist); err != nil {
client.Panic(err.String())
return
}

5
pkg/mumbleproto/Makefile
View file

@ -1,8 +1,9 @@
include $(GOROOT)/src/Make.inc
TARG = mumbleproto
TARG = grumble/mumbleproto
GOFILES=\
Mumble.pb.go
Mumble.pb.go \
types.go
include $(GOROOT)/src/Make.pkg
include $(GOROOT)/src/pkg/goprotobuf.googlecode.com/hg/Make.protobuf

40
pkg/mumbleproto/types.go Normal file
View file

@ -0,0 +1,40 @@
// Copyright (c) 2011 The Grumble Authors
// The use of this source code is goverened by a BSD-style
// license that can be found in the LICENSE-file.
package mumbleproto
const (
MessageVersion = iota
MessageUDPTunnel
MessageAuthenticate
MessagePing
MessageReject
MessageServerSync
MessageChannelRemove
MessageChannelState
MessageUserRemove
MessageUserState
MessageBanList
MessageTextMessage
MessagePermissionDenied
MessageACL
MessageQueryUsers
MessageCryptSetup
MessageContextActionAdd
MessageContextAction
MessageUserList
MessageVoiceTarget
MessagePermissionQuery
MessageCodecVersion
MessageUserStats
MessageRequestBlob
MessageServerConfig
)
const (
UDPMessageVoiceCELTAlpha = iota
UDPMessagePing
UDPMessageVoiceSpeex
UDPMessageVoiceCELTBeta
)

58
server.go
View file

@ -19,11 +19,11 @@ import (
"grumble/cryptstate"
"grumble/freezer"
"grumble/htmlfilter"
"grumble/mumbleproto"
"grumble/serverconf"
"grumble/sessionpool"
"hash"
"log"
"mumbleproto"
"net"
"os"
"path/filepath"
@ -302,7 +302,7 @@ func (server *Server) RemoveClient(client *Client, kicked bool) {
// If the user is disconnect via a kick, the UserRemove message has already been sent
// at this point.
if !kicked && client.state > StateClientAuthenticated {
err := server.broadcastProtoMessage(MessageUserRemove, &mumbleproto.UserRemove{
err := server.broadcastProtoMessage(mumbleproto.MessageUserRemove, &mumbleproto.UserRemove{
Session: proto.Uint32(client.Session),
})
if err != nil {
@ -403,7 +403,7 @@ func (server *Server) handler() {
// will send the channel tree, user list, etc. to the client.
func (server *Server) handleAuthenticate(client *Client, msg *Message) {
// Is this message not an authenticate message? If not, discard it...
if msg.kind != MessageAuthenticate {
if msg.kind != mumbleproto.MessageAuthenticate {
client.Panic("Unexpected message. Expected Authenticate.")
return
}
@ -499,7 +499,7 @@ func (server *Server) handleAuthenticate(client *Client, msg *Message) {
// Send CryptState information to the client so it can establish an UDP connection,
// if it wishes.
client.lastResync = time.Seconds()
err = client.sendProtoMessage(MessageCryptSetup, &mumbleproto.CryptSetup{
err = client.sendProtoMessage(mumbleproto.MessageCryptSetup, &mumbleproto.CryptSetup{
Key: client.crypt.RawKey[0:],
ClientNonce: client.crypt.DecryptIV[0:],
ServerNonce: client.crypt.EncryptIV[0:],
@ -601,7 +601,7 @@ func (server *Server) finishAuthenticate(client *Client) {
}
server.userEnterChannel(client, server.RootChannel(), userstate)
if err := server.broadcastProtoMessage(MessageUserState, userstate); err != nil {
if err := server.broadcastProtoMessage(mumbleproto.MessageUserState, userstate); err != nil {
// Server panic?
}
@ -623,12 +623,12 @@ func (server *Server) finishAuthenticate(client *Client) {
perm.ClearCacheBit()
sync.Permissions = proto.Uint64(uint64(perm))
}
if err := client.sendProtoMessage(MessageServerSync, sync); err != nil {
if err := client.sendProtoMessage(mumbleproto.MessageServerSync, sync); err != nil {
client.Panicf("%v", err)
return
}
err := client.sendProtoMessage(MessageServerConfig, &mumbleproto.ServerConfig{
err := client.sendProtoMessage(mumbleproto.MessageServerConfig, &mumbleproto.ServerConfig{
AllowHtml: proto.Bool(server.cfg.BoolValue("AllowHTML")),
MessageLength: proto.Uint32(server.cfg.Uint32Value("MaxTextMessageLength")),
ImageMessageLength: proto.Uint32(server.cfg.Uint32Value("MaxImageMessageLength")),
@ -686,7 +686,7 @@ func (server *Server) updateCodecVersions() {
server.BetaCodec = winner
}
err := server.broadcastProtoMessage(MessageCodecVersion, &mumbleproto.CodecVersion{
err := server.broadcastProtoMessage(mumbleproto.MessageCodecVersion, &mumbleproto.CodecVersion{
Alpha: proto.Int32(server.AlphaCodec),
Beta: proto.Int32(server.BetaCodec),
PreferAlpha: proto.Bool(server.PreferAlphaCodec),
@ -774,7 +774,7 @@ func (server *Server) sendUserList(client *Client) {
userstate.PluginIdentity = proto.String(connectedClient.PluginIdentity)
}
err := client.sendProtoMessage(MessageUserState, userstate)
err := client.sendProtoMessage(mumbleproto.MessageUserState, userstate)
if err != nil {
// Server panic?
continue
@ -794,7 +794,7 @@ func (server *Server) sendClientPermissions(client *Client, channel *Channel) {
perm := server.aclcache.GetPermission(client, channel)
// fixme(mkrautz): Cache which permissions we've already sent.
client.sendProtoMessage(MessagePermissionQuery, &mumbleproto.PermissionQuery{
client.sendProtoMessage(mumbleproto.MessagePermissionQuery, &mumbleproto.PermissionQuery{
ChannelId: proto.Uint32(uint32(channel.Id)),
Permissions: proto.Uint32(uint32(perm)),
})
@ -826,39 +826,39 @@ func (server *Server) broadcastProtoMessage(kind uint16, msg interface{}) (err o
func (server *Server) handleIncomingMessage(client *Client, msg *Message) {
switch msg.kind {
case MessageAuthenticate:
case mumbleproto.MessageAuthenticate:
server.handleAuthenticate(msg.client, msg)
case MessagePing:
case mumbleproto.MessagePing:
server.handlePingMessage(msg.client, msg)
case MessageChannelRemove:
case mumbleproto.MessageChannelRemove:
server.handleChannelRemoveMessage(msg.client, msg)
case MessageChannelState:
case mumbleproto.MessageChannelState:
server.handleChannelStateMessage(msg.client, msg)
case MessageUserState:
case mumbleproto.MessageUserState:
server.handleUserStateMessage(msg.client, msg)
case MessageUserRemove:
case mumbleproto.MessageUserRemove:
server.handleUserRemoveMessage(msg.client, msg)
case MessageBanList:
case mumbleproto.MessageBanList:
server.handleBanListMessage(msg.client, msg)
case MessageTextMessage:
case mumbleproto.MessageTextMessage:
server.handleTextMessage(msg.client, msg)
case MessageACL:
case mumbleproto.MessageACL:
server.handleAclMessage(msg.client, msg)
case MessageQueryUsers:
case mumbleproto.MessageQueryUsers:
server.handleQueryUsers(msg.client, msg)
case MessageCryptSetup:
case mumbleproto.MessageCryptSetup:
server.handleCryptSetup(msg.client, msg)
case MessageContextAction:
case mumbleproto.MessageContextAction:
server.Printf("MessageContextAction from client")
case MessageUserList:
case mumbleproto.MessageUserList:
server.handleUserList(msg.client, msg)
case MessageVoiceTarget:
case mumbleproto.MessageVoiceTarget:
server.Printf("MessageVoiceTarget from client")
case MessagePermissionQuery:
case mumbleproto.MessagePermissionQuery:
server.handlePermissionQuery(msg.client, msg)
case MessageUserStats:
case mumbleproto.MessageUserStats:
server.handleUserStatsMessage(msg.client, msg)
case MessageRequestBlob:
case mumbleproto.MessageRequestBlob:
server.handleRequestBlob(msg.client, msg)
}
}
@ -1120,7 +1120,7 @@ func (server *Server) RemoveChannel(channel *Channel) {
userstate.Session = proto.Uint32(client.Session)
userstate.ChannelId = proto.Uint32(uint32(target.Id))
server.userEnterChannel(client, target, userstate)
if err := server.broadcastProtoMessage(MessageUserState, userstate); err != nil {
if err := server.broadcastProtoMessage(mumbleproto.MessageUserState, userstate); err != nil {
server.Panicf("%v", err)
}
}
@ -1132,7 +1132,7 @@ func (server *Server) RemoveChannel(channel *Channel) {
chanremove := &mumbleproto.ChannelRemove{
ChannelId: proto.Uint32(uint32(channel.Id)),
}
if err := server.broadcastProtoMessage(MessageChannelRemove, chanremove); err != nil {
if err := server.broadcastProtoMessage(mumbleproto.MessageChannelRemove, chanremove); err != nil {
server.Panicf("%v", err)
}
}