diff --git a/client.go b/client.go index a39ab1e..06a05db 100644 --- a/client.go +++ b/client.go @@ -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) } diff --git a/freeze.go b/freeze.go index 8dd9671..2766f2a 100644 --- a/freeze.go +++ b/freeze.go @@ -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" diff --git a/message.go b/message.go index 7488223..2717576 100644 --- a/message.go +++ b/message.go @@ -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 } diff --git a/pkg/mumbleproto/Makefile b/pkg/mumbleproto/Makefile index 00e455d..ef8353b 100644 --- a/pkg/mumbleproto/Makefile +++ b/pkg/mumbleproto/Makefile @@ -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 diff --git a/pkg/mumbleproto/types.go b/pkg/mumbleproto/types.go new file mode 100644 index 0000000..d557d38 --- /dev/null +++ b/pkg/mumbleproto/types.go @@ -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 +) \ No newline at end of file diff --git a/server.go b/server.go index 741ae2c..8c4ba4b 100644 --- a/server.go +++ b/server.go @@ -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) } }