From 0161969df1fcd7beff213e3a77d85e34f637bc7e Mon Sep 17 00:00:00 2001 From: Mikkel Krautz Date: Thu, 8 Sep 2011 12:57:10 +0200 Subject: [PATCH] Remove message kind parameter from sendProtoMessage and friends. --- client.go | 12 ++++---- grumble.go | 1 - message.go | 44 ++++++++++++++--------------- pkg/mumbleproto/types.go | 61 ++++++++++++++++++++++++++++++++++++++-- server.go | 28 +++++++++--------- 5 files changed, 101 insertions(+), 45 deletions(-) diff --git a/client.go b/client.go index 06a05db..1e25255 100644 --- a/client.go +++ b/client.go @@ -187,7 +187,7 @@ func (client *Client) RejectAuth(kind, reason string) { reasonString = proto.String(reason) } - client.sendProtoMessage(mumbleproto.MessageReject, &mumbleproto.Reject{ + client.sendProtoMessage(&mumbleproto.Reject{ Type: mumbleproto.NewReject_RejectType(mumbleproto.Reject_RejectType_value[kind]), Reason: reasonString, }) @@ -230,7 +230,7 @@ func (client *Client) readProtoMessage() (msg *Message, err os.Error) { } // Send a protobuf-encoded message -func (c *Client) sendProtoMessage(kind uint16, msg interface{}) (err os.Error) { +func (c *Client) sendProtoMessage(msg interface{}) (err os.Error) { d, err := proto.Marshal(msg) if err != nil { return @@ -238,7 +238,7 @@ func (c *Client) sendProtoMessage(kind uint16, msg interface{}) (err os.Error) { c.msgchan <- &Message{ buf: d, - kind: kind, + kind: mumbleproto.MessageType(msg), } return @@ -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(mumbleproto.MessageVersion, &mumbleproto.Version{ + client.sendProtoMessage(&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(mumbleproto.MessageChannelState, chanstate) + err := client.sendProtoMessage(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(mumbleproto.MessageCryptSetup, cryptsetup) + err := client.sendProtoMessage(cryptsetup) if err != nil { client.Panicf("%v", err) } diff --git a/grumble.go b/grumble.go index aba8b40..4518a52 100644 --- a/grumble.go +++ b/grumble.go @@ -137,7 +137,6 @@ func main() { os.Mkdir(filepath.Join(Args.DataDir, fmt.Sprintf("%v", 1)), 0750) s.FreezeToFile() - go s.ListenAndMurmur() } diff --git a/message.go b/message.go index 2717576..a8536ca 100644 --- a/message.go +++ b/message.go @@ -57,7 +57,7 @@ func (server *Server) handleCryptSetup(client *Client, msg *Message) { if copy(cs.ClientNonce, client.crypt.EncryptIV[0:]) != aes.BlockSize { return } - client.sendProtoMessage(mumbleproto.MessageCryptSetup, cs) + client.sendProtoMessage(cs) } else { client.Printf("Received client nonce") if len(cs.ClientNonce) != aes.BlockSize { @@ -113,7 +113,7 @@ func (server *Server) handlePingMessage(client *Client, msg *Message) { client.TcpPackets = *ping.TcpPackets } - client.sendProtoMessage(mumbleproto.MessagePing, &mumbleproto.Ping{ + client.sendProtoMessage(&mumbleproto.Ping{ Timestamp: ping.Timestamp, Good: proto.Uint32(uint32(client.crypt.Good)), Late: proto.Uint32(uint32(client.crypt.Late)), @@ -302,7 +302,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) { chanstate.ChannelId = proto.Uint32(uint32(channel.Id)) // Broadcast channel add - server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool { + server.broadcastProtoMessageWithPredicate(chanstate, func(client *Client) bool { return client.Version < 0x10202 }) @@ -311,7 +311,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) { chanstate.Description = nil chanstate.DescriptionHash = channel.DescriptionBlobHashBytes() } - server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool { + server.broadcastProtoMessageWithPredicate(chanstate, func(client *Client) bool { return client.Version >= 0x10202 }) @@ -321,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(mumbleproto.MessageUserState, userstate) + server.broadcastProtoMessage(userstate) } } else { // Edit existing channel. @@ -466,7 +466,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) { } // Broadcast the update - server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool { + server.broadcastProtoMessageWithPredicate(chanstate, func(client *Client) bool { return client.Version < 0x10202 }) @@ -476,7 +476,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) { chanstate.DescriptionHash = channel.DescriptionBlobHashBytes() } chanstate.DescriptionHash = channel.DescriptionBlobHashBytes() - server.broadcastProtoMessageWithPredicate(mumbleproto.MessageChannelState, chanstate, func(client *Client) bool { + server.broadcastProtoMessageWithPredicate(chanstate, func(client *Client) bool { return client.Version >= 0x10202 }) } @@ -537,7 +537,7 @@ func (server *Server) handleUserRemoveMessage(client *Client, msg *Message) { } userremove.Actor = proto.Uint32(uint32(client.Session)) - if err = server.broadcastProtoMessage(mumbleproto.MessageUserRemove, userremove); err != nil { + if err = server.broadcastProtoMessage(userremove); err != nil { server.Panicf("Unable to broadcast UserRemove message") return } @@ -786,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(mumbleproto.MessageTextMessage, txtmsg, func(client *Client) bool { + server.broadcastProtoMessageWithPredicate(txtmsg, func(client *Client) bool { return client.Version < 0x10203 }) @@ -829,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(mumbleproto.MessageUserState, userstate, func(client *Client) bool { + err := server.broadcastProtoMessageWithPredicate(userstate, func(client *Client) bool { return client.Version < 0x10202 }) if err != nil { @@ -839,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(mumbleproto.MessageUserState, userstate, func(client *Client) bool { + err := server.broadcastProtoMessageWithPredicate(userstate, func(client *Client) bool { return client.Version < 0x10202 }) if err != nil { @@ -871,7 +871,7 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) { server.ClearACLCache() } - err := server.broadcastProtoMessageWithPredicate(mumbleproto.MessageUserState, userstate, func(client *Client) bool { + err := server.broadcastProtoMessageWithPredicate(userstate, func(client *Client) bool { return client.Version >= 0x10203 }) if err != nil { @@ -914,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(mumbleproto.MessageBanList, banlist); err != nil { + if err := client.sendProtoMessage(banlist); err != nil { client.Panic("Unable to send BanList") } } else { @@ -1014,7 +1014,7 @@ func (server *Server) handleTextMessage(client *Client, msg *Message) { clients[client.Session] = nil, false for _, target := range clients { - target.sendProtoMessage(mumbleproto.MessageTextMessage, &mumbleproto.TextMessage{ + target.sendProtoMessage(&mumbleproto.TextMessage{ Actor: proto.Uint32(client.Session), Message: txtmsg.Message, }) @@ -1143,7 +1143,7 @@ func (server *Server) handleAclMessage(client *Client, msg *Message) { reply.Groups = append(reply.Groups, mpgroup) } - if err := client.sendProtoMessage(mumbleproto.MessageACL, reply); err != nil { + if err := client.sendProtoMessage(reply); err != nil { client.Panic(err.String()) } @@ -1159,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(mumbleproto.MessageQueryUsers, queryusers) + client.sendProtoMessage(queryusers) } // Set new groups and ACLs @@ -1266,7 +1266,7 @@ func (server *Server) handleQueryUsers(client *Client, msg *Message) { } } - if err := client.sendProtoMessage(mumbleproto.MessageQueryUsers, reply); err != nil { + if err := client.sendProtoMessage(reply); err != nil { client.Panic(err.String()) return } @@ -1370,7 +1370,7 @@ func (server *Server) handleUserStatsMessage(client *Client, msg *Message) { // fixme(mkrautz): we don't do bandwidth tracking yet - if err := client.sendProtoMessage(mumbleproto.MessageUserStats, stats); err != nil { + if err := client.sendProtoMessage(stats); err != nil { client.Panic(err.String()) return } @@ -1418,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(mumbleproto.MessageUserState, userstate); err != nil { + if err := client.sendProtoMessage(userstate); err != nil { client.Panic(err.String()) return } @@ -1442,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(mumbleproto.MessageUserState, userstate); err != nil { + if err := client.sendProtoMessage(userstate); err != nil { client.Panic(err.String()) return } @@ -1465,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(mumbleproto.MessageChannelState, chanstate); err != nil { + if err := client.sendProtoMessage(chanstate); err != nil { client.Panic(err.String()) return } @@ -1501,7 +1501,7 @@ func (server *Server) handleUserList(client *Client, msg *Message) { Name: proto.String(user.Name), }) } - if err := client.sendProtoMessage(mumbleproto.MessageUserList, userlist); err != nil { + if err := client.sendProtoMessage(userlist); err != nil { client.Panic(err.String()) return } diff --git a/pkg/mumbleproto/types.go b/pkg/mumbleproto/types.go index d557d38..8006f3e 100644 --- a/pkg/mumbleproto/types.go +++ b/pkg/mumbleproto/types.go @@ -5,7 +5,7 @@ package mumbleproto const ( - MessageVersion = iota + MessageVersion uint16 = iota MessageUDPTunnel MessageAuthenticate MessagePing @@ -37,4 +37,61 @@ const ( UDPMessagePing UDPMessageVoiceSpeex UDPMessageVoiceCELTBeta -) \ No newline at end of file +) + +// Returns the numeric value identifying the message type of msg on the wire. +func MessageType(msg interface{}) uint16 { + switch msg.(type) { + case *Version: + return MessageVersion + case *UDPTunnel: + return MessageUDPTunnel + case *Authenticate: + return MessageAuthenticate + case *Ping: + return MessagePing + case *Reject: + return MessageReject + case *ServerSync: + return MessageServerSync + case *ChannelRemove: + return MessageChannelRemove + case *ChannelState: + return MessageChannelState + case *UserRemove: + return MessageUserRemove + case *UserState: + return MessageUserState + case *BanList: + return MessageBanList + case *TextMessage: + return MessageTextMessage + case *PermissionDenied: + return MessagePermissionDenied + case *ACL: + return MessageACL + case *QueryUsers: + return MessageQueryUsers + case *CryptSetup: + return MessageCryptSetup + case *ContextActionAdd: + return MessageContextActionAdd + case *ContextAction: + return MessageContextAction + case *UserList: + return MessageUserList + case *VoiceTarget: + return MessageVoiceTarget + case *PermissionQuery: + return MessagePermissionQuery + case *CodecVersion: + return MessageCodecVersion + case *UserStats: + return MessageUserStats + case *RequestBlob: + return MessageRequestBlob + case *ServerConfig: + return MessageServerConfig + } + panic("unknown type") +} \ No newline at end of file diff --git a/server.go b/server.go index 8c4ba4b..64de31a 100644 --- a/server.go +++ b/server.go @@ -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(mumbleproto.MessageUserRemove, &mumbleproto.UserRemove{ + err := server.broadcastProtoMessage(&mumbleproto.UserRemove{ Session: proto.Uint32(client.Session), }) if err != nil { @@ -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(mumbleproto.MessageCryptSetup, &mumbleproto.CryptSetup{ + err = client.sendProtoMessage(&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(mumbleproto.MessageUserState, userstate); err != nil { + if err := server.broadcastProtoMessage(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(mumbleproto.MessageServerSync, sync); err != nil { + if err := client.sendProtoMessage(sync); err != nil { client.Panicf("%v", err) return } - err := client.sendProtoMessage(mumbleproto.MessageServerConfig, &mumbleproto.ServerConfig{ + err := client.sendProtoMessage(&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(mumbleproto.MessageCodecVersion, &mumbleproto.CodecVersion{ + err := server.broadcastProtoMessage(&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(mumbleproto.MessageUserState, userstate) + err := client.sendProtoMessage(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(mumbleproto.MessagePermissionQuery, &mumbleproto.PermissionQuery{ + client.sendProtoMessage(&mumbleproto.PermissionQuery{ ChannelId: proto.Uint32(uint32(channel.Id)), Permissions: proto.Uint32(uint32(perm)), }) @@ -802,7 +802,7 @@ func (server *Server) sendClientPermissions(client *Client, channel *Channel) { type ClientPredicate func(client *Client) bool -func (server *Server) broadcastProtoMessageWithPredicate(kind uint16, msg interface{}, clientcheck ClientPredicate) (err os.Error) { +func (server *Server) broadcastProtoMessageWithPredicate(msg interface{}, clientcheck ClientPredicate) (err os.Error) { for _, client := range server.clients { if !clientcheck(client) { continue @@ -810,7 +810,7 @@ func (server *Server) broadcastProtoMessageWithPredicate(kind uint16, msg interf if client.state < StateClientAuthenticated { continue } - err := client.sendProtoMessage(kind, msg) + err := client.sendProtoMessage(msg) if err != nil { return } @@ -819,8 +819,8 @@ func (server *Server) broadcastProtoMessageWithPredicate(kind uint16, msg interf return } -func (server *Server) broadcastProtoMessage(kind uint16, msg interface{}) (err os.Error) { - err = server.broadcastProtoMessageWithPredicate(kind, msg, func(client *Client) bool { return true }) +func (server *Server) broadcastProtoMessage(msg interface{}) (err os.Error) { + err = server.broadcastProtoMessageWithPredicate(msg, func(client *Client) bool { return true }) return } @@ -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(mumbleproto.MessageUserState, userstate); err != nil { + if err := server.broadcastProtoMessage(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(mumbleproto.MessageChannelRemove, chanremove); err != nil { + if err := server.broadcastProtoMessage(chanremove); err != nil { server.Panicf("%v", err) } }