user: skip empty lines

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

user/user.go

@@ -56,14 +56,17 @@ type IDMap struct {
 	Count    int64
 }
 
-func parseLine(line []byte, v ...any) error {
+func parseLine(line []byte, v ...any) (ok bool, _ error) {
+	line = bytes.TrimSpace(line)
+	if len(line) == 0 {
+		return false, nil
+	}
 	return parseParts(bytes.Split(line, []byte(":")), v...)
 }
 
-func parseParts(parts [][]byte, v ...any) error {
+func parseParts(parts [][]byte, v ...any) (ok bool, _ error) {
 	if len(parts) == 0 {
-		// TODO(thaJeztah); do we need an "ok" return so that we can skip these in loops?
-		return nil
+		return false, nil
 	}
 
 	for i, p := range parts {
@@ -82,18 +85,18 @@ func parseParts(parts [][]byte, v ...any) error {
 			if len(p) != 0 {
 				n, ok, err := parseNumeric(string(p))
 				if err != nil {
-					return fmt.Errorf("parsing integer field %d: %w", i, err)
+					return true, fmt.Errorf("parsing integer field %d: %w", i, err)
 				}
 				if !ok {
-					return fmt.Errorf("parsing integer field %d: %q is not numeric", i, p)
+					return true, fmt.Errorf("parsing integer field %d: %q is not numeric", i, p)
 				}
 				*e = n
 			}
 		case *int64:
 			if len(p) != 0 {
 				n, err := strconv.ParseInt(string(p), 10, 64)
 				if err != nil {
-					return fmt.Errorf("parsing integer field %d: %w", i, err)
+					return true, fmt.Errorf("parsing integer field %d: %w", i, err)
 				}
 				*e = n
 			}
@@ -109,7 +112,7 @@ func parseParts(parts [][]byte, v ...any) error {
 			panic(fmt.Sprintf("parseLine only accepts {*string, *int, *int64, *[]string} as arguments! %#v is not a pointer!", e))
 		}
 	}
-	return nil
+	return true, nil
 }
 
 func ParsePasswdFile(path string) ([]User, error) {
@@ -151,8 +154,9 @@ func ParsePasswdFilter(r io.Reader, filter func(User) bool) ([]User, error) {
 		//  root:x:0:0:root:/root:/bin/bash
 		//  adm:x:3:4:adm:/var/adm:/bin/false
 		p := User{}
-		if err := parseLine(line, &p.Name, &p.Pass, &p.Uid, &p.Gid, &p.Gecos, &p.Home, &p.Shell); err != nil {
-			// Skip malformed lines, and don't consider them.
+		ok, err := parseLine(line, &p.Name, &p.Pass, &p.Uid, &p.Gid, &p.Gecos, &p.Home, &p.Shell)
+		if err != nil || !ok {
+			// Skip malformed and empty lines, and don't consider them.
 			continue
 		}
 
@@ -213,8 +217,9 @@ func ParseGroupFilter(r io.Reader, filter func(Group) bool) ([]Group, error) {
 		//  root:x:0:root
 		//  adm:x:4:root,adm,daemon
 		p := Group{}
-		if err := parseLine(line, &p.Name, &p.Pass, &p.Gid, &p.List); err != nil {
-			// Skip malformed lines, and don't consider them.
+		ok, err := parseLine(line, &p.Name, &p.Pass, &p.Gid, &p.List)
+		if err != nil || !ok {
+			// Skip malformed and empty lines, and don't consider them.
 			continue
 		}
 
@@ -530,8 +535,9 @@ func ParseSubIDFilter(r io.Reader, filter func(SubID) bool) ([]SubID, error) {
 
 		// see: man 5 subuid
 		p := SubID{}
-		if err := parseLine(line, &p.Name, &p.SubID, &p.Count); err != nil {
-			// Skip malformed lines, and don't consider them.
+		ok, err := parseLine(line, &p.Name, &p.SubID, &p.Count)
+		if err != nil || !ok {
+			// Skip malformed and empty lines, and don't consider them.
 			continue
 		}
 
@@ -581,8 +587,9 @@ func ParseIDMapFilter(r io.Reader, filter func(IDMap) bool) ([]IDMap, error) {
 
 		// see: man 7 user_namespaces
 		p := IDMap{}
-		if err := parseParts(bytes.Fields(line), &p.ID, &p.ParentID, &p.Count); err != nil {
-			// Skip malformed lines, and don't consider them.
+		ok, err := parseParts(bytes.Fields(line), &p.ID, &p.ParentID, &p.Count)
+		if err != nil || !ok {
+			// Skip malformed and empty lines, and don't consider them.
 			continue
 		}
 

user/user_test.go

@@ -21,63 +21,66 @@ func TestParseLine(t *testing.T) {
 		d    int
 	)
 
-	err := parseLine([]byte(""), &a, &b)
+	_, err := parseLine([]byte(""), &a, &b)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if a != "" || b != "" {
 		t.Fatalf("a and b should be empty ('%v', '%v')", a, b)
 	}
 
-	err = parseLine([]byte("a"), &a, &b)
+	_, err = parseLine([]byte("a"), &a, &b)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if a != "a" || b != "" {
 		t.Fatalf("a should be 'a' and b should be empty ('%v', '%v')", a, b)
 	}
 
-	err = parseLine([]byte("bad boys:corny cows"), &a, &b)
+	_, err = parseLine([]byte("bad boys:corny cows"), &a, &b)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if a != "bad boys" || b != "corny cows" {
 		t.Fatalf("a should be 'bad boys' and b should be 'corny cows' ('%v', '%v')", a, b)
 	}
 
-	err = parseLine([]byte(""), &c)
+	ok, err := parseLine([]byte(""), &c)
 	if err != nil {
 		t.Fatal(err)
 	}
+	if ok {
+		t.Fatalf("ok should be false for empty lines")
+	}
 	if len(c) != 0 {
 		t.Fatalf("c should be empty (%#v)", c)
 	}
 
-	err = parseLine([]byte("d,e,f:g:h:i,j,k"), &c, &a, &b, &c)
+	_, err = parseLine([]byte("d,e,f:g:h:i,j,k"), &c, &a, &b, &c)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if a != "g" || b != "h" || len(c) != 3 || c[0] != "i" || c[1] != "j" || c[2] != "k" {
 		t.Fatalf("a should be 'g', b should be 'h', and c should be ['i','j','k'] ('%v', '%v', '%#v')", a, b, c)
 	}
 
-	err = parseLine([]byte("::::::::::"), &a, &b, &c)
+	_, err = parseLine([]byte("::::::::::"), &a, &b, &c)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if a != "" || b != "" || len(c) != 0 {
 		t.Fatalf("a, b, and c should all be empty ('%v', '%v', '%#v')", a, b, c)
 	}
 
-	err = parseLine([]byte("not a number"), &d)
+	_, err = parseLine([]byte("not a number"), &d)
 	if err == nil {
 		t.Fatal("expected an error")
 	}
 	if d != 0 {
 		t.Fatalf("d should be 0 (%v)", d)
 	}
 
-	err = parseLine([]byte("b:12:c"), &a, &d, &b)
+	_, err = parseLine([]byte("b:12:c"), &a, &d, &b)
 	if err != nil {
 		t.Fatal(err)
 	}