]>
Commit | Line | Data |
---|---|---|
15c0b25d AP |
1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. |
2 | ||
3 | // Copyright 2016 The Go Authors. All rights reserved. | |
4 | // Use of this source code is governed by a BSD-style | |
5 | // license that can be found in the LICENSE file. | |
6 | ||
107c1cdb ND |
7 | // +build go1.10 |
8 | ||
15c0b25d AP |
9 | // Package idna implements IDNA2008 using the compatibility processing |
10 | // defined by UTS (Unicode Technical Standard) #46, which defines a standard to | |
11 | // deal with the transition from IDNA2003. | |
12 | // | |
13 | // IDNA2008 (Internationalized Domain Names for Applications), is defined in RFC | |
14 | // 5890, RFC 5891, RFC 5892, RFC 5893 and RFC 5894. | |
107c1cdb ND |
15 | // UTS #46 is defined in https://www.unicode.org/reports/tr46. |
16 | // See https://unicode.org/cldr/utility/idna.jsp for a visualization of the | |
15c0b25d AP |
17 | // differences between these two standards. |
18 | package idna // import "golang.org/x/net/idna" | |
19 | ||
20 | import ( | |
21 | "fmt" | |
22 | "strings" | |
23 | "unicode/utf8" | |
24 | ||
25 | "golang.org/x/text/secure/bidirule" | |
107c1cdb | 26 | "golang.org/x/text/unicode/bidi" |
15c0b25d AP |
27 | "golang.org/x/text/unicode/norm" |
28 | ) | |
29 | ||
30 | // NOTE: Unlike common practice in Go APIs, the functions will return a | |
31 | // sanitized domain name in case of errors. Browsers sometimes use a partially | |
32 | // evaluated string as lookup. | |
33 | // TODO: the current error handling is, in my opinion, the least opinionated. | |
34 | // Other strategies are also viable, though: | |
35 | // Option 1) Return an empty string in case of error, but allow the user to | |
36 | // specify explicitly which errors to ignore. | |
37 | // Option 2) Return the partially evaluated string if it is itself a valid | |
38 | // string, otherwise return the empty string in case of error. | |
39 | // Option 3) Option 1 and 2. | |
40 | // Option 4) Always return an empty string for now and implement Option 1 as | |
41 | // needed, and document that the return string may not be empty in case of | |
42 | // error in the future. | |
43 | // I think Option 1 is best, but it is quite opinionated. | |
44 | ||
45 | // ToASCII is a wrapper for Punycode.ToASCII. | |
46 | func ToASCII(s string) (string, error) { | |
47 | return Punycode.process(s, true) | |
48 | } | |
49 | ||
50 | // ToUnicode is a wrapper for Punycode.ToUnicode. | |
51 | func ToUnicode(s string) (string, error) { | |
52 | return Punycode.process(s, false) | |
53 | } | |
54 | ||
55 | // An Option configures a Profile at creation time. | |
56 | type Option func(*options) | |
57 | ||
58 | // Transitional sets a Profile to use the Transitional mapping as defined in UTS | |
59 | // #46. This will cause, for example, "ß" to be mapped to "ss". Using the | |
60 | // transitional mapping provides a compromise between IDNA2003 and IDNA2008 | |
61 | // compatibility. It is used by most browsers when resolving domain names. This | |
62 | // option is only meaningful if combined with MapForLookup. | |
63 | func Transitional(transitional bool) Option { | |
64 | return func(o *options) { o.transitional = true } | |
65 | } | |
66 | ||
67 | // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts | |
68 | // are longer than allowed by the RFC. | |
69 | func VerifyDNSLength(verify bool) Option { | |
70 | return func(o *options) { o.verifyDNSLength = verify } | |
71 | } | |
72 | ||
73 | // RemoveLeadingDots removes leading label separators. Leading runes that map to | |
107c1cdb | 74 | // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well. |
15c0b25d AP |
75 | // |
76 | // This is the behavior suggested by the UTS #46 and is adopted by some | |
77 | // browsers. | |
78 | func RemoveLeadingDots(remove bool) Option { | |
79 | return func(o *options) { o.removeLeadingDots = remove } | |
80 | } | |
81 | ||
82 | // ValidateLabels sets whether to check the mandatory label validation criteria | |
83 | // as defined in Section 5.4 of RFC 5891. This includes testing for correct use | |
84 | // of hyphens ('-'), normalization, validity of runes, and the context rules. | |
85 | func ValidateLabels(enable bool) Option { | |
86 | return func(o *options) { | |
87 | // Don't override existing mappings, but set one that at least checks | |
88 | // normalization if it is not set. | |
89 | if o.mapping == nil && enable { | |
90 | o.mapping = normalize | |
91 | } | |
92 | o.trie = trie | |
93 | o.validateLabels = enable | |
94 | o.fromPuny = validateFromPunycode | |
95 | } | |
96 | } | |
97 | ||
107c1cdb | 98 | // StrictDomainName limits the set of permissible ASCII characters to those |
15c0b25d AP |
99 | // allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the |
100 | // hyphen). This is set by default for MapForLookup and ValidateForRegistration. | |
101 | // | |
102 | // This option is useful, for instance, for browsers that allow characters | |
103 | // outside this range, for example a '_' (U+005F LOW LINE). See | |
104 | // http://www.rfc-editor.org/std/std3.txt for more details This option | |
105 | // corresponds to the UseSTD3ASCIIRules option in UTS #46. | |
106 | func StrictDomainName(use bool) Option { | |
107 | return func(o *options) { | |
108 | o.trie = trie | |
109 | o.useSTD3Rules = use | |
110 | o.fromPuny = validateFromPunycode | |
111 | } | |
112 | } | |
113 | ||
114 | // NOTE: the following options pull in tables. The tables should not be linked | |
115 | // in as long as the options are not used. | |
116 | ||
117 | // BidiRule enables the Bidi rule as defined in RFC 5893. Any application | |
118 | // that relies on proper validation of labels should include this rule. | |
119 | func BidiRule() Option { | |
120 | return func(o *options) { o.bidirule = bidirule.ValidString } | |
121 | } | |
122 | ||
123 | // ValidateForRegistration sets validation options to verify that a given IDN is | |
124 | // properly formatted for registration as defined by Section 4 of RFC 5891. | |
125 | func ValidateForRegistration() Option { | |
126 | return func(o *options) { | |
127 | o.mapping = validateRegistration | |
128 | StrictDomainName(true)(o) | |
129 | ValidateLabels(true)(o) | |
130 | VerifyDNSLength(true)(o) | |
131 | BidiRule()(o) | |
132 | } | |
133 | } | |
134 | ||
135 | // MapForLookup sets validation and mapping options such that a given IDN is | |
136 | // transformed for domain name lookup according to the requirements set out in | |
137 | // Section 5 of RFC 5891. The mappings follow the recommendations of RFC 5894, | |
138 | // RFC 5895 and UTS 46. It does not add the Bidi Rule. Use the BidiRule option | |
139 | // to add this check. | |
140 | // | |
141 | // The mappings include normalization and mapping case, width and other | |
142 | // compatibility mappings. | |
143 | func MapForLookup() Option { | |
144 | return func(o *options) { | |
145 | o.mapping = validateAndMap | |
146 | StrictDomainName(true)(o) | |
147 | ValidateLabels(true)(o) | |
15c0b25d AP |
148 | } |
149 | } | |
150 | ||
151 | type options struct { | |
152 | transitional bool | |
153 | useSTD3Rules bool | |
154 | validateLabels bool | |
155 | verifyDNSLength bool | |
156 | removeLeadingDots bool | |
157 | ||
158 | trie *idnaTrie | |
159 | ||
160 | // fromPuny calls validation rules when converting A-labels to U-labels. | |
161 | fromPuny func(p *Profile, s string) error | |
162 | ||
163 | // mapping implements a validation and mapping step as defined in RFC 5895 | |
164 | // or UTS 46, tailored to, for example, domain registration or lookup. | |
107c1cdb | 165 | mapping func(p *Profile, s string) (mapped string, isBidi bool, err error) |
15c0b25d AP |
166 | |
167 | // bidirule, if specified, checks whether s conforms to the Bidi Rule | |
168 | // defined in RFC 5893. | |
169 | bidirule func(s string) bool | |
170 | } | |
171 | ||
172 | // A Profile defines the configuration of an IDNA mapper. | |
173 | type Profile struct { | |
174 | options | |
175 | } | |
176 | ||
177 | func apply(o *options, opts []Option) { | |
178 | for _, f := range opts { | |
179 | f(o) | |
180 | } | |
181 | } | |
182 | ||
183 | // New creates a new Profile. | |
184 | // | |
185 | // With no options, the returned Profile is the most permissive and equals the | |
186 | // Punycode Profile. Options can be passed to further restrict the Profile. The | |
187 | // MapForLookup and ValidateForRegistration options set a collection of options, | |
188 | // for lookup and registration purposes respectively, which can be tailored by | |
189 | // adding more fine-grained options, where later options override earlier | |
190 | // options. | |
191 | func New(o ...Option) *Profile { | |
192 | p := &Profile{} | |
193 | apply(&p.options, o) | |
194 | return p | |
195 | } | |
196 | ||
197 | // ToASCII converts a domain or domain label to its ASCII form. For example, | |
198 | // ToASCII("bücher.example.com") is "xn--bcher-kva.example.com", and | |
199 | // ToASCII("golang") is "golang". If an error is encountered it will return | |
200 | // an error and a (partially) processed result. | |
201 | func (p *Profile) ToASCII(s string) (string, error) { | |
202 | return p.process(s, true) | |
203 | } | |
204 | ||
205 | // ToUnicode converts a domain or domain label to its Unicode form. For example, | |
206 | // ToUnicode("xn--bcher-kva.example.com") is "bücher.example.com", and | |
207 | // ToUnicode("golang") is "golang". If an error is encountered it will return | |
208 | // an error and a (partially) processed result. | |
209 | func (p *Profile) ToUnicode(s string) (string, error) { | |
210 | pp := *p | |
211 | pp.transitional = false | |
212 | return pp.process(s, false) | |
213 | } | |
214 | ||
215 | // String reports a string with a description of the profile for debugging | |
216 | // purposes. The string format may change with different versions. | |
217 | func (p *Profile) String() string { | |
218 | s := "" | |
219 | if p.transitional { | |
220 | s = "Transitional" | |
221 | } else { | |
222 | s = "NonTransitional" | |
223 | } | |
224 | if p.useSTD3Rules { | |
225 | s += ":UseSTD3Rules" | |
226 | } | |
227 | if p.validateLabels { | |
228 | s += ":ValidateLabels" | |
229 | } | |
230 | if p.verifyDNSLength { | |
231 | s += ":VerifyDNSLength" | |
232 | } | |
233 | return s | |
234 | } | |
235 | ||
236 | var ( | |
237 | // Punycode is a Profile that does raw punycode processing with a minimum | |
238 | // of validation. | |
239 | Punycode *Profile = punycode | |
240 | ||
241 | // Lookup is the recommended profile for looking up domain names, according | |
242 | // to Section 5 of RFC 5891. The exact configuration of this profile may | |
243 | // change over time. | |
244 | Lookup *Profile = lookup | |
245 | ||
246 | // Display is the recommended profile for displaying domain names. | |
247 | // The configuration of this profile may change over time. | |
248 | Display *Profile = display | |
249 | ||
250 | // Registration is the recommended profile for checking whether a given | |
251 | // IDN is valid for registration, according to Section 4 of RFC 5891. | |
252 | Registration *Profile = registration | |
253 | ||
254 | punycode = &Profile{} | |
255 | lookup = &Profile{options{ | |
107c1cdb ND |
256 | transitional: true, |
257 | useSTD3Rules: true, | |
258 | validateLabels: true, | |
259 | trie: trie, | |
260 | fromPuny: validateFromPunycode, | |
261 | mapping: validateAndMap, | |
262 | bidirule: bidirule.ValidString, | |
15c0b25d AP |
263 | }} |
264 | display = &Profile{options{ | |
107c1cdb ND |
265 | useSTD3Rules: true, |
266 | validateLabels: true, | |
267 | trie: trie, | |
268 | fromPuny: validateFromPunycode, | |
269 | mapping: validateAndMap, | |
270 | bidirule: bidirule.ValidString, | |
15c0b25d AP |
271 | }} |
272 | registration = &Profile{options{ | |
273 | useSTD3Rules: true, | |
274 | validateLabels: true, | |
275 | verifyDNSLength: true, | |
276 | trie: trie, | |
277 | fromPuny: validateFromPunycode, | |
278 | mapping: validateRegistration, | |
279 | bidirule: bidirule.ValidString, | |
280 | }} | |
281 | ||
282 | // TODO: profiles | |
283 | // Register: recommended for approving domain names: don't do any mappings | |
284 | // but rather reject on invalid input. Bundle or block deviation characters. | |
285 | ) | |
286 | ||
287 | type labelError struct{ label, code_ string } | |
288 | ||
289 | func (e labelError) code() string { return e.code_ } | |
290 | func (e labelError) Error() string { | |
291 | return fmt.Sprintf("idna: invalid label %q", e.label) | |
292 | } | |
293 | ||
294 | type runeError rune | |
295 | ||
296 | func (e runeError) code() string { return "P1" } | |
297 | func (e runeError) Error() string { | |
298 | return fmt.Sprintf("idna: disallowed rune %U", e) | |
299 | } | |
300 | ||
301 | // process implements the algorithm described in section 4 of UTS #46, | |
107c1cdb | 302 | // see https://www.unicode.org/reports/tr46. |
15c0b25d AP |
303 | func (p *Profile) process(s string, toASCII bool) (string, error) { |
304 | var err error | |
107c1cdb | 305 | var isBidi bool |
15c0b25d | 306 | if p.mapping != nil { |
107c1cdb | 307 | s, isBidi, err = p.mapping(p, s) |
15c0b25d AP |
308 | } |
309 | // Remove leading empty labels. | |
310 | if p.removeLeadingDots { | |
311 | for ; len(s) > 0 && s[0] == '.'; s = s[1:] { | |
312 | } | |
313 | } | |
107c1cdb | 314 | // TODO: allow for a quick check of the tables data. |
15c0b25d AP |
315 | // It seems like we should only create this error on ToASCII, but the |
316 | // UTS 46 conformance tests suggests we should always check this. | |
317 | if err == nil && p.verifyDNSLength && s == "" { | |
318 | err = &labelError{s, "A4"} | |
319 | } | |
320 | labels := labelIter{orig: s} | |
321 | for ; !labels.done(); labels.next() { | |
322 | label := labels.label() | |
323 | if label == "" { | |
324 | // Empty labels are not okay. The label iterator skips the last | |
325 | // label if it is empty. | |
326 | if err == nil && p.verifyDNSLength { | |
327 | err = &labelError{s, "A4"} | |
328 | } | |
329 | continue | |
330 | } | |
331 | if strings.HasPrefix(label, acePrefix) { | |
332 | u, err2 := decode(label[len(acePrefix):]) | |
333 | if err2 != nil { | |
334 | if err == nil { | |
335 | err = err2 | |
336 | } | |
337 | // Spec says keep the old label. | |
338 | continue | |
339 | } | |
107c1cdb | 340 | isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight |
15c0b25d AP |
341 | labels.set(u) |
342 | if err == nil && p.validateLabels { | |
343 | err = p.fromPuny(p, u) | |
344 | } | |
345 | if err == nil { | |
346 | // This should be called on NonTransitional, according to the | |
347 | // spec, but that currently does not have any effect. Use the | |
348 | // original profile to preserve options. | |
349 | err = p.validateLabel(u) | |
350 | } | |
351 | } else if err == nil { | |
352 | err = p.validateLabel(label) | |
353 | } | |
354 | } | |
107c1cdb ND |
355 | if isBidi && p.bidirule != nil && err == nil { |
356 | for labels.reset(); !labels.done(); labels.next() { | |
357 | if !p.bidirule(labels.label()) { | |
358 | err = &labelError{s, "B"} | |
359 | break | |
360 | } | |
361 | } | |
362 | } | |
15c0b25d AP |
363 | if toASCII { |
364 | for labels.reset(); !labels.done(); labels.next() { | |
365 | label := labels.label() | |
366 | if !ascii(label) { | |
367 | a, err2 := encode(acePrefix, label) | |
368 | if err == nil { | |
369 | err = err2 | |
370 | } | |
371 | label = a | |
372 | labels.set(a) | |
373 | } | |
374 | n := len(label) | |
375 | if p.verifyDNSLength && err == nil && (n == 0 || n > 63) { | |
376 | err = &labelError{label, "A4"} | |
377 | } | |
378 | } | |
379 | } | |
380 | s = labels.result() | |
381 | if toASCII && p.verifyDNSLength && err == nil { | |
382 | // Compute the length of the domain name minus the root label and its dot. | |
383 | n := len(s) | |
384 | if n > 0 && s[n-1] == '.' { | |
385 | n-- | |
386 | } | |
387 | if len(s) < 1 || n > 253 { | |
388 | err = &labelError{s, "A4"} | |
389 | } | |
390 | } | |
391 | return s, err | |
392 | } | |
393 | ||
107c1cdb ND |
394 | func normalize(p *Profile, s string) (mapped string, isBidi bool, err error) { |
395 | // TODO: consider first doing a quick check to see if any of these checks | |
396 | // need to be done. This will make it slower in the general case, but | |
397 | // faster in the common case. | |
398 | mapped = norm.NFC.String(s) | |
399 | isBidi = bidirule.DirectionString(mapped) == bidi.RightToLeft | |
400 | return mapped, isBidi, nil | |
15c0b25d AP |
401 | } |
402 | ||
107c1cdb ND |
403 | func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error) { |
404 | // TODO: filter need for normalization in loop below. | |
15c0b25d | 405 | if !norm.NFC.IsNormalString(s) { |
107c1cdb | 406 | return s, false, &labelError{s, "V1"} |
15c0b25d AP |
407 | } |
408 | for i := 0; i < len(s); { | |
409 | v, sz := trie.lookupString(s[i:]) | |
107c1cdb ND |
410 | if sz == 0 { |
411 | return s, bidi, runeError(utf8.RuneError) | |
412 | } | |
413 | bidi = bidi || info(v).isBidi(s[i:]) | |
15c0b25d AP |
414 | // Copy bytes not copied so far. |
415 | switch p.simplify(info(v).category()) { | |
416 | // TODO: handle the NV8 defined in the Unicode idna data set to allow | |
417 | // for strict conformance to IDNA2008. | |
418 | case valid, deviation: | |
419 | case disallowed, mapped, unknown, ignored: | |
420 | r, _ := utf8.DecodeRuneInString(s[i:]) | |
107c1cdb | 421 | return s, bidi, runeError(r) |
15c0b25d AP |
422 | } |
423 | i += sz | |
424 | } | |
107c1cdb ND |
425 | return s, bidi, nil |
426 | } | |
427 | ||
428 | func (c info) isBidi(s string) bool { | |
429 | if !c.isMapped() { | |
430 | return c&attributesMask == rtl | |
431 | } | |
432 | // TODO: also store bidi info for mapped data. This is possible, but a bit | |
433 | // cumbersome and not for the common case. | |
434 | p, _ := bidi.LookupString(s) | |
435 | switch p.Class() { | |
436 | case bidi.R, bidi.AL, bidi.AN: | |
437 | return true | |
438 | } | |
439 | return false | |
15c0b25d AP |
440 | } |
441 | ||
107c1cdb | 442 | func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error) { |
15c0b25d | 443 | var ( |
107c1cdb ND |
444 | b []byte |
445 | k int | |
15c0b25d | 446 | ) |
107c1cdb ND |
447 | // combinedInfoBits contains the or-ed bits of all runes. We use this |
448 | // to derive the mayNeedNorm bit later. This may trigger normalization | |
449 | // overeagerly, but it will not do so in the common case. The end result | |
450 | // is another 10% saving on BenchmarkProfile for the common case. | |
451 | var combinedInfoBits info | |
15c0b25d AP |
452 | for i := 0; i < len(s); { |
453 | v, sz := trie.lookupString(s[i:]) | |
107c1cdb ND |
454 | if sz == 0 { |
455 | b = append(b, s[k:i]...) | |
456 | b = append(b, "\ufffd"...) | |
457 | k = len(s) | |
458 | if err == nil { | |
459 | err = runeError(utf8.RuneError) | |
460 | } | |
461 | break | |
462 | } | |
463 | combinedInfoBits |= info(v) | |
464 | bidi = bidi || info(v).isBidi(s[i:]) | |
15c0b25d AP |
465 | start := i |
466 | i += sz | |
467 | // Copy bytes not copied so far. | |
468 | switch p.simplify(info(v).category()) { | |
469 | case valid: | |
470 | continue | |
471 | case disallowed: | |
472 | if err == nil { | |
473 | r, _ := utf8.DecodeRuneInString(s[start:]) | |
474 | err = runeError(r) | |
475 | } | |
476 | continue | |
477 | case mapped, deviation: | |
478 | b = append(b, s[k:start]...) | |
479 | b = info(v).appendMapping(b, s[start:i]) | |
480 | case ignored: | |
481 | b = append(b, s[k:start]...) | |
482 | // drop the rune | |
483 | case unknown: | |
484 | b = append(b, s[k:start]...) | |
485 | b = append(b, "\ufffd"...) | |
486 | } | |
487 | k = i | |
488 | } | |
489 | if k == 0 { | |
490 | // No changes so far. | |
107c1cdb ND |
491 | if combinedInfoBits&mayNeedNorm != 0 { |
492 | s = norm.NFC.String(s) | |
493 | } | |
15c0b25d AP |
494 | } else { |
495 | b = append(b, s[k:]...) | |
496 | if norm.NFC.QuickSpan(b) != len(b) { | |
497 | b = norm.NFC.Bytes(b) | |
498 | } | |
499 | // TODO: the punycode converters require strings as input. | |
500 | s = string(b) | |
501 | } | |
107c1cdb | 502 | return s, bidi, err |
15c0b25d AP |
503 | } |
504 | ||
505 | // A labelIter allows iterating over domain name labels. | |
506 | type labelIter struct { | |
507 | orig string | |
508 | slice []string | |
509 | curStart int | |
510 | curEnd int | |
511 | i int | |
512 | } | |
513 | ||
514 | func (l *labelIter) reset() { | |
515 | l.curStart = 0 | |
516 | l.curEnd = 0 | |
517 | l.i = 0 | |
518 | } | |
519 | ||
520 | func (l *labelIter) done() bool { | |
521 | return l.curStart >= len(l.orig) | |
522 | } | |
523 | ||
524 | func (l *labelIter) result() string { | |
525 | if l.slice != nil { | |
526 | return strings.Join(l.slice, ".") | |
527 | } | |
528 | return l.orig | |
529 | } | |
530 | ||
531 | func (l *labelIter) label() string { | |
532 | if l.slice != nil { | |
533 | return l.slice[l.i] | |
534 | } | |
535 | p := strings.IndexByte(l.orig[l.curStart:], '.') | |
536 | l.curEnd = l.curStart + p | |
537 | if p == -1 { | |
538 | l.curEnd = len(l.orig) | |
539 | } | |
540 | return l.orig[l.curStart:l.curEnd] | |
541 | } | |
542 | ||
543 | // next sets the value to the next label. It skips the last label if it is empty. | |
544 | func (l *labelIter) next() { | |
545 | l.i++ | |
546 | if l.slice != nil { | |
547 | if l.i >= len(l.slice) || l.i == len(l.slice)-1 && l.slice[l.i] == "" { | |
548 | l.curStart = len(l.orig) | |
549 | } | |
550 | } else { | |
551 | l.curStart = l.curEnd + 1 | |
552 | if l.curStart == len(l.orig)-1 && l.orig[l.curStart] == '.' { | |
553 | l.curStart = len(l.orig) | |
554 | } | |
555 | } | |
556 | } | |
557 | ||
558 | func (l *labelIter) set(s string) { | |
559 | if l.slice == nil { | |
560 | l.slice = strings.Split(l.orig, ".") | |
561 | } | |
562 | l.slice[l.i] = s | |
563 | } | |
564 | ||
565 | // acePrefix is the ASCII Compatible Encoding prefix. | |
566 | const acePrefix = "xn--" | |
567 | ||
568 | func (p *Profile) simplify(cat category) category { | |
569 | switch cat { | |
570 | case disallowedSTD3Mapped: | |
571 | if p.useSTD3Rules { | |
572 | cat = disallowed | |
573 | } else { | |
574 | cat = mapped | |
575 | } | |
576 | case disallowedSTD3Valid: | |
577 | if p.useSTD3Rules { | |
578 | cat = disallowed | |
579 | } else { | |
580 | cat = valid | |
581 | } | |
582 | case deviation: | |
583 | if !p.transitional { | |
584 | cat = valid | |
585 | } | |
586 | case validNV8, validXV8: | |
587 | // TODO: handle V2008 | |
588 | cat = valid | |
589 | } | |
590 | return cat | |
591 | } | |
592 | ||
593 | func validateFromPunycode(p *Profile, s string) error { | |
594 | if !norm.NFC.IsNormalString(s) { | |
595 | return &labelError{s, "V1"} | |
596 | } | |
107c1cdb ND |
597 | // TODO: detect whether string may have to be normalized in the following |
598 | // loop. | |
15c0b25d AP |
599 | for i := 0; i < len(s); { |
600 | v, sz := trie.lookupString(s[i:]) | |
107c1cdb ND |
601 | if sz == 0 { |
602 | return runeError(utf8.RuneError) | |
603 | } | |
15c0b25d AP |
604 | if c := p.simplify(info(v).category()); c != valid && c != deviation { |
605 | return &labelError{s, "V6"} | |
606 | } | |
607 | i += sz | |
608 | } | |
609 | return nil | |
610 | } | |
611 | ||
612 | const ( | |
613 | zwnj = "\u200c" | |
614 | zwj = "\u200d" | |
615 | ) | |
616 | ||
617 | type joinState int8 | |
618 | ||
619 | const ( | |
620 | stateStart joinState = iota | |
621 | stateVirama | |
622 | stateBefore | |
623 | stateBeforeVirama | |
624 | stateAfter | |
625 | stateFAIL | |
626 | ) | |
627 | ||
628 | var joinStates = [][numJoinTypes]joinState{ | |
629 | stateStart: { | |
630 | joiningL: stateBefore, | |
631 | joiningD: stateBefore, | |
632 | joinZWNJ: stateFAIL, | |
633 | joinZWJ: stateFAIL, | |
634 | joinVirama: stateVirama, | |
635 | }, | |
636 | stateVirama: { | |
637 | joiningL: stateBefore, | |
638 | joiningD: stateBefore, | |
639 | }, | |
640 | stateBefore: { | |
641 | joiningL: stateBefore, | |
642 | joiningD: stateBefore, | |
643 | joiningT: stateBefore, | |
644 | joinZWNJ: stateAfter, | |
645 | joinZWJ: stateFAIL, | |
646 | joinVirama: stateBeforeVirama, | |
647 | }, | |
648 | stateBeforeVirama: { | |
649 | joiningL: stateBefore, | |
650 | joiningD: stateBefore, | |
651 | joiningT: stateBefore, | |
652 | }, | |
653 | stateAfter: { | |
654 | joiningL: stateFAIL, | |
655 | joiningD: stateBefore, | |
656 | joiningT: stateAfter, | |
657 | joiningR: stateStart, | |
658 | joinZWNJ: stateFAIL, | |
659 | joinZWJ: stateFAIL, | |
660 | joinVirama: stateAfter, // no-op as we can't accept joiners here | |
661 | }, | |
662 | stateFAIL: { | |
663 | 0: stateFAIL, | |
664 | joiningL: stateFAIL, | |
665 | joiningD: stateFAIL, | |
666 | joiningT: stateFAIL, | |
667 | joiningR: stateFAIL, | |
668 | joinZWNJ: stateFAIL, | |
669 | joinZWJ: stateFAIL, | |
670 | joinVirama: stateFAIL, | |
671 | }, | |
672 | } | |
673 | ||
674 | // validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are | |
675 | // already implicitly satisfied by the overall implementation. | |
107c1cdb | 676 | func (p *Profile) validateLabel(s string) (err error) { |
15c0b25d AP |
677 | if s == "" { |
678 | if p.verifyDNSLength { | |
679 | return &labelError{s, "A4"} | |
680 | } | |
681 | return nil | |
682 | } | |
15c0b25d AP |
683 | if !p.validateLabels { |
684 | return nil | |
685 | } | |
686 | trie := p.trie // p.validateLabels is only set if trie is set. | |
687 | if len(s) > 4 && s[2] == '-' && s[3] == '-' { | |
688 | return &labelError{s, "V2"} | |
689 | } | |
690 | if s[0] == '-' || s[len(s)-1] == '-' { | |
691 | return &labelError{s, "V3"} | |
692 | } | |
693 | // TODO: merge the use of this in the trie. | |
694 | v, sz := trie.lookupString(s) | |
695 | x := info(v) | |
696 | if x.isModifier() { | |
697 | return &labelError{s, "V5"} | |
698 | } | |
699 | // Quickly return in the absence of zero-width (non) joiners. | |
700 | if strings.Index(s, zwj) == -1 && strings.Index(s, zwnj) == -1 { | |
701 | return nil | |
702 | } | |
703 | st := stateStart | |
704 | for i := 0; ; { | |
705 | jt := x.joinType() | |
706 | if s[i:i+sz] == zwj { | |
707 | jt = joinZWJ | |
708 | } else if s[i:i+sz] == zwnj { | |
709 | jt = joinZWNJ | |
710 | } | |
711 | st = joinStates[st][jt] | |
712 | if x.isViramaModifier() { | |
713 | st = joinStates[st][joinVirama] | |
714 | } | |
715 | if i += sz; i == len(s) { | |
716 | break | |
717 | } | |
718 | v, sz = trie.lookupString(s[i:]) | |
719 | x = info(v) | |
720 | } | |
721 | if st == stateFAIL || st == stateAfter { | |
722 | return &labelError{s, "C"} | |
723 | } | |
724 | return nil | |
725 | } | |
726 | ||
727 | func ascii(s string) bool { | |
728 | for i := 0; i < len(s); i++ { | |
729 | if s[i] >= utf8.RuneSelf { | |
730 | return false | |
731 | } | |
732 | } | |
733 | return true | |
734 | } |