Should verify that the max value is not too big

When parsing the ulimit, we should check if the ulimit max value is greater then
the processes max value.  If yes then we should return an error.

Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>

Author: rhatdan

ulimit.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"syscall"
 )
 
 // Ulimit is a human friendly version of Rlimit.
@@ -108,6 +109,29 @@ func ParseUlimit(val string) (*Ulimit, error) {
 	return &Ulimit{Name: parts[0], Soft: soft, Hard: *hard}, nil
 }
 
+// ParseUlimitAndVerify parses the value and verifyies that values work
+// with current kernel, returns a Ulimit from the specified string.
+func ParseUlimitAndVerify(val string) (*Ulimit, error) {
+	limit, err := ParseUlimit(val)
+	if err != nil {
+		return nil, err
+	}
+
+	parts := strings.Split(val, "=")
+	if len(parts) < 1 {
+		// this should never happen ParseUlimit should have caught this
+		return nil, fmt.Errorf("invalid ulimit argument: %s", val)
+	}
+
+	var rlimit syscall.Rlimit
+	if err := syscall.Getrlimit(ulimitNameMapping[parts[0]], &rlimit); err == nil {
+		if limit.Hard > int64(rlimit.Max) {
+			return nil, fmt.Errorf("ulimit hard limit must be less than or equal to hard limit for the current process, hard: %d", limit.Hard)
+		}
+	}
+	return limit, nil
+}
+
 // GetRlimit returns the RLimit corresponding to Ulimit.
 func (u *Ulimit) GetRlimit() (*Rlimit, error) {
 	t, exists := ulimitNameMapping[u.Name]

ulimit_test.go

@@ -21,6 +21,12 @@ func TestParseUlimitValid(t *testing.T) {
 	}
 }
 
+func TestParseUlimitTooBig(t *testing.T) {
+	if _, err := ParseUlimitAndVerify("nofile=512:1000024"); err == nil {
+		t.Fatalf("expected invalid value got %q", err)
+	}
+}
+
 func TestParseUlimitInvalidLimitType(t *testing.T) {
 	if _, err := ParseUlimit("notarealtype=1024:1024"); err == nil {
 		t.Fatalf("expected error on invalid ulimit type")