Black Lives Matter. Support the Equal Justice Initiative.

Source file src/vendor/golang.org/x/net/idna/idna10.0.0.go

Documentation: vendor/golang.org/x/net/idna

     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  }
   735  

View as plain text