podman

1
// Copyright 2013 The Go Authors. All rights reserved.
2
//
3
// Use of this source code is governed by a BSD-style
4
// license that can be found in the LICENSE file or at
5
// https://developers.google.com/open-source/licenses/bsd.
6

7
// this file was taken from the github.com/golang/gddo repository
8

9
// Package header provides functions for parsing HTTP headers.
10
package header
11

12
import (
13
	"net/http"
14
	"strings"
15
	"time"
16
)
17

18
// Octet types from RFC 2616.
19
var octetTypes [256]octetType
20

21
type octetType byte
22

23
const (
24
	isToken octetType = 1 << iota
25
	isSpace
26
)
27

28
func init() {
29
	// OCTET      = <any 8-bit sequence of data>
30
	// CHAR       = <any US-ASCII character (octets 0 - 127)>
31
	// CTL        = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
32
	// CR         = <US-ASCII CR, carriage return (13)>
33
	// LF         = <US-ASCII LF, linefeed (10)>
34
	// SP         = <US-ASCII SP, space (32)>
35
	// HT         = <US-ASCII HT, horizontal-tab (9)>
36
	// <">        = <US-ASCII double-quote mark (34)>
37
	// CRLF       = CR LF
38
	// LWS        = [CRLF] 1*( SP | HT )
39
	// TEXT       = <any OCTET except CTLs, but including LWS>
40
	// separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
41
	//              | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
42
	// token      = 1*<any CHAR except CTLs or separators>
43
	// qdtext     = <any TEXT except <">>
44

45
	for c := 0; c < 256; c++ {
46
		var t octetType
47
		isCtl := c <= 31 || c == 127
48
		isChar := 0 <= c && c <= 127
49
		isSeparator := strings.ContainsRune(" \t\"(),/:;<=>?@[]\\{}", rune(c))
50
		if strings.ContainsRune(" \t\r\n", rune(c)) {
51
			t |= isSpace
52
		}
53
		if isChar && !isCtl && !isSeparator {
54
			t |= isToken
55
		}
56
		octetTypes[c] = t
57
	}
58
}
59

60
// Copy returns a shallow copy of the header.
61
func Copy(header http.Header) http.Header {
62
	h := make(http.Header)
63
	for k, vs := range header {
64
		h[k] = vs
65
	}
66
	return h
67
}
68

69
var timeLayouts = []string{"Mon, 02 Jan 2006 15:04:05 GMT", time.RFC850, time.ANSIC}
70

71
// ParseTime parses the header as time. The zero value is returned if the
72
// header is not present or there is an error parsing the
73
// header.
74
func ParseTime(header http.Header, key string) time.Time {
75
	if s := header.Get(key); s != "" {
76
		for _, layout := range timeLayouts {
77
			if t, err := time.Parse(layout, s); err == nil {
78
				return t.UTC()
79
			}
80
		}
81
	}
82
	return time.Time{}
83
}
84

85
// ParseList parses a comma separated list of values. Commas are ignored in
86
// quoted strings. Quoted values are not unescaped or unquoted. Whitespace is
87
// trimmed.
88
func ParseList(header http.Header, key string) []string {
89
	var result []string
90
	for _, s := range header[http.CanonicalHeaderKey(key)] {
91
		begin := 0
92
		end := 0
93
		escape := false
94
		quote := false
95
		for i := 0; i < len(s); i++ {
96
			b := s[i]
97
			switch {
98
			case escape:
99
				escape = false
100
				end = i + 1
101
			case quote:
102
				switch b {
103
				case '\\':
104
					escape = true
105
				case '"':
106
					quote = false
107
				}
108
				end = i + 1
109
			case b == '"':
110
				quote = true
111
				end = i + 1
112
			case octetTypes[b]&isSpace != 0:
113
				if begin == end {
114
					begin = i + 1
115
					end = begin
116
				}
117
			case b == ',':
118
				if begin < end {
119
					result = append(result, s[begin:end])
120
				}
121
				begin = i + 1
122
				end = begin
123
			default:
124
				end = i + 1
125
			}
126
		}
127
		if begin < end {
128
			result = append(result, s[begin:end])
129
		}
130
	}
131
	return result
132
}
133

134
// ParseValueAndParams parses a comma separated list of values with optional
135
// semicolon separated name-value pairs. Content-Type and Content-Disposition
136
// headers are in this format.
137
func ParseValueAndParams(header http.Header, key string) (string, map[string]string) {
138
	return parseValueAndParams(header.Get(key))
139
}
140

141
func parseValueAndParams(s string) (value string, params map[string]string) {
142
	params = make(map[string]string)
143
	value, s = expectTokenSlash(s)
144
	if value == "" {
145
		return
146
	}
147
	value = strings.ToLower(value)
148
	s = skipSpace(s)
149
	for strings.HasPrefix(s, ";") {
150
		var pkey string
151
		pkey, s = expectToken(skipSpace(s[1:]))
152
		if pkey == "" {
153
			return
154
		}
155
		if !strings.HasPrefix(s, "=") {
156
			return
157
		}
158
		var pvalue string
159
		pvalue, s = expectTokenOrQuoted(s[1:])
160
		if pvalue == "" {
161
			return
162
		}
163
		pkey = strings.ToLower(pkey)
164
		params[pkey] = pvalue
165
		s = skipSpace(s)
166
	}
167
	return
168
}
169

170
// AcceptSpec ...
171
type AcceptSpec struct {
172
	Value string
173
	Q     float64
174
}
175

176
// ParseAccept2 ...
177
func ParseAccept2(header http.Header, key string) (specs []AcceptSpec) {
178
	for _, en := range ParseList(header, key) {
179
		v, p := parseValueAndParams(en)
180
		var spec AcceptSpec
181
		spec.Value = v
182
		spec.Q = 1.0
183
		if p != nil {
184
			if q, ok := p["q"]; ok {
185
				spec.Q, _ = expectQuality(q)
186
			}
187
		}
188
		if spec.Q < 0.0 {
189
			continue
190
		}
191
		specs = append(specs, spec)
192
	}
193

194
	return
195
}
196

197
// ParseAccept parses Accept* headers.
198
func ParseAccept(header http.Header, key string) (specs []AcceptSpec) {
199
loop:
200
	for _, s := range header[key] {
201
		for {
202
			var spec AcceptSpec
203
			spec.Value, s = expectTokenSlash(s)
204
			if spec.Value == "" {
205
				continue loop
206
			}
207
			spec.Q = 1.0
208
			s = skipSpace(s)
209
			if strings.HasPrefix(s, ";") {
210
				s = skipSpace(s[1:])
211
				for !strings.HasPrefix(s, "q=") && s != "" && !strings.HasPrefix(s, ",") {
212
					s = skipSpace(s[1:])
213
				}
214
				if strings.HasPrefix(s, "q=") {
215
					spec.Q, s = expectQuality(s[2:])
216
					if spec.Q < 0.0 {
217
						continue loop
218
					}
219
				}
220
			}
221
			specs = append(specs, spec)
222
			s = skipSpace(s)
223
			if !strings.HasPrefix(s, ",") {
224
				continue loop
225
			}
226
			s = skipSpace(s[1:])
227
		}
228
	}
229
	return
230
}
231

232
func skipSpace(s string) (rest string) {
233
	i := 0
234
	for ; i < len(s); i++ {
235
		if octetTypes[s[i]]&isSpace == 0 {
236
			break
237
		}
238
	}
239
	return s[i:]
240
}
241

242
func expectToken(s string) (token, rest string) {
243
	i := 0
244
	for ; i < len(s); i++ {
245
		if octetTypes[s[i]]&isToken == 0 {
246
			break
247
		}
248
	}
249
	return s[:i], s[i:]
250
}
251

252
func expectTokenSlash(s string) (token, rest string) {
253
	i := 0
254
	for ; i < len(s); i++ {
255
		b := s[i]
256
		if (octetTypes[b]&isToken == 0) && b != '/' {
257
			break
258
		}
259
	}
260
	return s[:i], s[i:]
261
}
262

263
func expectQuality(s string) (q float64, rest string) {
264
	switch {
265
	case len(s) == 0:
266
		return -1, ""
267
	case s[0] == '0':
268
		// q is already 0
269
		s = s[1:]
270
	case s[0] == '1':
271
		s = s[1:]
272
		q = 1
273
	case s[0] == '.':
274
		// q is already 0
275
	default:
276
		return -1, ""
277
	}
278
	if !strings.HasPrefix(s, ".") {
279
		return q, s
280
	}
281
	s = s[1:]
282
	i := 0
283
	n := 0
284
	d := 1
285
	for ; i < len(s); i++ {
286
		b := s[i]
287
		if b < '0' || b > '9' {
288
			break
289
		}
290
		n = n*10 + int(b) - '0'
291
		d *= 10
292
	}
293
	return q + float64(n)/float64(d), s[i:]
294
}
295

296
func expectTokenOrQuoted(s string) (value string, rest string) {
297
	if !strings.HasPrefix(s, "\"") {
298
		return expectToken(s)
299
	}
300
	s = s[1:]
301
	for i := 0; i < len(s); i++ {
302
		switch s[i] {
303
		case '"':
304
			return s[:i], s[i+1:]
305
		case '\\':
306
			p := make([]byte, len(s)-1)
307
			j := copy(p, s[:i])
308
			escape := true
309
			for i = i + 1; i < len(s); i++ {
310
				b := s[i]
311
				switch {
312
				case escape:
313
					escape = false
314
					p[j] = b
315
					j++
316
				case b == '\\':
317
					escape = true
318
				case b == '"':
319
					return string(p[:j]), s[i+1:]
320
				default:
321
					p[j] = b
322
					j++
323
				}
324
			}
325
			return "", ""
326
		}
327
	}
328
	return "", ""
329
}
330