External/grumble
1
0
Fork 1
mirror of https://github.com/mumble-voip/grumble.git synced 2025-12-19 21:59:59 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Make source code compatible with the latest releases.

Browse source
This commit is contained in:
Mikkel Krautz 2010-11-05 21:22:50 +01:00
parent 73ab596ae6
commit aa3f0add53
4 changed files with 55 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

13
client.go
View file

@ -148,12 +148,10 @@ func (client *ClientConnection) udpreceiver() {
func (client *ClientConnection) sendUdp(msg *Message) { func (client *ClientConnection) sendUdp(msg *Message) {
if client.udp { if client.udp {
// Send as UDP log.Printf("Sent UDP!")
log.Stdoutf("Sent UDP!")
client.server.udpsend <- msg client.server.udpsend <- msg
} else { } else {
// Tunnel through TCP log.Printf("Sent TCP!")
log.Stdoutf("Sent TCP!")
msg.kind = MessageUDPTunnel msg.kind = MessageUDPTunnel
client.msgchan <- msg client.msgchan <- msg
} }
@ -263,7 +261,7 @@ func (client *ClientConnection) sendChannelList() {
}) })
if err != nil { if err != nil {
// panic! // panic!
log.Stdoutf("poanic!") log.Printf("poanic!")
} }
} }
@ -274,15 +272,14 @@ func (client *ClientConnection) sendUserList() {
server.cmutex.RLock() server.cmutex.RLock()
defer server.cmutex.RUnlock() defer server.cmutex.RUnlock()
for x := range server.clients.Iter() { for _, user := range server.clients {
user := x.(*ClientConnection)
err := user.sendProtoMessage(MessageUserState, &mumbleproto.UserState{ err := user.sendProtoMessage(MessageUserState, &mumbleproto.UserState{
Session: proto.Uint32(client.Session), Session: proto.Uint32(client.Session),
Name: proto.String(client.Username), Name: proto.String(client.Username),
ChannelId: proto.Uint32(0), ChannelId: proto.Uint32(0),
}) })
if err != nil { if err != nil {
log.Stdoutf("unable to send!") log.Printf("unable to send!")
continue continue
} }
} }

19
message.go
View file

@ -10,7 +10,6 @@ import (
"mumbleproto" "mumbleproto"
"goprotobuf.googlecode.com/hg/proto" "goprotobuf.googlecode.com/hg/proto"
"net" "net"
"container/list"
"cryptstate" "cryptstate"
) )
@ -77,14 +76,14 @@ func (server *Server) handleCryptSetup(client *ClientConnection, msg *Message) {
// No client nonce. This means the client // No client nonce. This means the client
// is requesting that we re-sync our nonces. // is requesting that we re-sync our nonces.
if len(cs.ClientNonce) == 0 { if len(cs.ClientNonce) == 0 {
log.Stdoutf("Requested crypt-nonce resync") log.Printf("Requested crypt-nonce resync")
cs.ClientNonce = make([]byte, cryptstate.AESBlockSize) cs.ClientNonce = make([]byte, cryptstate.AESBlockSize)
if copy(cs.ClientNonce, client.crypt.EncryptIV[0:]) != cryptstate.AESBlockSize { if copy(cs.ClientNonce, client.crypt.EncryptIV[0:]) != cryptstate.AESBlockSize {
return return
} }
client.sendProtoMessage(MessageCryptSetup, cs) client.sendProtoMessage(MessageCryptSetup, cs)
} else { } else {
log.Stdoutf("Received client nonce") log.Printf("Received client nonce")
if len(cs.ClientNonce) != cryptstate.AESBlockSize { if len(cs.ClientNonce) != cryptstate.AESBlockSize {
return return
} }
@ -93,7 +92,7 @@ func (server *Server) handleCryptSetup(client *ClientConnection, msg *Message) {
if copy(client.crypt.DecryptIV[0:], cs.ClientNonce) != cryptstate.AESBlockSize { if copy(client.crypt.DecryptIV[0:], cs.ClientNonce) != cryptstate.AESBlockSize {
return return
} }
log.Stdoutf("Crypt re-sync successful") log.Printf("Crypt re-sync successful")
} }
} }
@ -142,19 +141,13 @@ func (server *Server) handleTextMessage(client *ClientConnection, msg *Message)
return return
} }
// Receiver list... users := []*ClientConnection{};
users := list.New()
for i := 0; i < len(txtmsg.Session); i++ { for i := 0; i < len(txtmsg.Session); i++ {
// Lookup user by ID
user := server.getClientConnection(txtmsg.Session[i]) user := server.getClientConnection(txtmsg.Session[i])
if user != nil { users = append(users, user)
users.PushBack(user)
}
} }
for x := range users.Iter() { for _, user := range users {
user := x.(*ClientConnection)
user.sendProtoMessage(MessageTextMessage, &mumbleproto.TextMessage{ user.sendProtoMessage(MessageTextMessage, &mumbleproto.TextMessage{
Actor: proto.Uint32(client.Session), Actor: proto.Uint32(client.Session),
Message: txtmsg.Message, Message: txtmsg.Message,

78
server.go
View file

@ -54,7 +54,7 @@ type Server struct {
// A list of all connected clients // A list of all connected clients
cmutex *sync.RWMutex cmutex *sync.RWMutex
clients *list.List clients []*ClientConnection
// Codec information // Codec information
AlphaCodec int32 AlphaCodec int32
@ -83,7 +83,6 @@ func NewServer(addr string, port int) (s *Server, err os.Error) {
// Create the list of connected clients // Create the list of connected clients
s.cmutex = new(sync.RWMutex) s.cmutex = new(sync.RWMutex)
s.clients = list.New()
s.outgoing = make(chan *Message) s.outgoing = make(chan *Message)
s.incoming = make(chan *Message) s.incoming = make(chan *Message)
@ -112,7 +111,7 @@ func (server *Server) NewClient(conn net.Conn) (err os.Error) {
// Get the address of the connected client // Get the address of the connected client
if addr := conn.RemoteAddr(); addr != nil { if addr := conn.RemoteAddr(); addr != nil {
client.tcpaddr = addr.(*net.TCPAddr) client.tcpaddr = addr.(*net.TCPAddr)
log.Stdoutf("client connected: %s", client.tcpaddr.String()) log.Printf("client connected: %s", client.tcpaddr.String())
} }
client.server = server client.server = server
@ -130,7 +129,7 @@ func (server *Server) NewClient(conn net.Conn) (err os.Error) {
// Add it to the list of connected clients // Add it to the list of connected clients
server.cmutex.Lock() server.cmutex.Lock()
server.clients.PushBack(client) server.clients = append(server.clients, client)
server.cmutex.Unlock() server.cmutex.Unlock()
go client.receiver() go client.receiver()
@ -145,8 +144,7 @@ func (server *Server) getClientConnection(session uint32) (client *ClientConnect
server.cmutex.RLock() server.cmutex.RLock()
defer server.cmutex.RUnlock() defer server.cmutex.RUnlock()
for x := range server.clients.Iter() { for _, user := range server.clients {
user := x.(*ClientConnection)
if user.Session == session { if user.Session == session {
return user return user
} }
@ -263,8 +261,7 @@ func (server *Server) updateCodecVersions() {
server.cmutex.RLock() server.cmutex.RLock()
defer server.cmutex.RUnlock() defer server.cmutex.RUnlock()
for x := range server.clients.Iter() { for _, client := range server.clients {
client := x.(*ClientConnection)
for i := 0; i < len(client.codecs); i++ { for i := 0; i < len(client.codecs); i++ {
codecusers[client.codecs[i]] += 1 codecusers[client.codecs[i]] += 1
} }
@ -307,11 +304,11 @@ func (server *Server) updateCodecVersions() {
PreferAlpha: proto.Bool(server.PreferAlphaCodec), PreferAlpha: proto.Bool(server.PreferAlphaCodec),
}) })
if err != nil { if err != nil {
log.Stdoutf("Unable to broadcast..") log.Printf("Unable to broadcast.")
return return
} }
log.Stdoutf("CELT codec switch %v %v (PreferAlpha %v)", server.AlphaCodec, server.BetaCodec, server.PreferAlphaCodec) log.Printf("CELT codec switch %v %v (PreferAlpha %v)", server.AlphaCodec, server.BetaCodec, server.PreferAlphaCodec)
return return
} }
@ -320,8 +317,7 @@ func (server *Server) sendUserList(client *ClientConnection) {
server.cmutex.RLock() server.cmutex.RLock()
defer server.cmutex.RUnlock() defer server.cmutex.RUnlock()
for x := range server.clients.Iter() { for _, user := range server.clients {
user := x.(*ClientConnection)
if user.state != StateClientAuthenticated { if user.state != StateClientAuthenticated {
continue continue
} }
@ -332,10 +328,10 @@ func (server *Server) sendUserList(client *ClientConnection) {
ChannelId: proto.Uint32(0), ChannelId: proto.Uint32(0),
}) })
log.Stdoutf("Sent One User...") log.Printf("Sent one user")
if err != nil { if err != nil {
log.Stdoutf("unable to send!") log.Printf("unable to send!")
continue continue
} }
} }
@ -346,8 +342,7 @@ func (server *Server) broadcastProtoMessage(kind uint16, msg interface{}) (err o
server.cmutex.RLock() server.cmutex.RLock()
defer server.cmutex.RUnlock() defer server.cmutex.RUnlock()
for x := range server.clients.Iter() { for _, client := range server.clients {
client := x.(*ClientConnection)
if client.state != StateClientAuthenticated { if client.state != StateClientAuthenticated {
continue continue
} }
@ -361,7 +356,7 @@ func (server *Server) broadcastProtoMessage(kind uint16, msg interface{}) (err o
} }
func (server *Server) handleIncomingMessage(client *ClientConnection, msg *Message) { func (server *Server) handleIncomingMessage(client *ClientConnection, msg *Message) {
log.Stdoutf("Handle Incoming Message") log.Printf("Handle Incoming Message")
switch msg.kind { switch msg.kind {
case MessagePing: case MessagePing:
server.handlePingMessage(msg.client, msg) server.handlePingMessage(msg.client, msg)
@ -384,30 +379,30 @@ func (server *Server) handleIncomingMessage(client *ClientConnection, msg *Messa
case MessageCryptSetup: case MessageCryptSetup:
server.handleCryptSetup(msg.client, msg) server.handleCryptSetup(msg.client, msg)
case MessageContextActionAdd: case MessageContextActionAdd:
log.Stdoutf("MessageContextActionAdd from client") log.Printf("MessageContextActionAdd from client")
case MessageContextAction: case MessageContextAction:
log.Stdoutf("MessageContextAction from client") log.Printf("MessageContextAction from client")
case MessageUserList: case MessageUserList:
log.Stdoutf("MessageUserList from client") log.Printf("MessageUserList from client")
case MessageVoiceTarget: case MessageVoiceTarget:
log.Stdoutf("MessageVoiceTarget from client") log.Printf("MessageVoiceTarget from client")
case MessagePermissionQuery: case MessagePermissionQuery:
log.Stdoutf("MessagePermissionQuery from client") log.Printf("MessagePermissionQuery from client")
case MessageCodecVersion: case MessageCodecVersion:
log.Stdoutf("MessageCodecVersion from client") log.Printf("MessageCodecVersion from client")
case MessageUserStats: case MessageUserStats:
server.handleUserStatsMessage(msg.client, msg) server.handleUserStatsMessage(msg.client, msg)
case MessageRequestBlob: case MessageRequestBlob:
log.Stdoutf("MessageRequestBlob from client") log.Printf("MessageRequestBlob from client")
case MessageServerConfig: case MessageServerConfig:
log.Stdoutf("MessageServerConfig from client") log.Printf("MessageServerConfig from client")
} }
} }
func (server *Server) multiplexer() { func (server *Server) multiplexer() {
for { for {
_ = <-server.outgoing _ = <-server.outgoing
log.Stdoutf("recvd message to multiplex") log.Printf("recvd message to multiplex")
} }
} }
@ -430,7 +425,9 @@ func (s *Server) SendUDP() {
// These are to be crypted... // These are to be crypted...
crypted := make([]byte, len(msg.buf)+4) crypted := make([]byte, len(msg.buf)+4)
msg.client.crypt.Encrypt(msg.buf, crypted) msg.client.crypt.Encrypt(msg.buf, crypted)
s.udpconn.WriteTo(crypted, msg.client.udpaddr) //s.udpconn.WriteTo(crypted, msg.client.udpaddr)
b := make([]byte, 1)
s.udpconn.WriteTo(b, msg.client.udpaddr)
} else if msg.address != nil { } else if msg.address != nil {
s.udpconn.WriteTo(msg.buf, msg.address) s.udpconn.WriteTo(msg.buf, msg.address)
} else { } else {
@ -451,7 +448,7 @@ func (server *Server) ListenUDP() {
udpaddr, ok := remote.(*net.UDPAddr) udpaddr, ok := remote.(*net.UDPAddr)
if !ok { if !ok {
log.Stdoutf("No UDPAddr in read packet. Disabling UDP. (Windows?)") log.Printf("No UDPAddr in read packet. Disabling UDP. (Windows?)")
return return
} }
@ -468,7 +465,7 @@ func (server *Server) ListenUDP() {
buffer := bytes.NewBuffer(make([]byte, 0, 24)) buffer := bytes.NewBuffer(make([]byte, 0, 24))
_ = binary.Write(buffer, binary.BigEndian, uint32((1<<16)|(2<<8)|2)) _ = binary.Write(buffer, binary.BigEndian, uint32((1<<16)|(2<<8)|2))
_ = binary.Write(buffer, binary.BigEndian, rand) _ = binary.Write(buffer, binary.BigEndian, rand)
_ = binary.Write(buffer, binary.BigEndian, uint32(server.clients.Len())) _ = binary.Write(buffer, binary.BigEndian, uint32(len(server.clients)))
_ = binary.Write(buffer, binary.BigEndian, uint32(server.MaxUsers)) _ = binary.Write(buffer, binary.BigEndian, uint32(server.MaxUsers))
_ = binary.Write(buffer, binary.BigEndian, uint32(server.MaxBandwidth)) _ = binary.Write(buffer, binary.BigEndian, uint32(server.MaxBandwidth))
@ -483,8 +480,7 @@ func (server *Server) ListenUDP() {
// First, check if any of our clients match the net.UDPAddr... // First, check if any of our clients match the net.UDPAddr...
server.cmutex.RLock() server.cmutex.RLock()
for x := range server.clients.Iter() { for _, client := range server.clients {
client := x.(*ClientConnection)
if client.udpaddr.String() == udpaddr.String() { if client.udpaddr.String() == udpaddr.String() {
match = client match = client
} }
@ -494,9 +490,7 @@ func (server *Server) ListenUDP() {
// No matching client found. We must try to decrypt... // No matching client found. We must try to decrypt...
if match == nil { if match == nil {
server.cmutex.RLock() server.cmutex.RLock()
for x := range server.clients.Iter() { for _, client := range server.clients {
client := x.(*ClientConnection)
// Try to decrypt. // Try to decrypt.
err = client.crypt.Decrypt(buf[0:nread], plain[0:]) err = client.crypt.Decrypt(buf[0:nread], plain[0:])
if err != nil { if err != nil {
@ -509,7 +503,7 @@ func (server *Server) ListenUDP() {
// If we were able to successfully decrpyt, add // If we were able to successfully decrpyt, add
// the UDPAddr to the ClientConnection struct. // the UDPAddr to the ClientConnection struct.
log.Stdoutf("Client UDP connection established.") log.Printf("Client UDP connection established.")
client.udpaddr = remote.(*net.UDPAddr) client.udpaddr = remote.(*net.UDPAddr)
match = client match = client
@ -527,7 +521,7 @@ func (server *Server) ListenUDP() {
if !decrypted { if !decrypted {
err = match.crypt.Decrypt(buf[0:nread], plain[0:]) err = match.crypt.Decrypt(buf[0:nread], plain[0:])
if err != nil { if err != nil {
log.Stdoutf("Unable to decrypt from client..") log.Printf("Unable to decrypt from client..")
} }
} }
@ -548,11 +542,11 @@ func (s *Server) ListenAndMurmur() {
// Create a new listening TLS socket. // Create a new listening TLS socket.
l := NewTLSListener(s.port) l := NewTLSListener(s.port)
if l == nil { if l == nil {
log.Stderrf("Unable to create TLS listener") log.Printf("Unable to create TLS listener")
return return
} }
log.Stderrf("Created new Murmur instance on port %v", s.port) log.Printf("Created new Murmur instance on port %v", s.port)
// The main accept loop. Basically, we block // The main accept loop. Basically, we block
// until we get a new client connection, and // until we get a new client connection, and
@ -563,12 +557,12 @@ func (s *Server) ListenAndMurmur() {
// New client connected // New client connected
conn, err := l.Accept() conn, err := l.Accept()
if err != nil { if err != nil {
log.Stderrf("unable to accept()") log.Printf("unable to accept()")
} }
tls, ok := conn.(*tls.Conn) tls, ok := conn.(*tls.Conn)
if !ok { if !ok {
log.Stderrf("Not tls :(") log.Printf("Not tls :(")
} }
// Force the TLS handshake to get going. We'd like // Force the TLS handshake to get going. We'd like
@ -580,9 +574,9 @@ func (s *Server) ListenAndMurmur() {
// which wraps net.TCPConn. // which wraps net.TCPConn.
err = s.NewClient(conn) err = s.NewClient(conn)
if err != nil { if err != nil {
log.Stderrf("Unable to start new client") log.Printf("Unable to start new client")
} }
log.Stdoutf("num clients = %v", s.clients.Len()) log.Printf("num clients = %v", len(s.clients))
} }
} }

16
tlsserver.go
View file

@ -17,34 +17,34 @@ func NewTLSListener(port int) (rl *tls.Listener) {
// Load the certificate // Load the certificate
pemBytes, err := ioutil.ReadFile("grumble.crt") pemBytes, err := ioutil.ReadFile("grumble.crt")
if err != nil { if err != nil {
log.Stderr("Failed to read server.crt:", err) log.Printf("Failed to read server.crt:", err)
return return
} }
// Decode the certificate // Decode the certificate
cert, _ := pem.Decode(pemBytes) cert, _ := pem.Decode(pemBytes)
if cert == nil { if cert == nil {
log.Stderr("Failed to parse server.crt") log.Printf("Failed to parse server.crt")
return return
} }
// Load the private key // Load the private key
keyBytes, err := ioutil.ReadFile("grumble.key") keyBytes, err := ioutil.ReadFile("grumble.key")
if err != nil { if err != nil {
log.Stderr("Failed to read server.key.insecure: %s", err) log.Printf("Failed to read server.key.insecure: %s", err)
return return
} }
// Decode the private key // Decode the private key
pkPEM, _ := pem.Decode(keyBytes) pkPEM, _ := pem.Decode(keyBytes)
if pkPEM == nil { if pkPEM == nil {
log.Stderrf("Failed to parse server.key.insecure: %s", err) log.Printf("Failed to parse server.key.insecure: %s", err)
return return
} }
// Determine if we are an RSA private key // Determine if we are an RSA private key
if pkPEM.Type != "RSA PRIVATE KEY" { if pkPEM.Type != "RSA PRIVATE KEY" {
log.Stderrf("server.key.insecure is not an RSA private key. Found '%s'", log.Printf("server.key.insecure is not an RSA private key. Found '%s'",
pkPEM.Type) pkPEM.Type)
return return
} }
@ -54,14 +54,14 @@ func NewTLSListener(port int) (rl *tls.Listener) {
// let us just assume that people will decrypt them for us, so // let us just assume that people will decrypt them for us, so
// we can use them without too much work. // we can use them without too much work.
if len(pkPEM.Headers) != 0 { if len(pkPEM.Headers) != 0 {
log.Stderr("server.key.insecure has headers and is probably encrypted.") log.Printf("server.key.insecure has headers and is probably encrypted.")
return return
} }
// Parse the PKCS12 private key. // Parse the PKCS12 private key.
priv, err := x509.ParsePKCS1PrivateKey(pkPEM.Bytes) priv, err := x509.ParsePKCS1PrivateKey(pkPEM.Bytes)
if err != nil { if err != nil {
log.Stderrf("Invalid key in server.key.insecure: %s", err) log.Printf("Invalid key in server.key.insecure: %s", err)
return return
} }
@ -78,7 +78,7 @@ func NewTLSListener(port int) (rl *tls.Listener) {
port, port,
}) })
if err != nil { if err != nil {
log.Stderrf("Cannot bind: %s\n", err) log.Printf("Cannot bind: %s\n", err)
return return
} }