netramesh

sniff.go
264 строки · 6.6 Кб
Перенос по словам
1
// Copyright 2011 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
package http
6

7
import (
8
	"bytes"
9
	"encoding/binary"
10
)
11

12
// The algorithm uses at most sniffLen bytes to make its decision.
13
const sniffLen = 512
14

15
// DetectContentType implements the algorithm described
16
// at https://mimesniff.spec.whatwg.org/ to determine the
17
// Content-Type of the given data. It considers at most the
18
// first 512 bytes of data. DetectContentType always returns
19
// a valid MIME type: if it cannot determine a more specific one, it
20
// returns "application/octet-stream".
21
func DetectContentType(data []byte) string {
22
	if len(data) > sniffLen {
23
		data = data[:sniffLen]
24
	}
25

26
	// Index of the first non-whitespace byte in data.
27
	firstNonWS := 0
28
	for ; firstNonWS < len(data) && isWS(data[firstNonWS]); firstNonWS++ {
29
	}
30

31
	for _, sig := range sniffSignatures {
32
		if ct := sig.match(data, firstNonWS); ct != "" {
33
			return ct
34
		}
35
	}
36

37
	return "application/octet-stream" // fallback
38
}
39

40
func isWS(b byte) bool {
41
	switch b {
42
	case '\t', '\n', '\x0c', '\r', ' ':
43
		return true
44
	}
45
	return false
46
}
47

48
type sniffSig interface {
49
	// match returns the MIME type of the data, or "" if unknown.
50
	match(data []byte, firstNonWS int) string
51
}
52

53
// Data matching the table in section 6.
54
var sniffSignatures = []sniffSig{
55
	htmlSig("<!DOCTYPE HTML"),
56
	htmlSig("<HTML"),
57
	htmlSig("<HEAD"),
58
	htmlSig("<SCRIPT"),
59
	htmlSig("<IFRAME"),
60
	htmlSig("<H1"),
61
	htmlSig("<DIV"),
62
	htmlSig("<FONT"),
63
	htmlSig("<TABLE"),
64
	htmlSig("<A"),
65
	htmlSig("<STYLE"),
66
	htmlSig("<TITLE"),
67
	htmlSig("<B"),
68
	htmlSig("<BODY"),
69
	htmlSig("<BR"),
70
	htmlSig("<P"),
71
	htmlSig("<!--"),
72

73
	&maskedSig{mask: []byte("\xFF\xFF\xFF\xFF\xFF"), pat: []byte("<?xml"), skipWS: true, ct: "text/xml; charset=utf-8"},
74

75
	&exactSig{[]byte("%PDF-"), "application/pdf"},
76
	&exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
77

78
	// UTF BOMs.
79
	&maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFE\xFF\x00\x00"), ct: "text/plain; charset=utf-16be"},
80
	&maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFF\xFE\x00\x00"), ct: "text/plain; charset=utf-16le"},
81
	&maskedSig{mask: []byte("\xFF\xFF\xFF\x00"), pat: []byte("\xEF\xBB\xBF\x00"), ct: "text/plain; charset=utf-8"},
82

83
	&exactSig{[]byte("GIF87a"), "image/gif"},
84
	&exactSig{[]byte("GIF89a"), "image/gif"},
85
	&exactSig{[]byte("\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"), "image/png"},
86
	&exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
87
	&exactSig{[]byte("BM"), "image/bmp"},
88
	&maskedSig{
89
		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
90
		pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
91
		ct:   "image/webp",
92
	},
93
	&exactSig{[]byte("\x00\x00\x01\x00"), "image/vnd.microsoft.icon"},
94

95
	&maskedSig{
96
		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
97
		pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
98
		ct:   "audio/wave",
99
	},
100
	&maskedSig{
101
		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
102
		pat:  []byte("FORM\x00\x00\x00\x00AIFF"),
103
		ct:   "audio/aiff",
104
	},
105
	&maskedSig{
106
		mask: []byte("\xFF\xFF\xFF\xFF"),
107
		pat:  []byte(".snd"),
108
		ct:   "audio/basic",
109
	},
110
	&maskedSig{
111
		mask: []byte("\xFF\xFF\xFF\xFF\xFF"),
112
		pat:  []byte("OggS\x00"),
113
		ct:   "application/ogg",
114
	},
115
	&maskedSig{
116
		mask: []byte("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
117
		pat:  []byte("MThd\x00\x00\x00\x06"),
118
		ct:   "audio/midi",
119
	},
120
	&maskedSig{
121
		mask: []byte("\xFF\xFF\xFF"),
122
		pat:  []byte("ID3"),
123
		ct:   "audio/mpeg",
124
	},
125
	&maskedSig{
126
		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
127
		pat:  []byte("RIFF\x00\x00\x00\x00AVI "),
128
		ct:   "video/avi",
129
	},
130

131
	// Fonts
132
	&maskedSig{
133
		// 34 NULL bytes followed by the string "LP"
134
		pat: []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4C\x50"),
135
		// 34 NULL bytes followed by \xF\xF
136
		mask: []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"),
137
		ct:   "application/vnd.ms-fontobject",
138
	},
139
	&exactSig{[]byte("\x00\x01\x00\x00"), "font/ttf"},
140
	&exactSig{[]byte("OTTO"), "font/otf"},
141
	&exactSig{[]byte("ttcf"), "font/collection"},
142
	&exactSig{[]byte("wOFF"), "font/woff"},
143
	&exactSig{[]byte("wOF2"), "font/woff2"},
144

145
	&exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
146
	&exactSig{[]byte("\x52\x61\x72\x20\x1A\x07\x00"), "application/x-rar-compressed"},
147
	&exactSig{[]byte("\x50\x4B\x03\x04"), "application/zip"},
148
	&exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
149

150
	&exactSig{[]byte("\x00\x61\x73\x6D"), "application/wasm"},
151

152
	mp4Sig{},
153

154
	textSig{}, // should be last
155
}
156

157
type exactSig struct {
158
	sig []byte
159
	ct  string
160
}
161

162
func (e *exactSig) match(data []byte, firstNonWS int) string {
163
	if bytes.HasPrefix(data, e.sig) {
164
		return e.ct
165
	}
166
	return ""
167
}
168

169
type maskedSig struct {
170
	mask, pat []byte
171
	skipWS    bool
172
	ct        string
173
}
174

175
func (m *maskedSig) match(data []byte, firstNonWS int) string {
176
	// pattern matching algorithm section 6
177
	// https://mimesniff.spec.whatwg.org/#pattern-matching-algorithm
178

179
	if m.skipWS {
180
		data = data[firstNonWS:]
181
	}
182
	if len(m.pat) != len(m.mask) {
183
		return ""
184
	}
185
	if len(data) < len(m.mask) {
186
		return ""
187
	}
188
	for i, mask := range m.mask {
189
		db := data[i] & mask
190
		if db != m.pat[i] {
191
			return ""
192
		}
193
	}
194
	return m.ct
195
}
196

197
type htmlSig []byte
198

199
func (h htmlSig) match(data []byte, firstNonWS int) string {
200
	data = data[firstNonWS:]
201
	if len(data) < len(h)+1 {
202
		return ""
203
	}
204
	for i, b := range h {
205
		db := data[i]
206
		if 'A' <= b && b <= 'Z' {
207
			db &= 0xDF
208
		}
209
		if b != db {
210
			return ""
211
		}
212
	}
213
	// Next byte must be space or right angle bracket.
214
	if db := data[len(h)]; db != ' ' && db != '>' {
215
		return ""
216
	}
217
	return "text/html; charset=utf-8"
218
}
219

220
var mp4ftype = []byte("ftyp")
221
var mp4 = []byte("mp4")
222

223
type mp4Sig struct{}
224

225
func (mp4Sig) match(data []byte, firstNonWS int) string {
226
	// https://mimesniff.spec.whatwg.org/#signature-for-mp4
227
	// c.f. section 6.2.1
228
	if len(data) < 12 {
229
		return ""
230
	}
231
	boxSize := int(binary.BigEndian.Uint32(data[:4]))
232
	if boxSize%4 != 0 || len(data) < boxSize {
233
		return ""
234
	}
235
	if !bytes.Equal(data[4:8], mp4ftype) {
236
		return ""
237
	}
238
	for st := 8; st < boxSize; st += 4 {
239
		if st == 12 {
240
			// minor version number
241
			continue
242
		}
243
		if bytes.Equal(data[st:st+3], mp4) {
244
			return "video/mp4"
245
		}
246
	}
247
	return ""
248
}
249

250
type textSig struct{}
251

252
func (textSig) match(data []byte, firstNonWS int) string {
253
	// c.f. section 5, step 4.
254
	for _, b := range data[firstNonWS:] {
255
		switch {
256
		case b <= 0x08,
257
			b == 0x0B,
258
			0x0E <= b && b <= 0x1A,
259
			0x1C <= b && b <= 0x1F:
260
			return ""
261
		}
262
	}
263
	return "text/plain; charset=utf-8"
264
}
265
netramesh

Использование cookies
