Skip to content

"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files

rc: reject out of range integer parameters instead of truncating them

Nick Craig-Wood7723091be979
diff --git a/fs/rc/internal.go b/fs/rc/internal.go
index 36d2fafd5..c1bbe7819 100644
--- a/fs/rc/internal.go
+++ b/fs/rc/internal.go
@@ -305,15 +305,14 @@ func init() {
// Terminates app
func rcQuit(ctx context.Context, in Params) (out Params, err error) {
- code, err := in.GetInt64("exitCode")
+ exitCode, err := in.GetInt("exitCode")
if IsErrParamInvalid(err) {
return nil, err
}
if IsErrParamNotFound(err) {
- code = 0
+ exitCode = 0
}
- exitCode := int(code)
go func(exitCode int) {
time.Sleep(time.Millisecond * 1500)
@@ -353,11 +352,11 @@ Results:
}
func rcSetMutexProfileFraction(ctx context.Context, in Params) (out Params, err error) {
- rate, err := in.GetInt64("rate")
+ rate, err := in.GetInt("rate")
if err != nil {
return nil, err
}
- previousRate := runtime.SetMutexProfileFraction(int(rate))
+ previousRate := runtime.SetMutexProfileFraction(rate)
out = make(Params)
out["previousRate"] = previousRate
return out, nil
@@ -388,11 +387,11 @@ Parameters:
}
func rcSetBlockProfileRate(ctx context.Context, in Params) (out Params, err error) {
- rate, err := in.GetInt64("rate")
+ rate, err := in.GetInt("rate")
if err != nil {
return nil, err
}
- runtime.SetBlockProfileRate(int(rate))
+ runtime.SetBlockProfileRate(rate)
return nil, nil
}
@@ -471,11 +470,11 @@ Parameters:
}
func rcSetGCPercent(ctx context.Context, in Params) (out Params, err error) {
- gcPercent, err := in.GetInt64("gc-percent")
+ gcPercent, err := in.GetInt("gc-percent")
if err != nil {
return nil, err
}
- oldGCPercent := debug.SetGCPercent(int(gcPercent))
+ oldGCPercent := debug.SetGCPercent(gcPercent)
out = Params{
"existing-gc-percent": oldGCPercent,
}
diff --git a/fs/rc/jobs/job.go b/fs/rc/jobs/job.go
index b4ef2acca..0390c3ad7 100644
--- a/fs/rc/jobs/job.go
+++ b/fs/rc/jobs/job.go
@@ -689,10 +689,10 @@ func rcBatch(ctx context.Context, in rc.Params) (out rc.Params, err error) {
}
// Read concurrency
- concurrency, err := in.GetInt64("concurrency")
+ concurrency, err := in.GetInt("concurrency")
if rc.IsErrParamNotFound(err) {
ci := fs.GetConfig(ctx)
- concurrency = int64(ci.Transfers)
+ concurrency = ci.Transfers
} else if err != nil {
return nil, err
}
@@ -702,7 +702,7 @@ func rcBatch(ctx context.Context, in rc.Params) (out rc.Params, err error) {
out["results"] = results
g, gCtx := errgroup.WithContext(ctx)
- g.SetLimit(int(concurrency))
+ g.SetLimit(concurrency)
for i, inputAny := range inputs {
input, ok := inputAny.(map[string]any)
if !ok {
diff --git a/fs/rc/params.go b/fs/rc/params.go
index 402be3c7b..994d543ca 100644
--- a/fs/rc/params.go
+++ b/fs/rc/params.go
@@ -182,6 +182,22 @@ func (p Params) GetInt64(key string) (int64, error) {
return 0, ErrParamInvalid{fmt.Errorf("expecting int64 value for key %q (was %T)", key, value)}
}
+// GetInt gets an int parameter from the input
+//
+// If the parameter isn't found then error will be of type
+// ErrParamNotFound and the returned value will be 0. If the value
+// doesn't fit in an int then the error will be of type ErrParamInvalid.
+func (p Params) GetInt(key string) (int, error) {
+ i, err := p.GetInt64(key)
+ if err != nil {
+ return 0, err
+ }
+ if i > math.MaxInt || i < math.MinInt {
+ return 0, ErrParamInvalid{fmt.Errorf("key %q (%v) overflows int", key, i)}
+ }
+ return int(i), nil
+}
+
// GetFloat64 gets a float64 parameter from the input
//
// If the parameter isn't found then error will be of type
diff --git a/fs/rc/params_test.go b/fs/rc/params_test.go
index 6714a5a3f..b6ad6f20d 100644
--- a/fs/rc/params_test.go
+++ b/fs/rc/params_test.go
@@ -158,6 +158,41 @@ func TestParamsGetInt64(t *testing.T) {
assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error())
}
+func TestParamsGetInt(t *testing.T) {
+ in := Params{
+ "int": "123",
+ "bad": "123x",
+ "notInt": []string{"a", "b"},
+ "maxInt": int64(math.MaxInt),
+ "minInt": int64(math.MinInt),
+ "overflow": "9223372036854775808",
+ }
+ v, err := in.GetInt("int")
+ require.NoError(t, err)
+ assert.Equal(t, 123, v)
+ v, err = in.GetInt("maxInt")
+ require.NoError(t, err)
+ assert.Equal(t, math.MaxInt, v)
+ v, err = in.GetInt("minInt")
+ require.NoError(t, err)
+ assert.Equal(t, math.MinInt, v)
+ for _, key := range []string{"bad", "notInt", "overflow"} {
+ v, err = in.GetInt(key)
+ assert.True(t, IsErrParamInvalid(err), key)
+ assert.Equal(t, 0, v)
+ }
+ v, err = in.GetInt("notFound")
+ assert.Equal(t, ErrParamNotFound("notFound"), err)
+ assert.Equal(t, 0, v)
+ if math.MaxInt == math.MaxInt32 {
+ in["big"] = int64(math.MaxInt32) + 1
+ v, err = in.GetInt("big")
+ assert.True(t, IsErrParamInvalid(err))
+ assert.Contains(t, err.Error(), "overflows int")
+ assert.Equal(t, 0, v)
+ }
+}
+
func TestParamsGetFloat64(t *testing.T) {
for _, test := range []struct {
value any