Remove message kind parameter from sendProtoMessage and friends.

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)
 			}

grumble.go

@@ -137,7 +137,6 @@ func main() {
 
 		os.Mkdir(filepath.Join(Args.DataDir, fmt.Sprintf("%v", 1)), 0750)
 		s.FreezeToFile()
-
 		go s.ListenAndMurmur()
 	}
 

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
 		}

pkg/mumbleproto/types.go

@@ -5,7 +5,7 @@
 package mumbleproto
 
 const (
-	MessageVersion = iota
+	MessageVersion uint16 = iota
 	MessageUDPTunnel
 	MessageAuthenticate
 	MessagePing
@@ -38,3 +38,60 @@ const (
 	UDPMessageVoiceSpeex
 	UDPMessageVoiceCELTBeta
 )
+
+// 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")
+}

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) {
+func (server *Server) broadcastProtoMessage(msg interface{}) (err os.Error) {
-	err = server.broadcastProtoMessageWithPredicate(kind, msg, func(client *Client) bool { return true })
+	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)
 	}
 }