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

Major gofix run.

Browse source
This commit is contained in:
Mikkel Krautz 2011-11-08 15:05:13 +01:00
parent 92e6ac5276
commit 71b8314c2e
28 changed files with 522 additions and 559 deletions
Download patch file Download diff file Expand all files Collapse all files

2
args.go
View file

@ -66,7 +66,7 @@ func init() {
flag.BoolVar(&Args.GenerateCert, "gencert", false, "Generate a self-signed certificate for use with Grumble")
// SQLite related
if (SQLiteSupport) {
if SQLiteSupport {
flag.StringVar(&Args.SQLiteDB, "murmurdb", "", "Path to a Murmur SQLite database to import from")
flag.BoolVar(&Args.CleanUp, "cleanup", false, "Clean up Grumble's data directory on launch")
}

4
channel.go
View file

@ -55,7 +55,7 @@ func (channel *Channel) AddChild(child *Channel) {
// Remove a child channel from a parent
func (channel *Channel) RemoveChild(child *Channel) {
child.parent = nil
channel.children[child.Id] = nil, false
delete(channel.children, child.Id)
}
// Add client
@ -66,7 +66,7 @@ func (channel *Channel) AddClient(client *Client) {
// Remove client
func (channel *Channel) RemoveClient(client *Client) {
channel.clients[client.Session] = nil, false
delete(channel.clients, client.Session)
client.Channel = nil
}

15
client.go
View file

@ -14,7 +14,6 @@ import (
"io"
"log"
"net"
"os"
"packetdatastream"
"time"
)
@ -196,7 +195,7 @@ func (client *Client) RejectAuth(rejectType mumbleproto.Reject_RejectType, reaso
}
// Read a protobuf message from a client
func (client *Client) readProtoMessage() (msg *Message, err os.Error) {
func (client *Client) readProtoMessage() (msg *Message, err error) {
var (
length uint32
kind uint16
@ -230,7 +229,7 @@ func (client *Client) readProtoMessage() (msg *Message, err os.Error) {
}
// Send a protobuf-encoded message
func (c *Client) sendProtoMessage(msg interface{}) (err os.Error) {
func (c *Client) sendProtoMessage(msg interface{}) (err error) {
d, err := proto.Marshal(msg)
if err != nil {
return
@ -277,7 +276,7 @@ func (c *Client) sendPermissionDenied(who *Client, where *Channel, what Permissi
Type: mumbleproto.NewPermissionDenied_DenyType(mumbleproto.PermissionDenied_Permission),
})
if err != nil {
c.Panicf(err.String())
c.Panicf(err.Error())
}
c.msgchan <- &Message{
buf: d,
@ -370,7 +369,7 @@ func (client *Client) sendUdp(msg *Message) {
// This method should only be called from within the client's own
// sender goroutine, since it serializes access to the underlying
// buffered writer.
func (client *Client) sendMessage(msg *Message) os.Error {
func (client *Client) sendMessage(msg *Message) error {
// Write message kind
err := binary.Write(client.writer, binary.BigEndian, msg.kind)
if err != nil {
@ -432,7 +431,7 @@ func (client *Client) receiver() {
// Try to read the next message in the pool
msg, err := client.readProtoMessage()
if err != nil {
if err == os.EOF {
if err == io.EOF {
client.Disconnect()
} else {
client.Panicf("%v", err)
@ -454,7 +453,7 @@ func (client *Client) receiver() {
// Try to read the next message in the pool
msg, err := client.readProtoMessage()
if err != nil {
if err == os.EOF {
if err == io.EOF {
client.Disconnect()
} else {
client.Panicf("%v", err)
@ -492,7 +491,7 @@ func (client *Client) receiver() {
} else if client.state == StateServerSentVersion {
msg, err := client.readProtoMessage()
if err != nil {
if err == os.EOF {
if err == io.EOF {
client.Disconnect()
} else {
client.Panicf("%v", err)

24
ctlrpc.go
View file

@ -4,9 +4,7 @@
package main
import (
"os"
)
import "errors"
type ControlRPC struct {
@ -19,30 +17,30 @@ type KeyValuePair struct {
}
// Start a server
func (c *ControlRPC) Start(Id int64, out *int64) os.Error {
func (c *ControlRPC) Start(Id int64, out *int64) error {
server, exists := servers[Id]
if !exists {
return os.NewError("no such server")
return errors.New("no such server")
}
_ = server
return nil
}
// Stop a server
func (c *ControlRPC) Stop(Id int64, out *int) os.Error {
func (c *ControlRPC) Stop(Id int64, out *int) error {
server, exists := servers[Id]
if !exists {
return os.NewError("no such server")
return errors.New("no such server")
}
_ = server
return nil
}
// Set SuperUser password
func (c *ControlRPC) SetSuperUserPassword(in *KeyValuePair, out *int64) os.Error {
func (c *ControlRPC) SetSuperUserPassword(in *KeyValuePair, out *int64) error {
server, exists := servers[in.Id]
if !exists {
return os.NewError("no such server")
return errors.New("no such server")
}
server.SetSuperUserPassword(in.Value)
*out = in.Id
@ -50,10 +48,10 @@ func (c *ControlRPC) SetSuperUserPassword(in *KeyValuePair, out *int64) os.Error
}
// Set a config value
func (c *ControlRPC) SetConfig(in *KeyValuePair, out *KeyValuePair) os.Error {
func (c *ControlRPC) SetConfig(in *KeyValuePair, out *KeyValuePair) error {
server, exists := servers[in.Id]
if !exists {
return os.NewError("no such server")
return errors.New("no such server")
}
server.cfg.Set(in.Key, in.Value)
server.cfgUpdate <- in
@ -64,10 +62,10 @@ func (c *ControlRPC) SetConfig(in *KeyValuePair, out *KeyValuePair) os.Error {
}
// Get a config value
func (c *ControlRPC) GetConfig(in *KeyValuePair, out *KeyValuePair) os.Error {
func (c *ControlRPC) GetConfig(in *KeyValuePair, out *KeyValuePair) error {
server, exists := servers[in.Id]
if !exists {
return os.NewError("no such server")
return errors.New("no such server")
}
out.Id = in.Id
out.Key = in.Key

48
freeze.go
View file

@ -5,11 +5,13 @@
package main
import (
"errors"
"goprotobuf.googlecode.com/hg/proto"
"grumble/ban"
"grumble/freezer"
"grumble/mumbleproto"
"grumble/serverconf"
"io"
"io/ioutil"
"log"
"os"
@ -20,7 +22,7 @@ import (
// Freeze a server to disk, and re-open the log, if needed.
// This must be called from within the Server's synchronous handler.
func (server *Server) FreezeToFile() (err os.Error) {
func (server *Server) FreezeToFile() (err error) {
// Close the log file, if it's open
if server.freezelog != nil {
err = server.freezelog.Close()
@ -69,10 +71,10 @@ func (server *Server) FreezeToFile() (err os.Error) {
}
// Open a new freeze log
func (server *Server) openFreezeLog() (err os.Error) {
func (server *Server) openFreezeLog() (err error) {
logfn := filepath.Join(Args.DataDir, strconv.Itoa64(server.Id), "log.fz")
err = os.Remove(logfn)
if pe, ok := err.(*os.PathError); ok && pe.Error == os.ENOENT {
if pe, ok := err.(*os.PathError); ok && pe.Err == os.ENOENT {
// OK. File does not exist...
} else if err != nil {
return err
@ -86,7 +88,7 @@ func (server *Server) openFreezeLog() (err os.Error) {
// Freeze a server to a flattened protobuf-based structure ready to
// persist to disk.
func (server *Server) Freeze() (fs *freezer.Server, err os.Error) {
func (server *Server) Freeze() (fs *freezer.Server, err error) {
fs = new(freezer.Server)
// Freeze all config kv-pairs
@ -112,7 +114,7 @@ func (server *Server) Freeze() (fs *freezer.Server, err os.Error) {
for _, c := range server.Channels {
fc, err := c.Freeze()
if err != nil {
return
return nil, err
}
channels = append(channels, fc)
}
@ -123,13 +125,13 @@ func (server *Server) Freeze() (fs *freezer.Server, err os.Error) {
for _, u := range server.Users {
fu, err := u.Freeze()
if err != nil {
return
return nil, err
}
users = append(users, fu)
}
fs.Users = users
return
return fs, nil
}
// Merge the contents of a freezer.BanList into the server's
@ -180,7 +182,7 @@ func FreezeBan(ban ban.Ban) (fb *freezer.Ban) {
// Freeze a channel into a flattened protobuf-based struct
// ready to be persisted to disk.
func (channel *Channel) Freeze() (fc *freezer.Channel, err os.Error) {
func (channel *Channel) Freeze() (fc *freezer.Channel, err error) {
fc = new(freezer.Channel)
fc.Id = proto.Uint32(uint32(channel.Id))
@ -196,7 +198,7 @@ func (channel *Channel) Freeze() (fc *freezer.Channel, err os.Error) {
for _, acl := range channel.ACL {
facl, err := acl.Freeze()
if err != nil {
return
return nil, err
}
acls = append(acls, facl)
}
@ -207,7 +209,7 @@ func (channel *Channel) Freeze() (fc *freezer.Channel, err os.Error) {
for _, grp := range channel.Groups {
fgrp, err := grp.Freeze()
if err != nil {
return
return nil, err
}
groups = append(groups, fgrp)
}
@ -294,7 +296,7 @@ func (c *Channel) Unfreeze(fc *freezer.Channel) {
// Freeze a User into a flattened protobuf-based structure
// ready to be persisted to disk.
func (user *User) Freeze() (fu *freezer.User, err os.Error) {
func (user *User) Freeze() (fu *freezer.User, err error) {
fu = new(freezer.User)
fu.Id = proto.Uint32(user.Id)
@ -336,7 +338,7 @@ func (u *User) Unfreeze(fu *freezer.User) {
// Freeze a ChannelACL into it a flattened protobuf-based structure
// ready to be persisted to disk.
func (acl *ChannelACL) Freeze() (facl *freezer.ACL, err os.Error) {
func (acl *ChannelACL) Freeze() (facl *freezer.ACL, err error) {
facl = new(freezer.ACL)
if acl.UserId != -1 {
@ -354,7 +356,7 @@ func (acl *ChannelACL) Freeze() (facl *freezer.ACL, err os.Error) {
// Freeze a Group into a flattened protobuf-based structure
// ready to be persisted to disk.
func (group *Group) Freeze() (fgrp *freezer.Group, err os.Error) {
func (group *Group) Freeze() (fgrp *freezer.Group, err error) {
fgrp = new(freezer.Group)
fgrp.Name = proto.String(group.Name)
@ -382,7 +384,7 @@ func (group *Group) Freeze() (fgrp *freezer.Group, err os.Error) {
// Once both the full server and the log file has been merged together
// in memory, a new full seralized server will be written and synced to
// disk, and the existing log file will be removed.
func NewServerFromFrozen(name string) (s *Server, err os.Error) {
func NewServerFromFrozen(name string) (s *Server, err error) {
id, err := strconv.Atoi64(name)
if err != nil {
return nil, err
@ -457,7 +459,7 @@ func NewServerFromFrozen(name string) (s *Server, err os.Error) {
if fc.ParentId != nil {
parents[*fc.Id] = *fc.ParentId
} else {
parents[*fc.Id] = 0, false
delete(parents, *fc.Id)
}
}
@ -495,7 +497,7 @@ func NewServerFromFrozen(name string) (s *Server, err os.Error) {
for {
values, err := walker.Next()
if err == os.EOF {
if err == io.EOF {
break
} else if err != nil {
return nil, err
@ -566,10 +568,10 @@ func NewServerFromFrozen(name string) (s *Server, err os.Error) {
user, ok := s.Users[userId]
if ok {
// Clear the server maps. That should do it.
s.Users[userId] = nil, false
s.UserNameMap[user.Name] = nil, false
delete(s.Users, userId)
delete(s.UserNameMap, user.Name)
if len(user.CertHash) > 0 {
s.UserCertMap[user.CertHash] = nil, false
delete(s.UserCertMap, user.CertHash)
}
} else {
log.Printf("Skipped UserRemove log entry: No user for given id.")
@ -611,7 +613,7 @@ func NewServerFromFrozen(name string) (s *Server, err os.Error) {
if fc.ParentId != nil {
parents[*fc.Id] = *fc.ParentId
} else {
parents[*fc.Id] = 0, false
delete(parents, *fc.Id)
}
case *freezer.ChannelRemove:
@ -621,7 +623,7 @@ func NewServerFromFrozen(name string) (s *Server, err os.Error) {
continue
}
s.Channels[int(*fc.Id)] = nil
parents[*fc.Id] = 0, false
delete(parents, *fc.Id)
case *freezer.BanList:
fbl := val.(*freezer.BanList)
@ -646,11 +648,11 @@ func NewServerFromFrozen(name string) (s *Server, err os.Error) {
for chanId, parentId := range parents {
childChan, exists := s.Channels[int(chanId)]
if !exists {
return nil, os.NewError("Non-existant child channel")
return nil, errors.New("Non-existant child channel")
}
parentChan, exists := s.Channels[int(parentId)]
if !exists {
return nil, os.NewError("Non-existant parent channel")
return nil, errors.New("Non-existant parent channel")
}
parentChan.AddChild(childChan)
}

2
gencert.go
View file

@ -20,7 +20,7 @@ import (
// Generate a 2048-bit RSA keypair and a Grumble auto-generated X509
// certificate. Output PEM-encoded DER representations of the resulting
// certificate and private key to certpath and keypath.
func GenerateSelfSignedCert(certpath, keypath string) (err os.Error) {
func GenerateSelfSignedCert(certpath, keypath string) (err error) {
now := time.Seconds()
tmpl := &x509.Certificate{
SerialNumber: big.NewInt(0),

6
group.go
View file

@ -6,8 +6,8 @@ package main
import (
"log"
"strings"
"strconv"
"strings"
)
type Group struct {
@ -117,7 +117,7 @@ func (group *Group) Members() map[int]bool {
members[uid] = true
}
for uid, _ := range curgroup.Remove {
members[uid] = false, false
delete(members, uid)
}
}
@ -374,7 +374,7 @@ func (channel *Channel) GroupNames() map[string]bool {
for _, group := range iter.Groups {
// A non-inheritable group in parent. Discard it.
if channel != iter && !group.Inheritable {
names[group.Name] = false, false
delete(names, group.Name)
// An inheritable group. Add it to the list.
} else {
names[group.Name] = true

12
grumble.go
View file

@ -19,7 +19,7 @@ import (
var servers map[int64]*Server
func main() {
var err os.Error
var err error
flag.Parse()
if Args.ShowHelp == true {
@ -41,7 +41,7 @@ func main() {
log.Printf("Using blob directory: %s", Args.BlobDir)
err = blobstore.Open(Args.BlobDir, true)
if err != nil {
log.Fatalf("Unable to initialize blobstore: %v", err.String())
log.Fatalf("Unable to initialize blobstore: %v", err.Error())
}
if Args.GenerateCert {
@ -67,13 +67,13 @@ func main() {
if SQLiteSupport && len(Args.SQLiteDB) > 0 {
f, err := os.Open(Args.DataDir)
if err != nil {
log.Fatalf("Murmur import failed: %s", err.String())
log.Fatalf("Murmur import failed: %s", err.Error())
}
defer f.Close()
names, err := f.Readdirnames(-1)
if err != nil {
log.Fatalf("Murmur import failed: %s", err.String())
log.Fatalf("Murmur import failed: %s", err.Error())
}
if !Args.CleanUp && len(names) > 0 {
@ -90,7 +90,7 @@ func main() {
log.Printf("Importing Murmur data from '%s'", Args.SQLiteDB)
if err = MurmurImport(Args.SQLiteDB); err != nil {
log.Fatalf("Murmur import failed: %s", err.String())
log.Fatalf("Murmur import failed: %s", err.Error())
}
log.Printf("Import from Murmur SQLite database succeeded.")
@ -130,7 +130,7 @@ func main() {
if len(servers) == 0 {
s, err := NewServer(1, "0.0.0.0", 64738)
if err != nil {
log.Fatalf("Couldn't start server: %s", err.String())
log.Fatalf("Couldn't start server: %s", err.Error())
}
servers[s.Id] = s

71
message.go
View file

@ -45,7 +45,7 @@ func (server *Server) handleCryptSetup(client *Client, msg *Message) {
cs := &mumbleproto.CryptSetup{}
err := proto.Unmarshal(msg.buf, cs)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -76,7 +76,7 @@ func (server *Server) handlePingMessage(client *Client, msg *Message) {
ping := &mumbleproto.Ping{}
err := proto.Unmarshal(msg.buf, ping)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -126,7 +126,7 @@ func (server *Server) handleChannelRemoveMessage(client *Client, msg *Message) {
chanremove := &mumbleproto.ChannelRemove{}
err := proto.Unmarshal(msg.buf, chanremove)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -157,7 +157,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
chanstate := &mumbleproto.ChannelState{}
err := proto.Unmarshal(msg.buf, chanstate)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -262,7 +262,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
if len(description) > 0 {
key, err = blobstore.Put([]byte(description))
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
}
}
@ -444,7 +444,7 @@ func (server *Server) handleChannelStateMessage(client *Client, msg *Message) {
} else {
key, err := blobstore.Put([]byte(description))
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
}
channel.DescriptionBlob = key
}
@ -493,7 +493,8 @@ func (server *Server) handleUserRemoveMessage(client *Client, msg *Message) {
userremove := &mumbleproto.UserRemove{}
err := proto.Unmarshal(msg.buf, userremove)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
// Get the client to be removed.
@ -556,7 +557,8 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
userstate := &mumbleproto.UserState{}
err := proto.Unmarshal(msg.buf, userstate)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
actor, ok := server.clients[client.Session]
@ -700,7 +702,8 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
if userstate.Texture != nil && target.user != nil {
key, err := blobstore.Put(userstate.Texture)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
return
}
if target.user.TextureBlob != key {
@ -740,7 +743,7 @@ func (server *Server) handleUserStateMessage(client *Client, msg *Message) {
if userstate.Comment != nil && target.user != nil {
key, err := blobstore.Put([]byte(*userstate.Comment))
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
}
if target.user.CommentBlob != key {
@ -888,7 +891,7 @@ func (server *Server) handleBanListMessage(client *Client, msg *Message) {
banlist := &mumbleproto.BanList{}
err := proto.Unmarshal(msg.buf, banlist)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -955,7 +958,7 @@ func (server *Server) handleTextMessage(client *Client, msg *Message) {
txtmsg := &mumbleproto.TextMessage{}
err := proto.Unmarshal(msg.buf, txtmsg)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -1011,7 +1014,7 @@ func (server *Server) handleTextMessage(client *Client, msg *Message) {
}
// Remove ourselves
clients[client.Session] = nil, false
delete(clients, client.Session)
for _, target := range clients {
target.sendProtoMessage(&mumbleproto.TextMessage{
@ -1026,7 +1029,8 @@ func (server *Server) handleAclMessage(client *Client, msg *Message) {
acl := &mumbleproto.ACL{}
err := proto.Unmarshal(msg.buf, acl)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
// Look up the channel this ACL message operates on.
@ -1127,7 +1131,7 @@ func (server *Server) handleAclMessage(client *Client, msg *Message) {
}
for uid, _ := range group.Remove {
users[uid] = true
toadd[uid] = false, false
delete(toadd, uid)
}
for uid, _ := range toadd {
mpgroup.Add = append(mpgroup.Add, uint32(uid))
@ -1144,7 +1148,8 @@ func (server *Server) handleAclMessage(client *Client, msg *Message) {
}
if err := client.sendProtoMessage(reply); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
// Map the user ids in the user map to usernames of users.
@ -1243,7 +1248,8 @@ func (server *Server) handleQueryUsers(client *Client, msg *Message) {
query := &mumbleproto.QueryUsers{}
err := proto.Unmarshal(msg.buf, query)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
server.Printf("in handleQueryUsers")
@ -1267,7 +1273,7 @@ func (server *Server) handleQueryUsers(client *Client, msg *Message) {
}
if err := client.sendProtoMessage(reply); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
}
@ -1278,7 +1284,8 @@ func (server *Server) handleUserStatsMessage(client *Client, msg *Message) {
stats := &mumbleproto.UserStats{}
err := proto.Unmarshal(msg.buf, stats)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
if stats.Session == nil {
@ -1371,7 +1378,7 @@ func (server *Server) handleUserStatsMessage(client *Client, msg *Message) {
// fixme(mkrautz): we don't do bandwidth tracking yet
if err := client.sendProtoMessage(stats); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
}
@ -1381,7 +1388,8 @@ func (server *Server) handlePermissionQuery(client *Client, msg *Message) {
query := &mumbleproto.PermissionQuery{}
err := proto.Unmarshal(msg.buf, query)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
if query.ChannelId == nil {
@ -1397,7 +1405,7 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
blobreq := &mumbleproto.RequestBlob{}
err := proto.Unmarshal(msg.buf, blobreq)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -1413,13 +1421,14 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
if target.user.HasTexture() {
buf, err := blobstore.Get(target.user.TextureBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
return
}
userstate.Reset()
userstate.Session = proto.Uint32(uint32(target.Session))
userstate.Texture = buf
if err := client.sendProtoMessage(userstate); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
}
@ -1437,13 +1446,14 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
if target.user.HasComment() {
buf, err := blobstore.Get(target.user.CommentBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
return
}
userstate.Reset()
userstate.Session = proto.Uint32(uint32(target.Session))
userstate.Comment = proto.String(string(buf))
if err := client.sendProtoMessage(userstate); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
}
@ -1461,12 +1471,13 @@ func (server *Server) handleRequestBlob(client *Client, msg *Message) {
chanstate.Reset()
buf, err := blobstore.Get(channel.DescriptionBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err)
return
}
chanstate.ChannelId = proto.Uint32(uint32(channel.Id))
chanstate.Description = proto.String(string(buf))
if err := client.sendProtoMessage(chanstate); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
}
@ -1480,7 +1491,7 @@ func (server *Server) handleUserList(client *Client, msg *Message) {
userlist := &mumbleproto.UserList{}
err := proto.Unmarshal(msg.buf, userlist)
if err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
@ -1502,7 +1513,7 @@ func (server *Server) handleUserList(client *Client, msg *Message) {
})
}
if err := client.sendProtoMessage(userlist); err != nil {
client.Panic(err.String())
client.Panic(err)
return
}
// Rename, registration removal

31
murmurdb.go
View file

@ -10,6 +10,7 @@ package main
// SQLite datbase into a format that Grumble can understand.
import (
"errors"
"grumble/ban"
"grumble/blobstore"
"grumble/sqlite"
@ -37,15 +38,15 @@ const (
const SQLiteSupport = true
// Import the structure of an existing Murmur SQLite database.
func MurmurImport(filename string) (err os.Error) {
func MurmurImport(filename string) (err error) {
db, err := sqlite.Open(filename)
if err != nil {
panic(err.String())
panic(err.Error())
}
stmt, err := db.Prepare("SELECT server_id FROM servers")
if err != nil {
panic(err.String())
panic(err.Error())
}
var serverids []int64
@ -80,7 +81,7 @@ func MurmurImport(filename string) (err os.Error) {
}
// Create a new Server from a Murmur SQLite database
func NewServerFromSQLite(id int64, db *sqlite.Conn) (s *Server, err os.Error) {
func NewServerFromSQLite(id int64, db *sqlite.Conn) (s *Server, err error) {
s, err = NewServer(id, "", int(DefaultPort+id-1))
if err != nil {
return nil, err
@ -125,7 +126,7 @@ func NewServerFromSQLite(id int64, db *sqlite.Conn) (s *Server, err os.Error) {
}
// Add channel metadata (channel_info table from SQLite) by reading the SQLite database.
func populateChannelInfoFromDatabase(server *Server, c *Channel, db *sqlite.Conn) os.Error {
func populateChannelInfoFromDatabase(server *Server, c *Channel, db *sqlite.Conn) error {
stmt, err := db.Prepare("SELECT value FROM channel_info WHERE server_id=? AND channel_id=? AND key=?")
if err != nil {
return err
@ -172,7 +173,7 @@ func populateChannelInfoFromDatabase(server *Server, c *Channel, db *sqlite.Conn
}
// Populate channel with its ACLs by reading the SQLite databse.
func populateChannelACLFromDatabase(server *Server, c *Channel, db *sqlite.Conn) os.Error {
func populateChannelACLFromDatabase(server *Server, c *Channel, db *sqlite.Conn) error {
stmt, err := db.Prepare("SELECT user_id, group_name, apply_here, apply_sub, grantpriv, revokepriv FROM acl WHERE server_id=? AND channel_id=? ORDER BY priority")
if err != nil {
return err
@ -206,7 +207,7 @@ func populateChannelACLFromDatabase(server *Server, c *Channel, db *sqlite.Conn)
} else if len(Group) > 0 {
acl.Group = Group
} else {
return os.NewError("Invalid ACL: Neither Group or UserId specified")
return errors.New("Invalid ACL: Neither Group or UserId specified")
}
acl.Deny = Permission(Deny)
@ -218,7 +219,7 @@ func populateChannelACLFromDatabase(server *Server, c *Channel, db *sqlite.Conn)
}
// Populate channel with groups by reading the SQLite database.
func populateChannelGroupsFromDatabase(server *Server, c *Channel, db *sqlite.Conn) os.Error {
func populateChannelGroupsFromDatabase(server *Server, c *Channel, db *sqlite.Conn) error {
stmt, err := db.Prepare("SELECT group_id, name, inherit, inheritable FROM groups WHERE server_id=? AND channel_id=?")
if err != nil {
return err
@ -281,10 +282,10 @@ func populateChannelGroupsFromDatabase(server *Server, c *Channel, db *sqlite.Co
}
// Populate the Server with Channels from the database.
func populateChannelsFromDatabase(server *Server, db *sqlite.Conn, parentId int) os.Error {
func populateChannelsFromDatabase(server *Server, db *sqlite.Conn, parentId int) error {
parent, exists := server.Channels[parentId]
if !exists {
return os.NewError("Non-existant parent")
return errors.New("Non-existant parent")
}
stmt, err := db.Prepare("SELECT channel_id, name, inheritacl FROM channels WHERE server_id=? AND parent_id=?")
@ -350,7 +351,7 @@ func populateChannelsFromDatabase(server *Server, db *sqlite.Conn, parentId int)
}
// Link a Server's channels together
func populateChannelLinkInfo(server *Server, db *sqlite.Conn) (err os.Error) {
func populateChannelLinkInfo(server *Server, db *sqlite.Conn) (err error) {
stmt, err := db.Prepare("SELECT channel_id, link_id FROM channel_links WHERE server_id=?")
if err != nil {
return err
@ -371,12 +372,12 @@ func populateChannelLinkInfo(server *Server, db *sqlite.Conn) (err os.Error) {
channel, exists := server.Channels[ChannelId]
if !exists {
return os.NewError("Attempt to perform link operation on non-existant channel.")
return errors.New("Attempt to perform link operation on non-existant channel.")
}
other, exists := server.Channels[LinkId]
if !exists {
return os.NewError("Attempt to perform link operation on non-existant channel.")
return errors.New("Attempt to perform link operation on non-existant channel.")
}
server.LinkChannels(channel, other)
@ -385,7 +386,7 @@ func populateChannelLinkInfo(server *Server, db *sqlite.Conn) (err os.Error) {
return nil
}
func populateUsers(server *Server, db *sqlite.Conn) (err os.Error) {
func populateUsers(server *Server, db *sqlite.Conn) (err error) {
// Populate the server with regular user data
stmt, err := db.Prepare("SELECT user_id, name, pw, lastchannel, texture, strftime('%s', last_active) FROM users WHERE server_id=?")
if err != nil {
@ -488,7 +489,7 @@ func populateUsers(server *Server, db *sqlite.Conn) (err os.Error) {
}
// Populate bans
func populateBans(server *Server, db *sqlite.Conn) (err os.Error) {
func populateBans(server *Server, db *sqlite.Conn) (err error) {
stmt, err := db.Prepare("SELECT base, mask, name, hash, reason, start, duration FROM bans WHERE server_id=?")
if err != nil {
return

6
murmurdb_null.go
View file

@ -4,10 +4,10 @@
package main
import "os"
import "errors"
const SQLiteSupport = false
func MurmurImport(filename string) (err os.Error) {
return os.NewError("no sqlite support built in")
func MurmurImport(filename string) (err error) {
return errors.New("no sqlite support built in")
}

12
pkg/blobstore/blobreader.go
View file

@ -8,9 +8,9 @@ import (
"bytes"
"crypto/sha1"
"encoding/hex"
"errors"
"hash"
"io"
"os"
)
// blobReader is based on the principles of the checksumReader from the archive/zip
@ -18,7 +18,7 @@ import (
// ErrHashMismatch is returned if a blobReader has read a file whose computed hash
// did not match its key.
var ErrHashMismatch = os.NewError("hash mismatch")
var ErrHashMismatch = errors.New("hash mismatch")
// blobReader reads a blob from disk, hashing all incoming data. On EOF, it checks
// whether the read data matches the key.
@ -28,7 +28,7 @@ type blobReader struct {
hash hash.Hash
}
func newBlobReader(rc io.ReadCloser, key string) (br *blobReader, err os.Error) {
func newBlobReader(rc io.ReadCloser, key string) (br *blobReader, err error) {
sum, err := hex.DecodeString(key)
if err != nil {
return
@ -36,10 +36,10 @@ func newBlobReader(rc io.ReadCloser, key string) (br *blobReader, err os.Error)
return &blobReader{rc, sum, sha1.New()}, nil
}
func (r *blobReader) Read(b []byte) (n int, err os.Error) {
func (r *blobReader) Read(b []byte) (n int, err error) {
n, err = r.rc.Read(b)
r.hash.Write(b[:n])
if err != os.EOF {
if err != io.EOF {
return
}
if !bytes.Equal(r.sum, r.hash.Sum()) {
@ -48,6 +48,6 @@ func (r *blobReader) Read(b []byte) (n int, err os.Error) {
return
}
func (r *blobReader) Close() os.Error {
func (r *blobReader) Close() error {
return r.rc.Close()
}

44
pkg/blobstore/blobstore.go
View file

@ -9,6 +9,7 @@ package blobstore
import (
"crypto/sha1"
"encoding/hex"
"errors"
"io/ioutil"
"os"
"path/filepath"
@ -26,11 +27,11 @@ const (
)
var (
ErrLocked = os.NewError("lockfile acquired by another process")
ErrLockAcquirement = os.NewError("unable to acquire lockfile")
ErrBadFile = os.NewError("a bad file exists in the blobstore directory. unable to create container directores.")
ErrNoSuchKey = os.NewError("no such key")
ErrInvalidKey = os.NewError("invalid key")
ErrLocked = errors.New("lockfile acquired by another process")
ErrLockAcquirement = errors.New("unable to acquire lockfile")
ErrBadFile = errors.New("a bad file exists in the blobstore directory. unable to create container directores.")
ErrNoSuchKey = errors.New("no such key")
ErrInvalidKey = errors.New("invalid key")
)
var (
@ -41,7 +42,7 @@ var (
// Open an existing, or create a new BlobStore at path.
// Path must point to a directory, and must already exist.
// See NewBlobStore for more information.
func Open(path string, makeall bool) (err os.Error) {
func Open(path string, makeall bool) (err error) {
defaultMutex.Lock()
defer defaultMutex.Unlock()
@ -55,7 +56,7 @@ func Open(path string, makeall bool) (err os.Error) {
// Close the open default BlobStore. This removes the lockfile allowing
// other processes to open the BlobStore.
func Close() (err os.Error) {
func Close() (err error) {
if defaultStore == nil {
panic("DefaultStore not open")
}
@ -71,17 +72,16 @@ func Close() (err os.Error) {
// Lookup a blob by its key and return a buffer containing the contents
// of the blob.
func Get(key string) (buf []byte, err os.Error) {
func Get(key string) (buf []byte, err error) {
return defaultStore.Get(key)
}
// Store a blob. If the blob was successfully stored, the returned key
// can be used to retrieve the buf from the BlobStore.
func Put(buf []byte) (key string, err os.Error) {
func Put(buf []byte) (key string, err error) {
return defaultStore.Put(buf)
}
// Open an existing, or create a new BlobStore residing at path.
// Path must point to a directory, and must already exist.
//
@ -92,7 +92,7 @@ func Put(buf []byte) (key string, err os.Error) {
// some I/O operations when writing blobs. (Since the BlobStore
// knows that all directories will exist, it does not need to check
// whether they do, and create them if they do not.).
func NewBlobStore(path string, makeall bool) (bs *BlobStore, err os.Error) {
func NewBlobStore(path string, makeall bool) (bs *BlobStore, err error) {
// Does the directory exist?
dir, err := os.Open(path)
if err != nil {
@ -130,7 +130,7 @@ func NewBlobStore(path string, makeall bool) (bs *BlobStore, err os.Error) {
if !fi.IsDirectory() {
return nil, ErrBadFile
}
} else if e.Error == os.ENOTDIR {
} else if e.Err == os.ENOTDIR {
return nil, ErrBadFile
}
} else if err != nil {
@ -150,7 +150,7 @@ func NewBlobStore(path string, makeall bool) (bs *BlobStore, err os.Error) {
if !fi.IsDirectory() {
return nil, ErrBadFile
}
} else if e.Error == os.ENOTDIR {
} else if e.Err == os.ENOTDIR {
return nil, ErrBadFile
}
} else if err != nil {
@ -170,14 +170,14 @@ func NewBlobStore(path string, makeall bool) (bs *BlobStore, err os.Error) {
// Close an open BlobStore. This removes the lockfile allowing
// other processes to open the BlobStore.
func (bs *BlobStore) Close() (err os.Error) {
func (bs *BlobStore) Close() (err error) {
return os.Remove(bs.lockfn)
}
// Checks that a given key is a valid key for the BlobStore.
// If it is, it returns the three components that make up the on-disk path
// the given key can be found or should be stored at.
func getKeyComponents(key string) (dir1, dir2, fn string, err os.Error) {
func getKeyComponents(key string) (dir1, dir2, fn string, err error) {
// SHA1 digests are 40 bytes long when hex-encoded
if len(key) != 40 {
err = ErrInvalidKey
@ -195,7 +195,7 @@ func getKeyComponents(key string) (dir1, dir2, fn string, err os.Error) {
// Lookup the path hat a key would have on disk.
// Returns an error if the key is not a valid BlobStore key.
func (bs *BlobStore) pathForKey(key string) (fn string, err os.Error) {
func (bs *BlobStore) pathForKey(key string) (fn string, err error) {
dir1, dir2, rest, err := getKeyComponents(key)
if err != nil {
return
@ -207,14 +207,14 @@ func (bs *BlobStore) pathForKey(key string) (fn string, err os.Error) {
// Lookup a blob by its key and return a buffer containing the contents
// of the blob.
func (bs *BlobStore) Get(key string) (buf []byte, err os.Error) {
func (bs *BlobStore) Get(key string) (buf []byte, err error) {
fn, err := bs.pathForKey(key)
if err != nil {
return
}
file, err := os.Open(fn)
if e, ok := err.(*os.PathError); ok && (e.Error == os.ENOENT || e.Error == os.ENOTDIR) {
if e, ok := err.(*os.PathError); ok && (e.Err == os.ENOENT || e.Err == os.ENOTDIR) {
err = ErrNoSuchKey
return
} else if err != nil {
@ -238,7 +238,7 @@ func (bs *BlobStore) Get(key string) (buf []byte, err os.Error) {
// Store a blob. If the blob was successfully stored, the returned key
// can be used to retrieve the buf from the BlobStore.
func (bs *BlobStore) Put(buf []byte) (key string, err os.Error) {
func (bs *BlobStore) Put(buf []byte) (key string, err error) {
// Calculate the key for the blob. We can't really delay it more than this,
// since we need to know the key for the blob to check whether it's already on
// disk.
@ -263,7 +263,7 @@ func (bs *BlobStore) Put(buf []byte) (key string, err os.Error) {
file.Close()
return
} else {
if e, ok := err.(*os.PathError); ok && (e.Error == os.ENOENT || e.Error == os.ENOTDIR) {
if e, ok := err.(*os.PathError); ok && (e.Err == os.ENOENT || e.Err == os.ENOTDIR) {
// No such file exists on disk. Ready to rock!
} else {
return
@ -315,10 +315,10 @@ func (bs *BlobStore) Put(buf []byte) (key string, err os.Error) {
// On Unix, it checks for EEXIST. On Windows, it checks for EEXIST
// and Errno code 183 (ERROR_ALREADY_EXISTS)
func isExistError(err *os.PathError) (exists bool) {
if e, ok := err.Error.(os.Errno); ok && e == win32AlreadyExists {
if e, ok := err.Err.(os.Errno); ok && e == win32AlreadyExists {
exists = true
}
if err.Error == os.EEXIST {
if err.Err == os.EEXIST {
exists = true
}
return

56
pkg/blobstore/blobstore_test.go
View file

@ -17,14 +17,14 @@ import (
func TestMakeAllCreateAll(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
bs, err := NewBlobStore(dir, true)
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer bs.Close()
@ -35,7 +35,7 @@ func TestMakeAllCreateAll(t *testing.T) {
dirname := filepath.Join(dir, hex.EncodeToString([]byte{byte(i)}), hex.EncodeToString([]byte{byte(j)}))
fi, err := os.Stat(dirname)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
if !fi.IsDirectory() {
t.Errorf("Not a directory")
@ -47,65 +47,65 @@ func TestMakeAllCreateAll(t *testing.T) {
func TestAllInvalidFiles(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
err = ioutil.WriteFile(filepath.Join(dir, "00"), []byte{0x0f, 0x00}, 0600)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
_, err = NewBlobStore(dir, true)
if err == ErrBadFile {
// Success
} else if err != nil {
t.Errorf(err.String())
t.Error(err)
} else {
t.Errorf("NewBlobStore returned without error")
t.Error("NewBlobStore returned without error")
}
}
func TestAllInvalidFilesLevel2(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
err = os.Mkdir(filepath.Join(dir, "00"), 0700)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
err = ioutil.WriteFile(filepath.Join(dir, "00", "00"), []byte{0x0f, 0x00}, 0600)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
_, err = NewBlobStore(dir, true)
if err == ErrBadFile {
// Success
} else if err != nil {
t.Errorf(err.String())
t.Error(err)
} else {
t.Errorf("NewBlobStore returned without error")
t.Error("NewBlobStore returned without error")
}
}
func TestStoreRetrieve(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
bs, err := NewBlobStore(dir, false)
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer bs.Close()
@ -114,13 +114,13 @@ func TestStoreRetrieve(t *testing.T) {
key, err := bs.Put(data)
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
recv, err := bs.Get(key)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
if !bytes.Equal(recv, data) {
@ -131,14 +131,14 @@ func TestStoreRetrieve(t *testing.T) {
func TestReadNonExistantKey(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
bs, err := NewBlobStore(dir, false)
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer bs.Close()
@ -148,7 +148,7 @@ func TestReadNonExistantKey(t *testing.T) {
key := hex.EncodeToString(h.Sum())
buf, err := bs.Get(key)
if err != ErrNoSuchKey {
t.Errorf("Expected no such key %v, found it anyway. (buf=%v, err=%v)", key, buf, err)
t.Error("Expected no such key %v, found it anyway. (buf=%v, err=%v)", key, buf, err)
return
}
}
@ -156,13 +156,13 @@ func TestReadNonExistantKey(t *testing.T) {
func TestReadInvalidKeyLength(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
defer os.RemoveAll(dir)
bs, err := NewBlobStore(dir, false)
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer bs.Close()
@ -174,7 +174,7 @@ func TestReadInvalidKeyLength(t *testing.T) {
_, err = bs.Get(key)
if err != ErrInvalidKey {
t.Errorf("Expected invalid key for %v, got %v", key, err)
t.Error("Expected invalid key for %v, got %v", key, err)
return
}
}
@ -182,14 +182,14 @@ func TestReadInvalidKeyLength(t *testing.T) {
func TestReadInvalidKeyNonHex(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
bs, err := NewBlobStore(dir, false)
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer bs.Close()
@ -209,26 +209,26 @@ func TestReadInvalidKeyNonHex(t *testing.T) {
func TestDefaultBlobStore(t *testing.T) {
dir, err := ioutil.TempDir("", "blobstore")
if err != nil {
t.Errorf(err.String())
t.Error(err)
return
}
defer os.RemoveAll(dir)
err = Open(dir, false)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
data := []byte{0xf, 0x0, 0x0, 0xb, 0xa, 0xf}
key, err := Put(data)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
fetchedData, err := Get(key)
if err != nil {
t.Errorf(err.String())
t.Error(err)
}
if !bytes.Equal(fetchedData, data) {

8
pkg/blobstore/lock_unix.go
View file

@ -5,20 +5,20 @@
package blobstore
import (
"io/ioutil"
"os"
"path/filepath"
"io/ioutil"
"strconv"
"syscall"
)
// Acquire lockfile at path.
func AcquireLockFile(path string) os.Error {
func AcquireLockFile(path string) error {
dir, fn := filepath.Split(path)
lockfn := filepath.Join(dir, fn)
lockfile, err := os.OpenFile(lockfn, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
if e, ok := err.(*os.PathError); ok && e.Error == os.EEXIST {
if e, ok := err.(*os.PathError); ok && e.Err == os.EEXIST {
content, err := ioutil.ReadFile(lockfn)
if err != nil {
return err
@ -68,6 +68,6 @@ func AcquireLockFile(path string) os.Error {
}
// Release lockfile at path.
func ReleaseLockFile(path string) os.Error {
func ReleaseLockFile(path string) error {
return os.Remove(path)
}

9
pkg/blobstore/lock_windows.go
View file

@ -4,17 +4,14 @@
package blobstore
import (
"os"
"syscall"
)
import "syscall"
const (
FILE_FLAG_DELETE_ON_CLOSE = 0x04000000
)
// Acquire a lockfile at path.
func AcquireLockFile(path string) os.Error {
func AcquireLockFile(path string) error {
handle, _ := syscall.CreateFile(syscall.StringToUTF16Ptr(path), syscall.GENERIC_WRITE, 0, nil, syscall.CREATE_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, 0)
if handle < 0 {
return ErrLocked
@ -23,7 +20,7 @@ func AcquireLockFile(path string) os.Error {
}
// Release the lockfile at path.
func ReleaseLockFile(path string) os.Error {
func ReleaseLockFile(path string) error {
// No-op because we use FLAG_DELETE_ON_CLOSE.
return nil
}

48
pkg/cryptstate/cryptstate.go
View file

@ -8,7 +8,7 @@ package cryptstate
import (
"crypto/aes"
"crypto/rand"
"os"
"errors"
"time"
)
@ -34,13 +34,13 @@ type CryptState struct {
cipher *aes.Cipher
}
func New() (cs *CryptState, err os.Error) {
func New() (cs *CryptState, err error) {
cs = new(CryptState)
return
}
func (cs *CryptState) GenerateKey() (err os.Error) {
func (cs *CryptState) GenerateKey() (err error) {
rand.Read(cs.RawKey[0:])
rand.Read(cs.EncryptIV[0:])
rand.Read(cs.DecryptIV[0:])
@ -53,19 +53,19 @@ func (cs *CryptState) GenerateKey() (err os.Error) {
return
}
func (cs *CryptState) SetKey(key []byte, eiv []byte, div []byte) (err os.Error) {
func (cs *CryptState) SetKey(key []byte, eiv []byte, div []byte) (err error) {
if copy(cs.RawKey[0:], key[0:]) != aes.BlockSize {
err = os.NewError("Unable to copy key")
err = errors.New("Unable to copy key")
return
}
if copy(cs.EncryptIV[0:], eiv[0:]) != aes.BlockSize {
err = os.NewError("Unable to copy EIV")
err = errors.New("Unable to copy EIV")
return
}
if copy(cs.DecryptIV[0:], div[0:]) != aes.BlockSize {
err = os.NewError("Unable to copy DIV")
err = errors.New("Unable to copy DIV")
return
}
@ -77,15 +77,15 @@ func (cs *CryptState) SetKey(key []byte, eiv []byte, div []byte) (err os.Error)
return
}
func (cs *CryptState) Decrypt(dst, src []byte) (err os.Error) {
func (cs *CryptState) Decrypt(dst, src []byte) (err error) {
if len(src) < 4 {
err = os.NewError("Crypted length too short to decrypt")
err = errors.New("Crypted length too short to decrypt")
return
}
plain_len := len(src) - 4
if len(dst) != plain_len {
err = os.NewError("plain_len and src len mismatch")
err = errors.New("plain_len and src len mismatch")
return
}
@ -100,7 +100,7 @@ func (cs *CryptState) Decrypt(dst, src []byte) (err os.Error) {
restore = false
if copy(saveiv[0:], cs.DecryptIV[0:]) != aes.BlockSize {
err = os.NewError("Copy failed")
err = errors.New("Copy failed")
return
}
@ -117,7 +117,7 @@ func (cs *CryptState) Decrypt(dst, src []byte) (err os.Error) {
}
}
} else {
err = os.NewError("invalid ivbyte")
err = errors.New("invalid ivbyte")
}
} else {
// Out of order or repeat
@ -162,13 +162,13 @@ func (cs *CryptState) Decrypt(dst, src []byte) (err os.Error) {
}
}
} else {
err = os.NewError("No matching ivbyte")
err = errors.New("No matching ivbyte")
return
}
if cs.decryptHistory[cs.DecryptIV[0]] == cs.DecryptIV[0] {
if copy(cs.DecryptIV[0:], saveiv[0:]) != aes.BlockSize {
err = os.NewError("Failed to copy aes.BlockSize bytes")
err = errors.New("Failed to copy aes.BlockSize bytes")
return
}
}
@ -179,10 +179,10 @@ func (cs *CryptState) Decrypt(dst, src []byte) (err os.Error) {
for i := 0; i < 3; i++ {
if tag[i] != src[i+1] {
if copy(cs.DecryptIV[0:], saveiv[0:]) != aes.BlockSize {
err = os.NewError("Error while trying to recover from error")
err = errors.New("Error while trying to recover from error")
return
}
err = os.NewError("tag mismatch")
err = errors.New("tag mismatch")
return
}
}
@ -191,7 +191,7 @@ func (cs *CryptState) Decrypt(dst, src []byte) (err os.Error) {
if restore {
if copy(cs.DecryptIV[0:], saveiv[0:]) != aes.BlockSize {
err = os.NewError("Error while trying to recover IV")
err = errors.New("Error while trying to recover IV")
return
}
}
@ -262,7 +262,7 @@ func times3(block []byte) {
block[aes.BlockSize-1] ^= ((block[aes.BlockSize-1] << 1) ^ (carry * 135))
}
func (cs *CryptState) OCBEncrypt(dst []byte, src []byte, nonce []byte, tag []byte) (err os.Error) {
func (cs *CryptState) OCBEncrypt(dst []byte, src []byte, nonce []byte, tag []byte) (err error) {
var delta [aes.BlockSize]byte
var checksum [aes.BlockSize]byte
var tmp [aes.BlockSize]byte
@ -292,17 +292,17 @@ func (cs *CryptState) OCBEncrypt(dst []byte, src []byte, nonce []byte, tag []byt
cs.cipher.Encrypt(pad[0:], tmp[0:])
copied := copy(tmp[0:], src[off:])
if copied != remain {
err = os.NewError("Copy failed")
err = errors.New("Copy failed")
return
}
if copy(tmp[copied:], pad[copied:]) != (aes.BlockSize - remain) {
err = os.NewError("Copy failed")
err = errors.New("Copy failed")
return
}
xor(checksum[0:], checksum[0:], tmp[0:])
xor(tmp[0:], pad[0:], tmp[0:])
if copy(dst[off:], tmp[0:]) != remain {
err = os.NewError("Copy failed")
err = errors.New("Copy failed")
return
}
@ -313,7 +313,7 @@ func (cs *CryptState) OCBEncrypt(dst []byte, src []byte, nonce []byte, tag []byt
return
}
func (cs *CryptState) OCBDecrypt(plain []byte, encrypted []byte, nonce []byte, tag []byte) (err os.Error) {
func (cs *CryptState) OCBDecrypt(plain []byte, encrypted []byte, nonce []byte, tag []byte) (err error) {
var checksum [aes.BlockSize]byte
var delta [aes.BlockSize]byte
var tmp [aes.BlockSize]byte
@ -344,14 +344,14 @@ func (cs *CryptState) OCBDecrypt(plain []byte, encrypted []byte, nonce []byte, t
zeros(tmp[0:])
copied := copy(tmp[0:remain], encrypted[off:off+remain])
if copied != remain {
err = os.NewError("Copy failed")
err = errors.New("Copy failed")
return
}
xor(tmp[0:], tmp[0:], pad[0:])
xor(checksum[0:], checksum[0:], tmp[0:])
copied = copy(plain[off:off+remain], tmp[0:remain])
if copied != remain {
err = os.NewError("Copy failed")
err = errors.New("Copy failed")
return
}

14
pkg/freezer/error.go
View file

@ -4,18 +4,18 @@
package freezer
import "os"
import "errors"
// Writer errors
var (
ErrTxGroupFull = os.NewError("transction group is full")
ErrTxGroupValueTooBig = os.NewError("value too big to put inside the txgroup")
ErrTxGroupFull = errors.New("transction group is full")
ErrTxGroupValueTooBig = errors.New("value too big to put inside the txgroup")
)
// Walker errors
var (
ErrUnexpectedEndOfRecord = os.NewError("unexpected end of record")
ErrCRC32Mismatch = os.NewError("CRC32 mismatch")
ErrRemainingBytesForRecord = os.NewError("remaining bytes in record")
ErrRecordTooBig = os.NewError("the record in the file is too big")
ErrUnexpectedEndOfRecord = errors.New("unexpected end of record")
ErrCRC32Mismatch = errors.New("CRC32 mismatch")
ErrRemainingBytesForRecord = errors.New("remaining bytes in record")
ErrRecordTooBig = errors.New("the record in the file is too big")
)

12
pkg/freezer/freezer_test.go
View file

@ -25,7 +25,7 @@ var testValues []interface{} = []interface{} {
}
// Generate a byet slice representing an entry in a Tx record
func genTxValue(kind uint16, val []byte) (chunk []byte, crc32sum uint32, err os.Error) {
func genTxValue(kind uint16, val []byte) (chunk []byte, crc32sum uint32, err error) {
buf := new(bytes.Buffer)
err = binary.Write(buf, binary.LittleEndian, kind)
@ -53,7 +53,7 @@ func genTxValue(kind uint16, val []byte) (chunk []byte, crc32sum uint32, err os.
}
// Generate the header of a Tx record
func genTestCaseHeader(chunk []byte, numops uint32, crc32sum uint32) (r io.Reader, err os.Error) {
func genTestCaseHeader(chunk []byte, numops uint32, crc32sum uint32) (r io.Reader, err error) {
buf := new(bytes.Buffer)
err = binary.Write(buf, binary.LittleEndian, uint32(4+4+len(chunk)))
@ -117,7 +117,7 @@ func TestLogging(t *testing.T) {
i := 0
for {
entries, err := walker.Next()
if err == os.EOF {
if err == io.EOF {
break
} else if err != nil {
t.Error(err)
@ -157,7 +157,7 @@ func TestCRC32MismatchLog(t *testing.T) {
t.Errorf("exepcted CRC32 mismatch, got %v", err)
}
_, err = walker.Next()
if err != os.EOF {
if err != io.EOF {
t.Errorf("expected EOF, got %v", err)
}
}
@ -187,7 +187,7 @@ func TestUnknownTypeDecode(t *testing.T) {
t.Errorf("expected empty entries and non-nil err (got %v entries and %v)", len(entries), err)
}
_, err = walker.Next()
if err != os.EOF {
if err != io.EOF {
t.Errorf("expected EOF, got %v", err)
}
}
@ -223,7 +223,7 @@ func TestTrailingBytesTxRecord(t *testing.T) {
}
_, err = walker.Next()
if err != os.EOF {
if err != io.EOF {
t.Errorf("expected EOF, got %v", err)
}
}

16
pkg/freezer/walker.go
View file

@ -16,8 +16,8 @@ import (
// Checks whether the error err is an EOF
// error.
func isEOF(err os.Error) bool {
if err == os.EOF || err == io.ErrUnexpectedEOF {
func isEOF(err error) bool {
if err == io.EOF || err == io.ErrUnexpectedEOF {
return true
}
return false
@ -52,9 +52,9 @@ func newTxReader(r io.Reader) *txReader {
// walkReader's Read method. Reads from walkReader's Reader
// and checksums while reading.
func (txr *txReader) Read(p []byte) (n int, err os.Error) {
func (txr *txReader) Read(p []byte) (n int, err error) {
n, err = txr.r.Read(p)
if err != nil && err != os.EOF {
if err != nil && err != io.EOF {
return
}
txr.consumed += n
@ -80,7 +80,7 @@ func (txr *txReader) Consumed() int {
}
// Create a new Walker that iterates over the entries of the given log file.
func NewFileWalker(fn string) (walker *Walker, err os.Error) {
func NewFileWalker(fn string) (walker *Walker, err error) {
f, err := os.Open(fn)
if err != nil {
return nil, err
@ -93,7 +93,7 @@ func NewFileWalker(fn string) (walker *Walker, err os.Error) {
}
// Create a new Walker that iterates over the log entries of a given Reader.
func NewReaderWalker(r io.Reader) (walker *Walker, err os.Error) {
func NewReaderWalker(r io.Reader) (walker *Walker, err error) {
walker = new(Walker)
walker.r = r
return walker, nil
@ -108,7 +108,7 @@ func NewReaderWalker(r io.Reader) (walker *Walker, err os.Error) {
//
// On error, Next returns a nil slice and a non-nil err.
// When the end of the file is reached, Next returns nil, os.EOF.
func (walker *Walker) Next() (entries []interface{}, err os.Error) {
func (walker *Walker) Next() (entries []interface{}, err error) {
var (
remainBytes uint32
remainOps uint32
@ -119,7 +119,7 @@ func (walker *Walker) Next() (entries []interface{}, err os.Error) {
err = binary.Read(walker.r, binary.LittleEndian, &remainBytes)
if isEOF(err) {
return nil, os.EOF
return nil, io.EOF
} else if err != nil {
return nil, err
}

12
pkg/freezer/writer.go
View file

@ -51,7 +51,7 @@ type LogTx struct {
}
// Create a new log file
func NewLogFile(fn string) (*Log, os.Error) {
func NewLogFile(fn string) (*Log, error) {
f, err := os.Create(fn)
if err != nil {
return nil, err
@ -64,7 +64,7 @@ func NewLogFile(fn string) (*Log, os.Error) {
}
// Close a Log
func (log *Log) Close() os.Error {
func (log *Log) Close() error {
return log.wc.Close()
}
@ -73,7 +73,7 @@ func (log *Log) Close() os.Error {
// This method implicitly creates a transaction
// group for this single Put operation. It is merely
// a convenience wrapper.
func (log *Log) Put(value interface{}) (err os.Error) {
func (log *Log) Put(value interface{}) (err error) {
tx := log.BeginTx()
err = tx.Put(value)
if err != nil {
@ -94,7 +94,7 @@ func (log *Log) BeginTx() *LogTx {
// Append a log entry to the transaction.
// The transaction's log entries will not be persisted to
// the log until the Commit has been called on the transaction.
func (tx *LogTx) Put(value interface{}) (err os.Error) {
func (tx *LogTx) Put(value interface{}) (err error) {
var (
buf []byte
kind typeKind
@ -155,14 +155,14 @@ func (tx *LogTx) Put(value interface{}) (err os.Error) {
return err
}
tx.numops += 1;
tx.numops += 1
return nil
}
// Commit all changes of the transaction to the log
// as a single atomic entry.
func (tx *LogTx) Commit() (err os.Error) {
func (tx *LogTx) Commit() (err error) {
buf := new(bytes.Buffer)
err = binary.Write(buf, binary.LittleEndian, uint32(4+4+tx.buf.Len()))

13
pkg/htmlfilter/htmlfilter.go
View file

@ -6,7 +6,8 @@ package htmlfilter
import (
"bytes"
"os"
"errors"
"io"
"strings"
"xml"
)
@ -24,12 +25,12 @@ var defaultOptions Options = Options{
}
var (
ErrExceedsTextMessageLength = os.NewError("Exceeds text message length")
ErrExceedsImageMessageLength = os.NewError("Exceeds image message length")
ErrExceedsTextMessageLength = errors.New("Exceeds text message length")
ErrExceedsImageMessageLength = errors.New("Exceeds image message length")
)
// Filter text according to options.
func Filter(text string, options *Options) (filtered string, err os.Error) {
func Filter(text string, options *Options) (filtered string, err error) {
// This function filters incoming text from clients according to the three options:
//
// StripHTML:
@ -64,7 +65,7 @@ func Filter(text string, options *Options) (filtered string, err os.Error) {
parser.Entity = xml.HTMLEntity
for {
tok, err := parser.Token()
if err == os.EOF {
if err == io.EOF {
break
} else if err != nil {
return "", err
@ -117,7 +118,7 @@ func Filter(text string, options *Options) (filtered string, err os.Error) {
parser.Entity = xml.HTMLEntity
for {
tok, err := parser.Token()
if err == os.EOF {
if err == io.EOF {
break
} else if err != nil {
return "", err

2
pkg/serverconf/config.go
View file

@ -59,7 +59,7 @@ func (cfg *Config) Set(key string, value string) {
func (cfg *Config) Reset(key string) {
cfg.mutex.Lock()
defer cfg.mutex.Unlock()
cfg.cfgMap[key] = "", false
delete(cfg.cfgMap, key)
}
// Get the value of a specific config key encoded as a string

2
pkg/sessionpool/sessionpool.go
View file

@ -86,7 +86,7 @@ func (pool *SessionPool) Reclaim(id uint32) {
if !inUse {
panic("Attempt to reclaim invalid session ID")
}
pool.used[id] = false, false
delete(pool.used, id)
}
pool.unused = append(pool.unused, id)

117
pkg/sqlite/sqlite.go
View file

@ -28,17 +28,18 @@ static int my_bind_blob(sqlite3_stmt *stmt, int n, void *p, int np) {
import "C"
import (
"errors"
"fmt"
"os"
"reflect"
"strconv"
"unsafe"
"time"
"unsafe"
)
type Errno int
func (e Errno) String() string {
func (e Errno) Error() string {
s := errText[e]
if s == "" {
return fmt.Sprintf("errno %d", int(e))
@ -47,30 +48,30 @@ func (e Errno) String() string {
}
var (
ErrError os.Error = Errno(1) // /* SQL error or missing database */
ErrInternal os.Error = Errno(2) // /* Internal logic error in SQLite */
ErrPerm os.Error = Errno(3) // /* Access permission denied */
ErrAbort os.Error = Errno(4) // /* Callback routine requested an abort */
ErrBusy os.Error = Errno(5) // /* The database file is locked */
ErrLocked os.Error = Errno(6) // /* A table in the database is locked */
ErrNoMem os.Error = Errno(7) // /* A malloc() failed */
ErrReadOnly os.Error = Errno(8) // /* Attempt to write a readonly database */
ErrInterrupt os.Error = Errno(9) // /* Operation terminated by sqlite3_interrupt()*/
ErrIOErr os.Error = Errno(10) // /* Some kind of disk I/O error occurred */
ErrCorrupt os.Error = Errno(11) // /* The database disk image is malformed */
ErrFull os.Error = Errno(13) // /* Insertion failed because database is full */
ErrCantOpen os.Error = Errno(14) // /* Unable to open the database file */
ErrEmpty os.Error = Errno(16) // /* Database is empty */
ErrSchema os.Error = Errno(17) // /* The database schema changed */
ErrTooBig os.Error = Errno(18) // /* String or BLOB exceeds size limit */
ErrConstraint os.Error = Errno(19) // /* Abort due to constraint violation */
ErrMismatch os.Error = Errno(20) // /* Data type mismatch */
ErrMisuse os.Error = Errno(21) // /* Library used incorrectly */
ErrNolfs os.Error = Errno(22) // /* Uses OS features not supported on host */
ErrAuth os.Error = Errno(23) // /* Authorization denied */
ErrFormat os.Error = Errno(24) // /* Auxiliary database format error */
ErrRange os.Error = Errno(25) // /* 2nd parameter to sqlite3_bind out of range */
ErrNotDB os.Error = Errno(26) // /* File opened that is not a database file */
ErrError error = Errno(1) // /* SQL error or missing database */
ErrInternal error = Errno(2) // /* Internal logic error in SQLite */
ErrPerm error = Errno(3) // /* Access permission denied */
ErrAbort error = Errno(4) // /* Callback routine requested an abort */
ErrBusy error = Errno(5) // /* The database file is locked */
ErrLocked error = Errno(6) // /* A table in the database is locked */
ErrNoMem error = Errno(7) // /* A malloc() failed */
ErrReadOnly error = Errno(8) // /* Attempt to write a readonly database */
ErrInterrupt error = Errno(9) // /* Operation terminated by sqlite3_interrupt()*/
ErrIOErr error = Errno(10) // /* Some kind of disk I/O error occurred */
ErrCorrupt error = Errno(11) // /* The database disk image is malformed */
ErrFull error = Errno(13) // /* Insertion failed because database is full */
ErrCantOpen error = Errno(14) // /* Unable to open the database file */
ErrEmpty error = Errno(16) // /* Database is empty */
ErrSchema error = Errno(17) // /* The database schema changed */
ErrTooBig error = Errno(18) // /* String or BLOB exceeds size limit */
ErrConstraint error = Errno(19) // /* Abort due to constraint violation */
ErrMismatch error = Errno(20) // /* Data type mismatch */
ErrMisuse error = Errno(21) // /* Library used incorrectly */
ErrNolfs error = Errno(22) // /* Uses OS features not supported on host */
ErrAuth error = Errno(23) // /* Authorization denied */
ErrFormat error = Errno(24) // /* Auxiliary database format error */
ErrRange error = Errno(25) // /* 2nd parameter to sqlite3_bind out of range */
ErrNotDB error = Errno(26) // /* File opened that is not a database file */
Row = Errno(100) // /* sqlite3_step() has another row ready */
Done = Errno(101) // /* sqlite3_step() has finished executing */
)
@ -106,9 +107,9 @@ var errText = map[Errno]string {
101: "sqlite3_step() has finished executing",
}
func (c *Conn) error(rv C.int) os.Error {
func (c *Conn) error(rv C.int) error {
if c == nil || c.db == nil {
return os.NewError("nil sqlite database")
return errors.New("nil sqlite database")
}
if rv == 0 {
return nil
@ -116,7 +117,7 @@ func (c *Conn) error(rv C.int) os.Error {
if rv == 21 { // misuse
return Errno(rv)
}
return os.NewError(Errno(rv).String() + ": " + C.GoString(C.sqlite3_errmsg(c.db)))
return errors.New(Errno(rv).Error() + ": " + C.GoString(C.sqlite3_errmsg(c.db)))
}
type Conn struct {
@ -124,13 +125,13 @@ type Conn struct {
}
func Version() string {
p := C.sqlite3_libversion();
return C.GoString(p);
p := C.sqlite3_libversion()
return C.GoString(p)
}
func Open(filename string) (*Conn, os.Error) {
func Open(filename string) (*Conn, error) {
if C.sqlite3_threadsafe() == 0 {
return nil, os.NewError("sqlite library was not compiled for thread-safe operation")
return nil, errors.New("sqlite library was not compiled for thread-safe operation")
}
var db *C.sqlite3
@ -145,12 +146,12 @@ func Open(filename string) (*Conn, os.Error) {
return nil, Errno(rv)
}
if db == nil {
return nil, os.NewError("sqlite succeeded without returning a database")
return nil, errors.New("sqlite succeeded without returning a database")
}
return &Conn{db}, nil
}
func NewBackup(dst *Conn, dstTable string, src *Conn, srcTable string) (*Backup, os.Error) {
func NewBackup(dst *Conn, dstTable string, src *Conn, srcTable string) (*Backup, error) {
dname := C.CString(dstTable)
sname := C.CString(srcTable)
defer C.free(unsafe.Pointer(dname))
@ -168,7 +169,7 @@ type Backup struct {
dst, src *Conn
}
func (b *Backup) Step(npage int) os.Error {
func (b *Backup) Step(npage int) error {
rv := C.sqlite3_backup_step(b.sb, C.int(npage))
if rv == 0 || Errno(rv) == ErrBusy || Errno(rv) == ErrLocked {
return nil
@ -185,8 +186,8 @@ func (b *Backup) Status() BackupStatus {
return BackupStatus{int(C.sqlite3_backup_remaining(b.sb)), int(C.sqlite3_backup_pagecount(b.sb))}
}
func (b *Backup) Run(npage int, sleepNs int64, c chan<- BackupStatus) os.Error {
var err os.Error
func (b *Backup) Run(npage int, sleepNs int64, c chan<- BackupStatus) error {
var err error
for {
err = b.Step(npage)
if err != nil {
@ -200,7 +201,7 @@ func (b *Backup) Run(npage int, sleepNs int64, c chan<- BackupStatus) os.Error {
return b.dst.error(C.sqlite3_errcode(b.dst.db))
}
func (b *Backup) Close() os.Error {
func (b *Backup) Close() error {
if b.sb == nil {
return os.EINVAL
}
@ -209,7 +210,7 @@ func (b *Backup) Close() os.Error {
return nil
}
func (c *Conn) BusyTimeout(ms int) os.Error {
func (c *Conn) BusyTimeout(ms int) error {
rv := C.sqlite3_busy_timeout(c.db, C.int(ms))
if rv == 0 {
return nil
@ -217,7 +218,7 @@ func (c *Conn) BusyTimeout(ms int) os.Error {
return Errno(rv)
}
func (c *Conn) Exec(cmd string, args ...interface{}) os.Error {
func (c *Conn) Exec(cmd string, args ...interface{}) error {
s, err := c.Prepare(cmd)
if err != nil {
return err
@ -237,15 +238,15 @@ func (c *Conn) Exec(cmd string, args ...interface{}) os.Error {
type Stmt struct {
c *Conn
stmt *C.sqlite3_stmt
err os.Error
err error
t0 int64
sql string
args string
}
func (c *Conn) Prepare(cmd string) (*Stmt, os.Error) {
func (c *Conn) Prepare(cmd string) (*Stmt, error) {
if c == nil || c.db == nil {
return nil, os.NewError("nil sqlite database")
return nil, errors.New("nil sqlite database")
}
cmdstr := C.CString(cmd)
defer C.free(unsafe.Pointer(cmdstr))
@ -258,7 +259,7 @@ func (c *Conn) Prepare(cmd string) (*Stmt, os.Error) {
return &Stmt{c: c, stmt: stmt, sql: cmd, t0: time.Nanoseconds()}, nil
}
func (s *Stmt) Exec(args ...interface{}) os.Error {
func (s *Stmt) Exec(args ...interface{}) error {
s.args = fmt.Sprintf(" %v", []interface{}(args))
rv := C.sqlite3_reset(s.stmt)
if rv != 0 {
@ -267,7 +268,7 @@ func (s *Stmt) Exec(args ...interface{}) os.Error {
n := int(C.sqlite3_bind_parameter_count(s.stmt))
if n != len(args) {
return os.NewError(fmt.Sprintf("incorrect argument count for Stmt.Exec: have %d want %d", len(args), n))
return errors.New(fmt.Sprintf("incorrect argument count for Stmt.Exec: have %d want %d", len(args), n))
}
for i, v := range args {
@ -304,7 +305,7 @@ func (s *Stmt) Exec(args ...interface{}) os.Error {
return nil
}
func (s *Stmt) Error() os.Error {
func (s *Stmt) Error() error {
return s.err
}
@ -320,22 +321,22 @@ func (s *Stmt) Next() bool {
return false
}
func (s *Stmt) Reset() os.Error {
func (s *Stmt) Reset() error {
C.sqlite3_reset(s.stmt)
return nil
}
func (s *Stmt) Scan(args ...interface{}) os.Error {
func (s *Stmt) Scan(args ...interface{}) error {
n := int(C.sqlite3_column_count(s.stmt))
if n != len(args) {
return os.NewError(fmt.Sprintf("incorrect argument count for Stmt.Scan: have %d want %d", len(args), n))
return errors.New(fmt.Sprintf("incorrect argument count for Stmt.Scan: have %d want %d", len(args), n))
}
for i, v := range args {
n := C.sqlite3_column_bytes(s.stmt, C.int(i))
p := C.sqlite3_column_blob(s.stmt, C.int(i))
if p == nil && n > 0 {
return os.NewError("got nil blob")
return errors.New("got nil blob")
}
var data []byte
if n > 0 {
@ -351,23 +352,23 @@ func (s *Stmt) Scan(args ...interface{}) os.Error {
case *int:
x, err := strconv.Atoi(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int: " + err.String())
return errors.New("arg " + strconv.Itoa(i) + " as int: " + err.Error())
}
*v = x
case *int64:
x, err := strconv.Atoi64(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as int64: " + err.String())
return errors.New("arg " + strconv.Itoa(i) + " as int64: " + err.Error())
}
*v = x
case *float64:
x, err := strconv.Atof64(string(data))
if err != nil {
return os.NewError("arg " + strconv.Itoa(i) + " as float64: " + err.String())
return errors.New("arg " + strconv.Itoa(i) + " as float64: " + err.Error())
}
*v = x
default:
return os.NewError("unsupported type in Scan: " + reflect.TypeOf(v).String())
return errors.New("unsupported type in Scan: " + reflect.TypeOf(v).String())
}
}
return nil
@ -381,7 +382,7 @@ func (s *Stmt) Nanoseconds() int64 {
return time.Nanoseconds() - s.t0
}
func (s *Stmt) Finalize() os.Error {
func (s *Stmt) Finalize() error {
rv := C.sqlite3_finalize(s.stmt)
if rv != 0 {
return s.c.error(rv)
@ -389,9 +390,9 @@ func (s *Stmt) Finalize() os.Error {
return nil
}
func (c *Conn) Close() os.Error {
func (c *Conn) Close() error {
if c == nil || c.db == nil {
return os.NewError("nil sqlite database")
return errors.New("nil sqlite database")
}
rv := C.sqlite3_close(c.db)
if rv != 0 {

60
register.go
View file

@ -13,9 +13,6 @@ import (
"encoding/hex"
"http"
"io/ioutil"
"net"
"os"
"url"
"xml"
)
@ -47,26 +44,6 @@ const (
registerUrl = "https://mumble.hive.no/register.cgi"
)
// Create a persistent HTTP ClientConn to server at addr with TLS configuration cfg.
func newTLSClientAuthConn(addr string, cfg *tls.Config) (c *http.ClientConn, err os.Error) {
tcpaddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
tcpconn, err := net.DialTCP("tcp", nil, tcpaddr)
if err != nil {
return nil, err
}
tlsconn := tls.Client(tcpconn, cfg)
if err != nil {
return nil, err
}
return http.NewClientConn(tlsconn, nil), nil
}
// Determines whether a server is public by checking whether the
// config values required for public registration are set.
//
@ -135,41 +112,16 @@ func (server *Server) RegisterPublicServer() {
// Post registration XML data to server asynchronously in its own goroutine
go func() {
// Go's http package does not allow HTTP clients to set their own
// certificate chain, so we use our own wrapper instead.
hc, err := newTLSClientAuthConn(registerAddr, config)
tr := &http.Transport{
TLSClientConfig: config,
DisableCompression: true,
}
client := &http.Client{Transport: tr}
r, err := client.Post(registerUrl, "text/xml", ioutil.NopCloser(buf))
if err != nil {
server.Printf("register: unable to create https client: %v", err)
return
}
defer hc.Close()
// The master registration server requires
// that a Content-Length be specified in incoming HTTP requests.
// Make sure we don't send a chunked request by hand-crafting it.
var req http.Request
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Body = ioutil.NopCloser(buf)
req.ContentLength = int64(buf.Len())
req.Header = http.Header{
"Content-Type": {"text/xml"},
}
req.URL, err = url.Parse(registerUrl)
if err != nil {
server.Printf("register: error parsing url: %v", err)
return
}
r, err := hc.Do(&req)
if err != nil && err != http.ErrPersistEOF {
server.Printf("register: unable to post registration request: %v", err)
return
}
bodyBytes, err := ioutil.ReadAll(r.Body)
if err == nil {
registerMsg := string(bodyBytes)

65
server.go
View file

@ -12,6 +12,7 @@ import (
"crypto/tls"
"encoding/binary"
"encoding/hex"
"errors"
"fmt"
"goprotobuf.googlecode.com/hg/proto"
"grumble/ban"
@ -115,7 +116,7 @@ type clientLogForwarder struct {
logger *log.Logger
}
func (lf clientLogForwarder) Write(incoming []byte) (int, os.Error) {
func (lf clientLogForwarder) Write(incoming []byte) (int, error) {
buf := bytes.NewBuffer(nil)
buf.WriteString(fmt.Sprintf("<%v:%v(%v)> ", lf.client.Session, lf.client.ShownName(), lf.client.UserId()))
buf.Write(incoming)
@ -124,7 +125,7 @@ func (lf clientLogForwarder) Write(incoming []byte) (int, os.Error) {
}
// Allocate a new Murmur instance
func NewServer(id int64, addr string, port int) (s *Server, err os.Error) {
func NewServer(id int64, addr string, port int) (s *Server, err error) {
s = new(Server)
s.Id = id
@ -236,11 +237,11 @@ func (server *Server) CheckSuperUserPassword(password string) bool {
}
// Called by the server to initiate a new client connection.
func (server *Server) NewClient(conn net.Conn) (err os.Error) {
func (server *Server) NewClient(conn net.Conn) (err error) {
client := new(Client)
addr := conn.RemoteAddr()
if addr == nil {
err = os.NewError("Unable to extract address for client.")
err = errors.New("Unable to extract address for client.")
return
}
@ -285,11 +286,11 @@ func (server *Server) RemoveClient(client *Client, kicked bool) {
}
server.hclients[host] = newclients
if client.udpaddr != nil {
server.hpclients[client.udpaddr.String()] = nil, false
delete(server.hpclients, client.udpaddr.String())
}
server.hmutex.Unlock()
server.clients[client.Session] = nil, false
delete(server.clients, client.Session)
server.pool.Reclaim(client.Session)
// Remove client from channel
@ -327,7 +328,7 @@ func (server *Server) RemoveChanel(channel *Channel) {
return
}
server.Channels[channel.Id] = nil, false
delete(server.Channels, channel.Id)
}
// Link two channels
@ -338,8 +339,8 @@ func (server *Server) LinkChannels(channel *Channel, other *Channel) {
// Unlink two channels
func (server *Server) UnlinkChannels(channel *Channel, other *Channel) {
channel.Links[other.Id] = nil, false
other.Links[channel.Id] = nil, false
delete(channel.Links, other.Id)
delete(other.Links, channel.Id)
}
// This is the synchronous handler goroutine.
@ -580,7 +581,7 @@ func (server *Server) finishAuthenticate(client *Client) {
} else {
buf, err := blobstore.Get(client.user.TextureBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err.Error())
}
userstate.Texture = buf
}
@ -593,7 +594,7 @@ func (server *Server) finishAuthenticate(client *Client) {
} else {
buf, err := blobstore.Get(client.user.CommentBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err.Error())
}
userstate.Comment = proto.String(string(buf))
}
@ -729,7 +730,7 @@ func (server *Server) sendUserList(client *Client) {
} else {
buf, err := blobstore.Get(connectedClient.user.TextureBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err.Error())
}
userstate.Texture = buf
}
@ -742,7 +743,7 @@ func (server *Server) sendUserList(client *Client) {
} else {
buf, err := blobstore.Get(connectedClient.user.CommentBlob)
if err != nil {
server.Panicf("Blobstore error: %v", err.String())
server.Panicf("Blobstore error: %v", err.Error())
}
userstate.Comment = proto.String(string(buf))
}
@ -802,7 +803,7 @@ func (server *Server) sendClientPermissions(client *Client, channel *Channel) {
type ClientPredicate func(client *Client) bool
func (server *Server) broadcastProtoMessageWithPredicate(msg interface{}, clientcheck ClientPredicate) (err os.Error) {
func (server *Server) broadcastProtoMessageWithPredicate(msg interface{}, clientcheck ClientPredicate) error {
for _, client := range server.clients {
if !clientcheck(client) {
continue
@ -812,14 +813,14 @@ func (server *Server) broadcastProtoMessageWithPredicate(msg interface{}, client
}
err := client.sendProtoMessage(msg)
if err != nil {
return
return err
}
}
return
return nil
}
func (server *Server) broadcastProtoMessage(msg interface{}) (err os.Error) {
func (server *Server) broadcastProtoMessage(msg interface{}) (err error) {
err = server.broadcastProtoMessageWithPredicate(msg, func(client *Client) bool { return true })
return
}
@ -863,7 +864,7 @@ func (server *Server) handleIncomingMessage(client *Client, msg *Message) {
}
}
func (s *Server) SetupUDP() (err os.Error) {
func (s *Server) SetupUDP() (err error) {
addr := &net.UDPAddr{
net.ParseIP(s.address),
s.port,
@ -1016,7 +1017,7 @@ func (server *Server) userEnterChannel(client *Client, channel *Channel, usersta
}
// Register a client on the server.
func (s *Server) RegisterClient(client *Client) (uid uint32, err os.Error) {
func (s *Server) RegisterClient(client *Client) (uid uint32, err error) {
// Increment nextUserId only if registration succeeded.
defer func() {
if err == nil {
@ -1031,7 +1032,7 @@ func (s *Server) RegisterClient(client *Client) (uid uint32, err os.Error) {
// Grumble can only register users with certificates.
if len(client.CertHash) == 0 {
return 0, os.NewError("no cert hash")
return 0, errors.New("no cert hash")
}
user.Email = client.Email
@ -1046,16 +1047,16 @@ func (s *Server) RegisterClient(client *Client) (uid uint32, err os.Error) {
}
// Remove a registered user.
func (s *Server) RemoveRegistration(uid uint32) (err os.Error) {
func (s *Server) RemoveRegistration(uid uint32) (err error) {
user, ok := s.Users[uid]
if !ok {
return os.NewError("Unknown user ID")
return errors.New("Unknown user ID")
}
// Remove from user maps
s.Users[uid] = nil, false
s.UserCertMap[user.CertHash] = nil, false
s.UserNameMap[user.Name] = nil, false
delete(s.Users, uid)
delete(s.UserCertMap, user.CertHash)
delete(s.UserNameMap, user.Name)
// Remove from groups and ACLs.
s.removeRegisteredUserFromChannel(uid, s.RootChannel())
@ -1077,13 +1078,13 @@ func (s *Server) removeRegisteredUserFromChannel(uid uint32, channel *Channel) {
for _, grp := range channel.Groups {
if _, ok := grp.Add[int(uid)]; ok {
grp.Add[int(uid)] = false, false
delete(grp.Add, int(uid))
}
if _, ok := grp.Remove[int(uid)]; ok {
grp.Remove[int(uid)] = false, false
delete(grp.Remove, int(uid))
}
if _, ok := grp.Temporary[int(uid)]; ok {
grp.Temporary[int(uid)] = false, false
delete(grp.Temporary, int(uid))
}
}
@ -1101,7 +1102,7 @@ func (server *Server) RemoveChannel(channel *Channel) {
// Remove all links
for _, linkedChannel := range channel.Links {
linkedChannel.Links[channel.Id] = nil, false
delete(linkedChannel.Links, channel.Id)
}
// Remove all subchannels
@ -1127,8 +1128,8 @@ func (server *Server) RemoveChannel(channel *Channel) {
// Remove the channel itself
parent := channel.parent
parent.children[channel.Id] = nil, false
server.Channels[channel.Id] = nil, false
delete(parent.children, channel.Id)
delete(server.Channels, channel.Id)
chanremove := &mumbleproto.ChannelRemove{
ChannelId: proto.Uint32(uint32(channel.Id)),
}
@ -1153,7 +1154,7 @@ func (server *Server) IsBanned(conn net.Conn) bool {
}
// Filter incoming text according to the server's current rules.
func (server *Server) FilterText(text string) (filtered string, err os.Error) {
func (server *Server) FilterText(text string) (filtered string, err error) {
options := &htmlfilter.Options{
StripHTML: !server.cfg.BoolValue("AllowHTML"),
MaxTextMessageLength: server.cfg.IntValue("MaxTextMessageLength"),

8
user.go
View file

@ -6,7 +6,7 @@ package main
import (
"encoding/hex"
"os"
"errors"
)
// This file implements Server's handling of Users.
@ -26,12 +26,12 @@ type User struct {
}
// Create a new User
func NewUser(id uint32, name string) (user *User, err os.Error) {
func NewUser(id uint32, name string) (user *User, err error) {
if id < 0 {
return nil, os.NewError("Invalid user id")
return nil, errors.New("Invalid user id")
}
if len(name) == 0 {
return nil, os.NewError("Invalid username")
return nil, errors.New("Invalid username")
}
return &User{