tpl: avoid panic on too few args to apply

Fixes #1089

diff --git a/tpl/template_funcs.go b/tpl/template_funcs.go
index ea069b2af0e7365c030bc582fe9df48937896c14..68b0a22718dfafce88612ba350bc529166887e6d 100644 (file)
--- a/tpl/template_funcs.go
+++ b/tpl/template_funcs.go
@@ -653,6 +653,16 @@ func applyFnToThis(fn, this reflect.Value, args ...interface{}) (reflect.Value,
                }
        }
 
+       num := fn.Type().NumIn()
+
+       if fn.Type().IsVariadic() {
+               num--
+       }
+
+       if len(args) < num {
+               return reflect.ValueOf(nil), errors.New("Too few arguments")
+       }
+
        res := fn.Call(n)
 
        if len(res) == 1 || res[1].IsNil() {

diff --git a/tpl/template_test.go b/tpl/template_test.go
index 0c440966ba349cabee57d681b571195e206ce649..e3ce56a33c2370d8c96dcc57c5987575295d9c38 100644 (file)
--- a/tpl/template_test.go
+++ b/tpl/template_test.go
@@ -1,3 +1,74 @@
 package tpl
 
-// TODO(bep) test it
+import (
+       "errors"
+       "io/ioutil"
+       "testing"
+)
+
+// Test for bugs discovered by https://github.com/dvyukov/go-fuzz
+func TestTplGoFuzzReports(t *testing.T) {
+       for i, this := range []struct {
+               data      string
+               expectErr int
+       }{{"{{apply .C \"first\" }}", 2}} {
+               templ := New()
+
+               d := &Data{
+                       A: 42,
+                       B: "foo",
+                       C: []int{1, 2, 3},
+                       D: map[int]string{1: "foo", 2: "bar"},
+                       E: Data1{42, "foo"},
+               }
+
+               err := templ.AddTemplate("fuzz", this.data)
+
+               if err != nil && this.expectErr == 0 {
+                       t.Fatalf("Test %d errored: %s", i, err)
+               } else if err == nil && this.expectErr == 1 {
+                       t.Fatalf("#1 Test %d should have errored", i)
+               }
+
+               err = templ.ExecuteTemplate(ioutil.Discard, "fuzz", d)
+
+               if err != nil && this.expectErr == 0 {
+                       t.Fatalf("Test %d errored: %s", i, err)
+               } else if err == nil && this.expectErr == 2 {
+                       t.Fatalf("#2 Test %d should have errored", i)
+               }
+       }
+}
+
+type Data struct {
+       A int
+       B string
+       C []int
+       D map[int]string
+       E Data1
+}
+
+type Data1 struct {
+       A int
+       B string
+}
+
+func (Data1) Q() string {
+       return "foo"
+}
+
+func (Data1) W() (string, error) {
+       return "foo", nil
+}
+
+func (Data1) E() (string, error) {
+       return "foo", errors.New("Data.E error")
+}
+
+func (Data1) R(v int) (string, error) {
+       return "foo", nil
+}
+
+func (Data1) T(s string) (string, error) {
+       return s, nil
+}