Matteo Scandolo | a428586 | 2020-12-01 18:10:10 -0800 | [diff] [blame^] | 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 | |
| 7 | // +build go1.10 |
| 8 | |
| 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. |
| 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 |
| 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" |
| 26 | "golang.org/x/text/unicode/bidi" |
| 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 |
| 74 | // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well. |
| 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 | |
| 98 | // StrictDomainName limits the set of permissible ASCII characters to those |
| 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) |
| 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. |
| 165 | mapping func(p *Profile, s string) (mapped string, isBidi bool, err error) |
| 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{ |
| 256 | transitional: true, |
| 257 | useSTD3Rules: true, |
| 258 | validateLabels: true, |
| 259 | trie: trie, |
| 260 | fromPuny: validateFromPunycode, |
| 261 | mapping: validateAndMap, |
| 262 | bidirule: bidirule.ValidString, |
| 263 | }} |
| 264 | display = &Profile{options{ |
| 265 | useSTD3Rules: true, |
| 266 | validateLabels: true, |
| 267 | trie: trie, |
| 268 | fromPuny: validateFromPunycode, |
| 269 | mapping: validateAndMap, |
| 270 | bidirule: bidirule.ValidString, |
| 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, |
| 302 | // see https://www.unicode.org/reports/tr46. |
| 303 | func (p *Profile) process(s string, toASCII bool) (string, error) { |
| 304 | var err error |
| 305 | var isBidi bool |
| 306 | if p.mapping != nil { |
| 307 | s, isBidi, err = p.mapping(p, s) |
| 308 | } |
| 309 | // Remove leading empty labels. |
| 310 | if p.removeLeadingDots { |
| 311 | for ; len(s) > 0 && s[0] == '.'; s = s[1:] { |
| 312 | } |
| 313 | } |
| 314 | // TODO: allow for a quick check of the tables data. |
| 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 | } |
| 340 | isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight |
| 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 | } |
| 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 | } |
| 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 | |
| 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 |
| 401 | } |
| 402 | |
| 403 | func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error) { |
| 404 | // TODO: filter need for normalization in loop below. |
| 405 | if !norm.NFC.IsNormalString(s) { |
| 406 | return s, false, &labelError{s, "V1"} |
| 407 | } |
| 408 | for i := 0; i < len(s); { |
| 409 | v, sz := trie.lookupString(s[i:]) |
| 410 | if sz == 0 { |
| 411 | return s, bidi, runeError(utf8.RuneError) |
| 412 | } |
| 413 | bidi = bidi || info(v).isBidi(s[i:]) |
| 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:]) |
| 421 | return s, bidi, runeError(r) |
| 422 | } |
| 423 | i += sz |
| 424 | } |
| 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 |
| 440 | } |
| 441 | |
| 442 | func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error) { |
| 443 | var ( |
| 444 | b []byte |
| 445 | k int |
| 446 | ) |
| 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 |
| 452 | for i := 0; i < len(s); { |
| 453 | v, sz := trie.lookupString(s[i:]) |
| 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:]) |
| 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. |
| 491 | if combinedInfoBits&mayNeedNorm != 0 { |
| 492 | s = norm.NFC.String(s) |
| 493 | } |
| 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 | } |
| 502 | return s, bidi, err |
| 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 | } |
| 597 | // TODO: detect whether string may have to be normalized in the following |
| 598 | // loop. |
| 599 | for i := 0; i < len(s); { |
| 600 | v, sz := trie.lookupString(s[i:]) |
| 601 | if sz == 0 { |
| 602 | return runeError(utf8.RuneError) |
| 603 | } |
| 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. |
| 676 | func (p *Profile) validateLabel(s string) (err error) { |
| 677 | if s == "" { |
| 678 | if p.verifyDNSLength { |
| 679 | return &labelError{s, "A4"} |
| 680 | } |
| 681 | return nil |
| 682 | } |
| 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 | } |