-
-
Notifications
You must be signed in to change notification settings - Fork 123
/
httploader.go
160 lines (147 loc) · 4 KB
/
httploader.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
package httploader
import (
"compress/gzip"
"fmt"
"github.com/cshum/imagor"
"io"
"net/http"
"net/url"
"strconv"
"strings"
)
type HTTPLoader struct {
// The Transport used to request images, default http.DefaultTransport.
Transport http.RoundTripper
// ForwardHeaders copy request headers to image request headers
ForwardHeaders []string
// OverrideHeaders override image request headers
OverrideHeaders map[string]string
// AllowedSources list of host names allowed to load from,
// supports glob patterns such as *.google.com
AllowedSources []string
// Accept set request Accept and validate response Content-Type header
Accept string
// MaxAllowedSize maximum bytes allowed for image
MaxAllowedSize int
// DefaultScheme default image URL scheme
DefaultScheme string
// UserAgent default user agent for image request.
// Can be overridden by ForwardHeaders and OverrideHeaders
UserAgent string
accepts []string
}
func New(options ...Option) *HTTPLoader {
h := &HTTPLoader{
Transport: http.DefaultTransport.(*http.Transport).Clone(),
OverrideHeaders: map[string]string{},
DefaultScheme: "https",
Accept: "*/*",
UserAgent: fmt.Sprintf("Imagor/%s", imagor.Version),
}
for _, option := range options {
option(h)
}
if s := strings.ToLower(h.DefaultScheme); s == "nil" {
h.DefaultScheme = ""
}
if h.Accept != "" {
for _, seg := range strings.Split(h.Accept, ",") {
if typ := parseContentType(seg); typ != "" {
h.accepts = append(h.accepts, typ)
}
}
}
return h
}
func (h *HTTPLoader) Get(r *http.Request, image string) (*imagor.Blob, error) {
if image == "" {
return nil, imagor.ErrInvalid
}
u, err := url.Parse(image)
if err != nil {
return nil, imagor.ErrInvalid
}
if u.Host == "" || u.Scheme == "" {
if h.DefaultScheme != "" {
image = h.DefaultScheme + "://" + image
if u, err = url.Parse(image); err != nil {
return nil, imagor.ErrInvalid
}
} else {
return nil, imagor.ErrInvalid
}
}
if !isURLAllowed(u, h.AllowedSources) {
return nil, imagor.ErrInvalid
}
client := &http.Client{Transport: h.Transport}
if h.MaxAllowedSize > 0 {
req, err := h.newRequest(r, http.MethodHead, image)
if err != nil {
return nil, err
}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
_ = resp.Body.Close()
if resp.StatusCode < 200 && resp.StatusCode > 206 {
return nil, imagor.NewErrorFromStatusCode(resp.StatusCode)
}
contentLength, _ := strconv.Atoi(resp.Header.Get("Content-Length"))
if contentLength > h.MaxAllowedSize {
return nil, imagor.ErrMaxSizeExceeded
}
}
req, err := h.newRequest(r, http.MethodGet, image)
if err != nil {
return nil, err
}
return imagor.NewBlob(func() (io.ReadCloser, int64, error) {
resp, err := client.Do(req)
if err != nil {
return nil, 0, err
}
body := resp.Body
size, _ := strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64)
if resp.Header.Get("Content-Encoding") == "gzip" {
gzipBody, err := gzip.NewReader(resp.Body)
if err != nil {
return nil, 0, err
}
body = gzipBody
size = 0 // size unknown after decompress
}
if resp.StatusCode >= 400 {
return body, size, imagor.NewErrorFromStatusCode(resp.StatusCode)
}
if !validateContentType(resp.Header.Get("Content-Type"), h.accepts) {
return body, size, imagor.ErrUnsupportedFormat
}
return body, size, nil
}), nil
}
func (h *HTTPLoader) newRequest(r *http.Request, method, url string) (*http.Request, error) {
req, err := http.NewRequestWithContext(r.Context(), method, url, nil)
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", h.UserAgent)
if h.Accept != "" {
req.Header.Set("Accept", h.Accept)
}
for _, header := range h.ForwardHeaders {
if header == "*" {
req.Header = r.Header.Clone()
req.Header.Del("Accept-Encoding") // fix compressions
break
}
if _, ok := r.Header[header]; ok {
req.Header.Set(header, r.Header.Get(header))
}
}
for key, value := range h.OverrideHeaders {
req.Header.Set(key, value)
}
return req, nil
}