feature: header encoder filter

filters/builtin/builtin.go

@@ -139,6 +139,8 @@ func Filters() []filters.Spec {
 		NewSetPath(),
 		NewModRequestHeader(),
 		NewModResponseHeader(),
+		NewEncodeRequestHeader(),
+		NewEncodeResponseHeader(),
 		NewDropQuery(),
 		NewSetQuery(),
 		NewHealthCheck(),

filters/builtin/header_encode.go

@@ -0,0 +1,167 @@
+package builtin
+
+import (
+	log "github.com/sirupsen/logrus"
+	"github.com/zalando/skipper/filters"
+	xencoding "golang.org/x/text/encoding"
+	"golang.org/x/text/encoding/charmap"
+)
+
+type encodeTyp int
+
+const (
+	requestEncoder encodeTyp = iota + 1
+	responseEncoder
+)
+
+type encodeHeaderSpec struct {
+	typ encodeTyp
+}
+
+type encodeHeader struct {
+	typ     encodeTyp
+	header  string
+	encoder *xencoding.Encoder
+}
+
+func NewEncodeRequestHeader() *encodeHeaderSpec {
+	return &encodeHeaderSpec{
+		typ: requestEncoder,
+	}
+}
+func NewEncodeResponseHeader() *encodeHeaderSpec {
+	return &encodeHeaderSpec{
+		typ: responseEncoder,
+	}
+}
+
+func (spec *encodeHeaderSpec) Name() string {
+	switch spec.typ {
+	case requestEncoder:
+		return filters.EncodeRequestHeaderName
+	case responseEncoder:
+		return filters.EncodeResponseHeaderName
+	}
+	return "unknown"
+}
+
+func (spec *encodeHeaderSpec) CreateFilter(args []interface{}) (filters.Filter, error) {
+	if len(args) != 2 {
+		return nil, filters.ErrInvalidFilterParameters
+	}
+
+	header, ok := args[0].(string)
+	if !ok {
+		return nil, filters.ErrInvalidFilterParameters
+	}
+	to, ok := args[1].(string)
+	if !ok {
+		return nil, filters.ErrInvalidFilterParameters
+	}
+
+	var (
+		encoder *xencoding.Encoder
+	)
+
+	switch to {
+	case "ISO8859_1":
+		encoder = charmap.ISO8859_1.NewEncoder()
+	case "ISO8859_10":
+		encoder = charmap.ISO8859_10.NewEncoder()
+	case "ISO8859_13":
+		encoder = charmap.ISO8859_13.NewEncoder()
+	case "ISO8859_14":
+		encoder = charmap.ISO8859_14.NewEncoder()
+	case "ISO8859_15":
+		encoder = charmap.ISO8859_15.NewEncoder()
+	case "ISO8859_16":
+		encoder = charmap.ISO8859_16.NewEncoder()
+	case "ISO8859_2":
+		encoder = charmap.ISO8859_2.NewEncoder()
+	case "ISO8859_3":
+		encoder = charmap.ISO8859_3.NewEncoder()
+	case "ISO8859_4":
+		encoder = charmap.ISO8859_4.NewEncoder()
+	case "ISO8859_5":
+		encoder = charmap.ISO8859_5.NewEncoder()
+	case "ISO8859_6":
+		encoder = charmap.ISO8859_6.NewEncoder()
+	case "ISO8859_7":
+		encoder = charmap.ISO8859_7.NewEncoder()
+	case "ISO8859_8":
+		encoder = charmap.ISO8859_8.NewEncoder()
+	case "ISO8859_9":
+		encoder = charmap.ISO8859_9.NewEncoder()
+	case "KOI8R":
+		encoder = charmap.KOI8R.NewEncoder()
+	case "KOI8U":
+		encoder = charmap.KOI8U.NewEncoder()
+	case "Macintosh":
+		encoder = charmap.Macintosh.NewEncoder()
+	case "MacintoshCyrillic":
+		encoder = charmap.MacintoshCyrillic.NewEncoder()
+	case "Windows1250":
+		encoder = charmap.Windows1250.NewEncoder()
+	case "Windows1251":
+		encoder = charmap.Windows1251.NewEncoder()
+	case "Windows1252":
+		encoder = charmap.Windows1252.NewEncoder()
+	case "Windows1253":
+		encoder = charmap.Windows1253.NewEncoder()
+	case "Windows1254":
+		encoder = charmap.Windows1254.NewEncoder()
+	case "Windows1255":
+		encoder = charmap.Windows1255.NewEncoder()
+	case "Windows1256":
+		encoder = charmap.Windows1256.NewEncoder()
+	case "Windows1257":
+		encoder = charmap.Windows1257.NewEncoder()
+	case "Windows1258":
+		encoder = charmap.Windows1258.NewEncoder()
+	case "Windows874":
+		encoder = charmap.Windows874.NewEncoder()
+	default:
+		log.Errorf("Unknown encoder for %q", to)
+		return nil, filters.ErrInvalidFilterParameters
+	}
+
+	return &encodeHeader{
+		typ:     spec.typ,
+		header:  header,
+		encoder: encoder,
+	}, nil
+}
+
+func (f *encodeHeader) Request(ctx filters.FilterContext) {
+	if f.typ != requestEncoder {
+		return
+	}
+
+	s := ctx.Request().Header.Get(f.header)
+	if s == "" {
+		return
+	}
+
+	sNew, err := f.encoder.String(s)
+	if err != nil {
+		log.Errorf("Failed to encode %q: %v", s, err)
+	}
+	ctx.Request().Header.Set(f.header, sNew)
+}
+
+func (f *encodeHeader) Response(ctx filters.FilterContext) {
+	if f.typ != responseEncoder {
+		return
+	}
+	s := ctx.Response().Header.Get(f.header)
+	if s == "" {
+		return
+	}
+
+	sNew, err := f.encoder.String(s)
+	if err != nil {
+		log.Errorf("Failed to encode %q: %v", s, err)
+	}
+	ctx.Response().Header.Set(f.header, sNew)
+
+}

filters/builtin/header_encode_test.go

@@ -0,0 +1,115 @@
+package builtin
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/zalando/skipper/eskip"
+	"github.com/zalando/skipper/filters"
+	"github.com/zalando/skipper/filters/diag"
+	"github.com/zalando/skipper/proxy/proxytest"
+	"github.com/zalando/skipper/routing"
+	"github.com/zalando/skipper/routing/testdataclient"
+)
+
+func Test_encodeRequestHeader(t *testing.T) {
+	tests := []struct {
+		name string
+		doc  string
+		data string
+		want []byte
+	}{
+		{
+			name: "test request header Windows1252",
+			doc:  `r: * -> encodeRequestHeader("X-Test", "Windows1252") -> logHeader("request")-> "%s";`,
+			data: `für`,
+			want: []byte{102, 252, 114}, //`f\xfcr`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.Header().Set("Result", r.Header.Get("Result"))
+				w.WriteHeader(http.StatusOK)
+			}))
+			defer backend.Close()
+
+			r := eskip.MustParse(fmt.Sprintf(tt.doc, backend.URL))
+			fr := make(filters.Registry)
+			fr.Register(NewEncodeRequestHeader())
+			fr.Register(diag.NewLogHeader())
+
+			dc := testdataclient.New(r)
+			defer dc.Close()
+
+			proxy := proxytest.WithRoutingOptions(fr, routing.Options{
+				DataClients: []routing.DataClient{dc},
+			})
+			defer proxy.Close()
+
+			req, err := http.NewRequest("GET", proxy.URL, nil)
+			if err != nil {
+				t.Fatalf("Failed to create request: %v", err)
+			}
+			req.Header.Set("Result", tt.data)
+
+			rsp, err := proxy.Client().Do(req)
+			if err != nil {
+				t.Fatalf("Failed to do request: %v", err)
+			}
+			defer rsp.Body.Close()
+			if result := rsp.Header.Get("Result"); result != string(tt.want) {
+				t.Fatalf("Failed to get %q, got %q", tt.want, result)
+			}
+		})
+	}
+}
+
+func Test_encodeResponseHeader(t *testing.T) {
+	tests := []struct {
+		name string
+		doc  string
+		data string
+		want []byte
+	}{
+		{
+			name: "test response header Windows1252",
+			doc:  `r: * -> encodeResponseHeader("Result", "Windows1252") -> setResponseHeader("Result", "%s") -> <shunt>;`,
+			data: `für`,
+			want: []byte{102, 252, 114}, //`f\xfcr`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := eskip.MustParse(fmt.Sprintf(tt.doc, tt.data))
+			fr := make(filters.Registry)
+			fr.Register(NewEncodeResponseHeader())
+			fr.Register(NewSetResponseHeader())
+
+			dc := testdataclient.New(r)
+			defer dc.Close()
+
+			proxy := proxytest.WithRoutingOptions(fr, routing.Options{
+				DataClients: []routing.DataClient{dc},
+			})
+			defer proxy.Close()
+
+			req, err := http.NewRequest("GET", proxy.URL, nil)
+			if err != nil {
+				t.Fatalf("Failed to create request: %v", err)
+			}
+
+			rsp, err := proxy.Client().Do(req)
+			if err != nil {
+				t.Fatalf("Failed to do request: %v", err)
+			}
+			defer rsp.Body.Close()
+			if result := rsp.Header.Get("Result"); result != string(tt.want) {
+				t.Fatalf("Failed to get %q, got %q", tt.want, result)
+			}
+
+		})
+	}
+}

filters/filters.go

@@ -230,6 +230,8 @@ const (
 	AppendContextResponseHeaderName            = "appendContextResponseHeader"
 	CopyRequestHeaderName                      = "copyRequestHeader"
 	CopyResponseHeaderName                     = "copyResponseHeader"
+	EncodeRequestHeaderName                    = "encodeRequestHeader"
+	EncodeResponseHeaderName                   = "encodeResponseHeader"
 	ModPathName                                = "modPath"
 	SetPathName                                = "setPath"
 	RedirectToName                             = "redirectTo"