1 files changed, 57 insertions, 72 deletions

diff --git a/src/nshd/hackers_git/db_group.go b/src/nshd/hackers_git/db_group.go
index 63a9fe4..3122bd2 100644
--- a/src/nshd/hackers_git/db_group.go
+++ b/src/nshd/hackers_git/db_group.go
@@ -1,9 +1,6 @@
 package hackers_git
 
-import (
-	p "nslcd_proto"
-	"nslcd_proto/util"
-)
+import p "nslcd_proto"
 
 func (o *Hackers) groupByName(name string, users bool) p.Group {
 	members_set, found := o.groups[name]
@@ -51,85 +48,73 @@ func (o *Hackers) groupByGid(gid int32, users bool) p.Group {
 	}
 }
 
-func (o *Hackers) Group_ByName(cred p.Ucred, req p.Request_Group_ByName) p.Group_Enumerator {
+func (o *Hackers) Group_ByName(cred p.Ucred, req p.Request_Group_ByName) <-chan p.Group {
 	o.lock.RLock()
-	defer o.lock.RUnlock()
-	group := o.groupByName(req.Name, true)
-	if group.ID < 0 {
-		return util.Group_Ø{}
-	}
-	return util.New_Group_List([]p.Group{group})
-}
+	ret := make(chan p.Group)
+	go func() {
+		defer o.lock.RUnlock()
+		defer close(ret)
 
-func (o *Hackers) Group_ByGid(cred p.Ucred, req p.Request_Group_ByGid) p.Group_Enumerator {
-	o.lock.RLock()
-	defer o.lock.RUnlock()
-	group := o.groupByGid(req.Gid, true)
-	if group.ID < 0 {
-		return util.Group_Ø{}
-	}
-	return util.New_Group_List([]p.Group{group})
+		group := o.groupByName(req.Name, true)
+		if group.ID < 0 {
+			return
+		}
+		ret <- group
+	}()
+	return ret
 }
 
-type groupEnumerator struct {
-	groups  []string
-	users   bool
-	backend *Hackers
-	done    bool
-}
+func (o *Hackers) Group_ByGid(cred p.Ucred, req p.Request_Group_ByGid) <-chan p.Group {
+	o.lock.RLock()
+	ret := make(chan p.Group)
+	go func() {
+		defer o.lock.RUnlock()
+		defer close(ret)
 
-func (e *groupEnumerator) GetNext() (*p.Group, error) {
-	for len(e.groups) > 0 {
-		name := e.groups[0]
-		group := e.backend.groupByName(name, e.users)
-		e.groups = e.groups[1:]
-		if group.ID >= 0 {
-			return &group, nil
+		group := o.groupByGid(req.Gid, true)
+		if group.ID < 0 {
+			return
 		}
-	}
-	if !e.done {
-		e.done = true
-		e.backend.lock.RUnlock()
-	}
-	return nil, nil
-}
-
-func (o *groupEnumerator) GenericGetNext() (n *interface{}, err error) {
-	a, err := o.GetNext()
-	if a != nil {
-		b := (interface{})(*a)
-		n = &b
-	}
-	return
+		ret <- group
+	}()
+	return ret
 }
 
 // note that the BYMEMBER call returns an empty members list
-func (o *Hackers) Group_ByMember(cred p.Ucred, req p.Request_Group_ByMember) p.Group_Enumerator {
+func (o *Hackers) Group_ByMember(cred p.Ucred, req p.Request_Group_ByMember) <-chan p.Group {
 	o.lock.RLock()
-	uid := o.name2uid(req.Member)
-	if uid < 0 {
-		return util.Group_Ø{}
-	}
-	return &groupEnumerator{
-		groups:  o.users[uid].groups,
-		users:   false,
-		backend: o,
-		done:    false,
-	}
+	ret := make(chan p.Group)
+	go func() {
+		defer o.lock.RUnlock()
+		defer close(ret)
+
+		uid := o.name2uid(req.Member)
+		if uid < 0 {
+			return
+		}
+		for _, name := range o.users[uid].groups {
+			group := o.groupByName(name, false)
+			if group.ID >= 0 {
+				ret <- group
+			}
+		}
+	}()
+	return ret
 }
 
-func (o *Hackers) Group_All(cred p.Ucred, req p.Request_Group_All) p.Group_Enumerator {
+func (o *Hackers) Group_All(cred p.Ucred, req p.Request_Group_All) <-chan p.Group {
 	o.lock.RLock()
-	e := groupEnumerator{
-		groups:  make([]string, len(o.groups)),
-		users:   true,
-		backend: o,
-		done:    false,
-	}
-	i := uint(0)
-	for group, _ := range o.groups {
-		e.groups[i] = group
-		i++
-	}
-	return &e
+	ret := make(chan p.Group)
+	go func() {
+		defer o.lock.RUnlock()
+		defer close(ret)
+
+		for name, _ := range o.groups {
+			group := o.groupByName(name, false)
+			if group.ID >= 0 {
+				ret <- group
+			}
+		}
+	}()
+	return ret
 }