Squashed a race condition/deadlock buried in client.go

client.go

 type Client struct {
 	conn             net.Conn
 	connectionID     int
+	connected        bool
 	playerID         DBRef
 	authenticated    bool
-	connected        bool
-	reader           *bufio.Reader
-	commandChan      chan string
 	inbound          chan PlayerEvent
 	outbound         chan PlayerEvent
 	eventDistributor *EventDistributor
+	quit             chan bool
 	db               *DB
 	factory          *ObjectFactory
 }
 	c := new(Client)
 	c.conn = conn
 	c.connectionID = connectionID
-	c.reader = bufio.NewReader(conn)
-	c.authenticated = false
 	c.connected = true
-	c.commandChan = make(chan string)
+	c.authenticated = false
 	c.inbound = make(chan PlayerEvent)
 	c.eventDistributor = e
 	c.db = w
 
 	log.Print("Received connection from ", c.conn.RemoteAddr())
 
+	commandChan := make(chan string)
+	dieChan := make(chan bool)
+
 	go func() {
+		reader := bufio.NewReader(c.conn)
+
 		for c.connected {
-			message, err := c.reader.ReadString('\n')
+
+			message, err := reader.ReadString('\n')
 			if err != nil {
-				c.connected = false
-				return
+				fmt.Println("lost connection")
+				dieChan <- true
+				break
 			}
 			message = strings.TrimSpace(message)
 			if len(message) > 0 {
-				c.commandChan <- message
+				commandChan <- message
 			}
 		}
 	}()
 		select {
 		case m := <-c.inbound:
 			c.handleInboundEvent(m)
-		case cmd := <-c.commandChan:
+		case cmd := <-commandChan:
 			if c.authenticated {
 				c.sendCommand(cmd)
 			} else {
 				c.handleLoginPhase(cmd)
 			}
+		case <-dieChan:
+			c.connected = false
 		}
 	}
 
 	c.conn.Close()
-
+	fmt.Println("conn.Close")
 	c.outbound <- PlayerEvent{src: c.playerID, dst: c.playerID, messageType: EventTypeTeardown, connectionID: c.connectionID}
 
 	log.Print("Lost connection from ", c.conn.RemoteAddr())

db.go

 	})
 }
 
-
 func (s *DB) SetPlayerPassword(name string, oldPassword string, newPassword string) bool {
-	
+
 	updated := false
 
 	s.db.Update(func(tx *bolt.Tx) error {
 		if err != nil {
 			return err
 		}
-		
+
 		if player.Password != oldPassword {
 			return fmt.Errorf("password mismatch")
 		}
-		
+
 		player.Password = newPassword
-		
+
 		buf, err := json.Marshal(player)
 		if err != nil {
 			return err
 	s.db.View(func(tx *bolt.Tx) error {
 		b := tx.Bucket([]byte("object"))
 		o, f = s.txRetrieveObject(b, id)
-		return nil	
+		return nil
 	})
 	return o, f
 

execution_context.go

 )
 
 const (
-	MatchContext = 			1 << iota
-	MatchGlobalDBRef = 		1 << iota
-	MatchGlobalPlayer = 	1 << iota
-	MatchInventory = 		1 << iota
-	MatchRelative =  	    1 << iota
-	MatchExitAliases = 		1 << iota
-	MatchExitType = 		1 << iota
-	MatchRoomType = 		1 << iota
-	MatchPlayerType = 		1 << iota
-	MatchThingType = 		1 << iota
-	MatchAnyType = 			MatchExitType|MatchRoomType|MatchPlayerType|MatchThingType
-	MatchStuffTypes =       MatchExitType|MatchRoomType|MatchThingType
-
+	MatchContext      = 1 << iota
+	MatchGlobalDBRef  = 1 << iota
+	MatchGlobalPlayer = 1 << iota
+	MatchInventory    = 1 << iota
+	MatchRelative     = 1 << iota
+	MatchExitAliases  = 1 << iota
+	MatchExitType     = 1 << iota
+	MatchRoomType     = 1 << iota
+	MatchPlayerType   = 1 << iota
+	MatchThingType    = 1 << iota
+	MatchAnyType      = MatchExitType | MatchRoomType | MatchPlayerType | MatchThingType
+	MatchStuffTypes   = MatchExitType | MatchRoomType | MatchThingType
 )
 
 type ExecutionContext struct {
 		c.output("%s\n%s", object.DetailedName(), object.Description)
 	} else {
 		c.output("%s\n%s", c.context.DetailedName(), c.context.Description)
-		contents := c.context.GetContents(c.actor.ID)
+		contents := c.context.GetContents(c.actor.ID, false)
 		if len(contents) > 0 {
 			c.output("Contents:\n" + strings.Join(contents, "\n"))
 		}
-		exits := c.context.GetExits(true)
+		exits := c.context.GetExits(true, false)
 		if len(exits) > 0 {
 			c.output("Obvious Exits:\n" + strings.Join(exits, " "))
 		}
 	c.output("Owner: %s", c.objectName(object.Owner))
 	c.output("Location: %s", c.objectName(containerID))
 
-	contents := object.GetContents(0)
+	contents := object.GetContents(0, true)
 	if len(contents) > 0 {
 		c.output("Contains:\n%s", strings.Join(contents, "\n"))
 	}
 
-	exits := object.GetExits(false)
+	exits := object.GetExits(false, true)
 	if len(exits) > 0 {
 		c.output("Exits:\n%s", strings.Join(exits, "\n"))
 	}
 		c.output("That player appears to be offline.")
 		return
 	}
-	
+
 	c.output(`You paged %s with "%s".`, candidate.ColorName(), message)
 	c.outbound <- PlayerEvent{src: c.actor.ID, dst: candidate.ID, message: message, messageType: EventTypePage}
-	
+
 }
 
 func (c *ExecutionContext) inventoryCmd() {
 
-	inventory := c.actor.GetContents(0)
+	inventory := c.actor.GetContents(0, true)
 
 	if len(inventory) > 0 {
 		c.output("Inventory:\n %s", strings.Join(inventory, "\n "))
 		c.output("You can't pick yourself up.")
 		return
 	}
-	
+
 	err := c.actor.Contains(&object)
 	if err != nil {
 		return
 }
 
 func (c *ExecutionContext) MatchFirst(context DBRef, matchName string, matchType int) (Object, bool) {
-	
+
 	wanted := map[string]bool{
-		"player": matchType & MatchPlayerType != 0,
-		"exit": matchType & MatchExitType != 0,
-		"room": matchType & MatchRoomType != 0,
-		"thing": matchType & MatchThingType != 0,
+		"player": matchType&MatchPlayerType != 0,
+		"exit":   matchType&MatchExitType != 0,
+		"room":   matchType&MatchRoomType != 0,
+		"thing":  matchType&MatchThingType != 0,
 	}
-	
-	if matchType & MatchRelative != 0 {	
+
+	if matchType&MatchRelative != 0 {
 		if matchName == "here" {
 			o, found := c.db.Fetch(context)
 			if found && wanted[o.Type] {
 				return o, true
 			}
 		}
-	
+
 		if matchName == "me" {
 			if wanted[c.actor.Type] {
 				return c.actor, true
 	}
 
 	ref, valid := NewDBRefFromHashRef(matchName)
-	
+
 	if valid {
 		o, found := c.db.Fetch(ref)
 		if found && wanted[o.Type] {
 			container, _ := c.db.GetParent(o.ID)
-			if container == context && matchType & MatchContext != 0 {
+			if container == context && matchType&MatchContext != 0 {
 				return o, true
 			}
-			if container == c.actor.ID && matchType & MatchInventory != 0 {
+			if container == c.actor.ID && matchType&MatchInventory != 0 {
 				return o, true
 			}
-			if matchType & MatchGlobalDBRef != 0 {
+			if matchType&MatchGlobalDBRef != 0 {
 				return o, true
 			}
 		}
 	}
-	
 
-	if  wanted["player"] && matchType & MatchGlobalPlayer != 0 {
+	if wanted["player"] && matchType&MatchGlobalPlayer != 0 {
 		o, found := c.MatchPlayerName(matchName)
 		if found {
 			return o, true
 		}
 	}
 
-	if matchType & MatchContext != 0 {
+	if matchType&MatchContext != 0 {
 		for childID, _ := range c.db.GetChildren(context) {
 			o, found := c.db.Fetch(childID)
 			if found && wanted[o.Type] {
-				if o.Type == "exit" && matchType & MatchExitAliases != 0 {
+				if o.Type == "exit" && matchType&MatchExitAliases != 0 {
 					aliases := strings.Split(o.Name, ";")
 					for _, v := range aliases {
 						if strings.EqualFold(v, matchName) {
 			}
 		}
 	}
-	
-	if matchType & MatchInventory != 0 {
+
+	if matchType&MatchInventory != 0 {
 		for childID, _ := range c.db.GetChildren(c.actor.ID) {
 			o, found := c.db.Fetch(childID)
 			if found && wanted[o.Type] {
 			}
 		}
 	}
-	
+
 	return Object{}, false
 
 }
 		return
 	}
 
+	if !object.GetFlag("enter_ok") && !c.actor.GetFlag("wizard") {
+		c.output("You're not allowed to do that.")
+		return
+	}
+
 	err := object.Contains(&c.actor)
 	if err != nil {
 		return
 		c.output("Only players can have passwords.")
 		return
 	}
-	
+
 	r, _ := regexp.Compile(`^@password\pZ+([^\pZ]+)\pZ*=\pZ*([^\pZ]+)\pZ*$`)
 	params := r.FindStringSubmatch(input)
 	if params == nil {
 		return
 	}
-	
+
 	oldPassword, newPassword := params[1], params[2]
 
 	if len(oldPassword) == 0 || len(newPassword) == 0 {
 		c.output("Password can't be blank.")
 		return
 	}
-	
+
 	changed := c.db.SetPlayerPassword(c.actor.Name, oldPassword, newPassword)
 	if changed {
 		c.output("Password updated.")
 	} else {
 		c.output("Old password is wrong.")
 	}
-	
+
 }
 
 func (c *ExecutionContext) nameCmd(input string) {
 
 func (c *ExecutionContext) descCmd(input string) {
 
-
 	r, _ := regexp.Compile(`^@desc\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
 	params := r.FindStringSubmatch(input)
 	if params == nil {
 
 	objectName, description := params[1], params[2]
 
-
 	object, found := c.MatchFirst(c.context.ID, objectName, MatchContext|MatchInventory|MatchRelative|MatchGlobalDBRef|MatchExitAliases|MatchAnyType)
 	if !found {
 		c.output("I don't see that here.")
 		return
 	}
 
+	if object.Owner != c.actor.ID && !c.actor.GetFlag("wizard") {
+		c.output("You're not allowed to do that.")
+		return
+	}
+
 	object.SetFlag(flag, value)
 	object.Commit()
 
 
 }
 
-
 func (c *ExecutionContext) colorCmd(input string) {
 
 	r, _ := regexp.Compile(`^@color\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*([^\pZ]*)\pZ*$`)
 		return
 	}
 
+	if object.Owner != c.actor.ID && !c.actor.GetFlag("wizard") {
+		c.output("You're not allowed to do that.")
+		return
+	}
+
 	object.SetProp("color", value)
 	object.Commit()
 
 
 }
 
-
-
 func (c *ExecutionContext) telCmd(destStr string) {
 
 	var dest Object
 		c.output("I didn't think homicide was your thing.")
 		return
 	}
+
+	if object.Owner != c.actor.ID && !c.actor.GetFlag("wizard") {
+		c.output("You're not allowed to do that.")
+		return
+	}
+
 	name := object.DetailedName()
 	err := object.Delete()
 	if err == nil {
 func (c *ExecutionContext) goCmd(dir string) bool {
 
 	exit, found := c.MatchFirst(c.context.ID, dir, MatchContext|MatchExitType|MatchExitAliases)
-	
+
 	if !found {
 		return false
 	}
-	
+
 	if !exit.Next.Valid() {
 		return false
 	}
 	c.oemit(c.context.ID, "%s leaves the room.", c.actor.ColorName())
 	c.oemit(newRoom.ID, "%s enters the room.", c.actor.ColorName())
 	return true
-	
-	
+
 	return false
 
 }

object.go

 
 import (
 	"fmt"
+	"github.com/mgutz/ansi"
 	"sort"
 	"strings"
-	"github.com/mgutz/ansi"
 )
 
 const (
 	o := Object{}
 	o.ID, _ = f.db.Allocate()
 	o.Type = "room"
-	o.Flags = map[string]bool{"jump_ok": true}
 	o.db = f.db
+	o.SetFlag("jump_ok", true)
 	return o
 }
 
 	o.ID, _ = f.db.Allocate()
 	o.Type = "thing"
 	o.db = f.db
+	o.SetFlag("enter_ok", true)
 	return o
 }
 
 	return o.Name
 }
 
-func (o *Object) GetContents(exclude DBRef) []string {
+func (o *Object) GetContents(exclude DBRef, showDark bool) []string {
 	r := make([]string, 0)
 	children := o.db.GetChildren(o.ID)
 	for childID, linkType := range children {
 		if !(linkType == "player" || linkType == "thing") {
 			continue
 		}
-		o, found := o.db.Fetch(childID)
+		child, found := o.db.Fetch(childID)
 		if !found {
 			continue
 		}
-		if linkType == "player" && !o.GetFlag("online") {
+		if linkType == "player" && !child.GetFlag("online") {
+			continue
+		}
+		if child.GetFlag("dark") && !showDark {
 			continue
 		}
-		r = append(r, o.DetailedName())
+		r = append(r, child.DetailedName())
 	}
 	sort.Strings(r)
 	return r
 }
 
-func (o *Object) GetExits(parseAliases bool) []string {
+func (o *Object) GetExits(parseAliases bool, showDark bool) []string {
 	r := make([]string, 0)
 	children := o.db.GetChildren(o.ID)
 	for exitID, linkType := range children {
 		if !found {
 			continue
 		}
+		if exit.GetFlag("dark") && !showDark {
+			continue
+		}
 		if parseAliases {
 			r = append(r, exit.FirstAlias())
 		} else {
 }
 
 func (o *Object) FirstAlias() string {
-	
+
 	aliases := strings.Split(o.Name, ";")
 	colour := o.GetProp("color")
 
 	}
 }
 
-
 func (o *Object) SetFlag(flag string, value bool) {
 	if o.Flags == nil {
 		o.Flags = make(map[string]bool)