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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
// Package uasurfer provides fast and reliable abstraction
// of HTTP User-Agent strings. The philosophy is to identify
// technologies that holds >1% market share, and to avoid
// expending resources and accuracy on guessing at esoteric UA
// strings.
package uasurfer
import "strings"
//go:generate stringer -type=DeviceType,BrowserName,OSName,Platform -output=const_string.go
// DeviceType (int) returns a constant.
type DeviceType int
// A complete list of supported devices in the
// form of constants.
const (
DeviceUnknown DeviceType = iota
DeviceComputer
DeviceTablet
DevicePhone
DeviceConsole
DeviceWearable
DeviceTV
)
// BrowserName (int) returns a constant.
type BrowserName int
// A complete list of supported web browsers in the
// form of constants.
const (
BrowserUnknown BrowserName = iota
BrowserChrome
BrowserIE
BrowserSafari
BrowserFirefox
BrowserAndroid
BrowserOpera
BrowserBlackberry
BrowserUCBrowser
BrowserSilk
BrowserNokia
BrowserNetFront
BrowserQQ
BrowserMaxthon
BrowserSogouExplorer
BrowserSpotify
BrowserBot // Bot list begins here
BrowserAppleBot
BrowserBaiduBot
BrowserBingBot
BrowserDuckDuckGoBot
BrowserFacebookBot
BrowserGoogleBot
BrowserLinkedInBot
BrowserMsnBot
BrowserPingdomBot
BrowserTwitterBot
BrowserYandexBot
BrowserYahooBot // Bot list ends here
)
// OSName (int) returns a constant.
type OSName int
// A complete list of supported OSes in the
// form of constants. For handling particular versions
// of operating systems (e.g. Windows 2000), see
// the README.md file.
const (
OSUnknown OSName = iota
OSWindowsPhone
OSWindows
OSMacOSX
OSiOS
OSAndroid
OSBlackberry
OSChromeOS
OSKindle
OSWebOS
OSLinux
OSPlaystation
OSXbox
OSNintendo
OSBot
)
// Platform (int) returns a constant.
type Platform int
// A complete list of supported platforms in the
// form of constants. Many OSes report their
// true platform, such as Android OS being Linux
// platform.
const (
PlatformUnknown Platform = iota
PlatformWindows
PlatformMac
PlatformLinux
PlatformiPad
PlatformiPhone
PlatformiPod
PlatformBlackberry
PlatformWindowsPhone
PlatformPlaystation
PlatformXbox
PlatformNintendo
PlatformBot
)
type Version struct {
Major int
Minor int
Patch int
}
func (v Version) Less(c Version) bool {
if v.Major < c.Major {
return true
}
if v.Major > c.Major {
return false
}
if v.Minor < c.Minor {
return true
}
if v.Minor > c.Minor {
return false
}
return v.Patch < c.Patch
}
type UserAgent struct {
Browser Browser
OS OS
DeviceType DeviceType
}
type Browser struct {
Name BrowserName
Version Version
}
type OS struct {
Platform Platform
Name OSName
Version Version
}
// Reset resets the UserAgent to it's zero value
func (ua *UserAgent) Reset() {
ua.Browser = Browser{}
ua.OS = OS{}
ua.DeviceType = DeviceUnknown
}
// Parse accepts a raw user agent (string) and returns the UserAgent.
func Parse(ua string) *UserAgent {
dest := new(UserAgent)
parse(ua, dest)
return dest
}
// ParseUserAgent is the same as Parse, but populates the supplied UserAgent.
// It is the caller's responsibility to call Reset() on the UserAgent before
// passing it to this function.
func ParseUserAgent(ua string, dest *UserAgent) {
parse(ua, dest)
}
func parse(ua string, dest *UserAgent) {
ua = normalise(ua)
switch {
case len(ua) == 0:
dest.OS.Platform = PlatformUnknown
dest.OS.Name = OSUnknown
dest.Browser.Name = BrowserUnknown
dest.DeviceType = DeviceUnknown
// stop on on first case returning true
case dest.evalOS(ua):
case dest.evalBrowserName(ua):
default:
dest.evalBrowserVersion(ua)
dest.evalDevice(ua)
}
}
// normalise normalises the user supplied agent string so that
// we can more easily parse it.
func normalise(ua string) string {
if len(ua) <= 1024 {
var buf [1024]byte
ascii := copyLower(buf[:len(ua)], ua)
if !ascii {
// Fall back for non ascii characters
return strings.ToLower(ua)
}
return string(buf[:len(ua)])
}
// Fallback for unusually long strings
return strings.ToLower(ua)
}
// copyLower copies a lowercase version of s to b. It assumes s contains only single byte characters
// and will panic if b is nil or is not long enough to contain all the bytes from s.
// It returns early with false if any characters were non ascii.
func copyLower(b []byte, s string) bool {
for j := 0; j < len(s); j++ {
c := s[j]
if c > 127 {
return false
}
if 'A' <= c && c <= 'Z' {
c += 'a' - 'A'
}
b[j] = c
}
return true
}
|
