niki/vendor/golang.org/x/net/idna/idna10.0.0.go

// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.

// Copyright 2016 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

//go:build go1.10

// Package idna implements IDNA2008 using the compatibility processing

// defined by UTS (Unicode Technical Standard) #46, which defines a standard to

// deal with the transition from IDNA2003.

//

// IDNA2008 (Internationalized Domain Names for Applications), is defined in RFC

// 5890, RFC 5891, RFC 5892, RFC 5893 and RFC 5894.

// UTS #46 is defined in https://www.unicode.org/reports/tr46.

// See https://unicode.org/cldr/utility/idna.jsp for a visualization of the

// differences between these two standards.

package idna // import "golang.org/x/net/idna"

import (
	"fmt"
	"strings"
	"unicode/utf8"

	"golang.org/x/text/secure/bidirule"
	"golang.org/x/text/unicode/bidi"
	"golang.org/x/text/unicode/norm"
)

// NOTE: Unlike common practice in Go APIs, the functions will return a

// sanitized domain name in case of errors. Browsers sometimes use a partially

// evaluated string as lookup.

// TODO: the current error handling is, in my opinion, the least opinionated.

// Other strategies are also viable, though:

// Option 1) Return an empty string in case of error, but allow the user to

//    specify explicitly which errors to ignore.

// Option 2) Return the partially evaluated string if it is itself a valid

//    string, otherwise return the empty string in case of error.

// Option 3) Option 1 and 2.

// Option 4) Always return an empty string for now and implement Option 1 as

//    needed, and document that the return string may not be empty in case of

//    error in the future.

// I think Option 1 is best, but it is quite opinionated.

// ToASCII is a wrapper for Punycode.ToASCII.

func ToASCII(s string) (string, error) {

	return Punycode.process(s, true)

}

// ToUnicode is a wrapper for Punycode.ToUnicode.

func ToUnicode(s string) (string, error) {

	return Punycode.process(s, false)

}

// An Option configures a Profile at creation time.

type Option func(*options)

// Transitional sets a Profile to use the Transitional mapping as defined in UTS

// #46. This will cause, for example, "ß" to be mapped to "ss". Using the

// transitional mapping provides a compromise between IDNA2003 and IDNA2008

// compatibility. It is used by some browsers when resolving domain names. This

// option is only meaningful if combined with MapForLookup.

func Transitional(transitional bool) Option {

	return func(o *options) { o.transitional = transitional }

}

// VerifyDNSLength sets whether a Profile should fail if any of the IDN parts

// are longer than allowed by the RFC.

//

// This option corresponds to the VerifyDnsLength flag in UTS #46.

func VerifyDNSLength(verify bool) Option {

	return func(o *options) { o.verifyDNSLength = verify }

}

// RemoveLeadingDots removes leading label separators. Leading runes that map to

// dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.

func RemoveLeadingDots(remove bool) Option {

	return func(o *options) { o.removeLeadingDots = remove }

}

// ValidateLabels sets whether to check the mandatory label validation criteria

// as defined in Section 5.4 of RFC 5891. This includes testing for correct use

// of hyphens ('-'), normalization, validity of runes, and the context rules.

// In particular, ValidateLabels also sets the CheckHyphens and CheckJoiners flags

// in UTS #46.

func ValidateLabels(enable bool) Option {

	return func(o *options) {

		// Don't override existing mappings, but set one that at least checks

		// normalization if it is not set.

		if o.mapping == nil && enable {

			o.mapping = normalize

		}

		o.trie = trie

		o.checkJoiners = enable

		o.checkHyphens = enable

		if enable {

			o.fromPuny = validateFromPunycode

		} else {

			o.fromPuny = nil

		}

	}

}

// CheckHyphens sets whether to check for correct use of hyphens ('-') in

// labels. Most web browsers do not have this option set, since labels such as

// "r3---sn-apo3qvuoxuxbt-j5pe" are in common use.

//

// This option corresponds to the CheckHyphens flag in UTS #46.

func CheckHyphens(enable bool) Option {

	return func(o *options) { o.checkHyphens = enable }

}

// CheckJoiners sets whether to check the ContextJ rules as defined in Appendix

// A of RFC 5892, concerning the use of joiner runes.

//

// This option corresponds to the CheckJoiners flag in UTS #46.

func CheckJoiners(enable bool) Option {

	return func(o *options) {

		o.trie = trie

		o.checkJoiners = enable

	}

}

// StrictDomainName limits the set of permissible ASCII characters to those

// allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the

// hyphen). This is set by default for MapForLookup and ValidateForRegistration,

// but is only useful if ValidateLabels is set.

//

// This option is useful, for instance, for browsers that allow characters

// outside this range, for example a '_' (U+005F LOW LINE). See

// http://www.rfc-editor.org/std/std3.txt for more details.

//

// This option corresponds to the UseSTD3ASCIIRules flag in UTS #46.

func StrictDomainName(use bool) Option {

	return func(o *options) { o.useSTD3Rules = use }

}

// NOTE: the following options pull in tables. The tables should not be linked

// in as long as the options are not used.

// BidiRule enables the Bidi rule as defined in RFC 5893. Any application

// that relies on proper validation of labels should include this rule.

//

// This option corresponds to the CheckBidi flag in UTS #46.

func BidiRule() Option {

	return func(o *options) { o.bidirule = bidirule.ValidString }

}

// ValidateForRegistration sets validation options to verify that a given IDN is

// properly formatted for registration as defined by Section 4 of RFC 5891.

func ValidateForRegistration() Option {

	return func(o *options) {

		o.mapping = validateRegistration

		StrictDomainName(true)(o)

		ValidateLabels(true)(o)

		VerifyDNSLength(true)(o)

		BidiRule()(o)

	}

}

// MapForLookup sets validation and mapping options such that a given IDN is

// transformed for domain name lookup according to the requirements set out in

// Section 5 of RFC 5891. The mappings follow the recommendations of RFC 5894,

// RFC 5895 and UTS 46. It does not add the Bidi Rule. Use the BidiRule option

// to add this check.

//

// The mappings include normalization and mapping case, width and other

// compatibility mappings.

func MapForLookup() Option {

	return func(o *options) {

		o.mapping = validateAndMap

		StrictDomainName(true)(o)

		ValidateLabels(true)(o)

	}

}

type options struct {
	transitional bool

	useSTD3Rules bool

	checkHyphens bool

	checkJoiners bool

	verifyDNSLength bool

	removeLeadingDots bool

	trie *idnaTrie

	// fromPuny calls validation rules when converting A-labels to U-labels.

	fromPuny func(p *Profile, s string) error

	// mapping implements a validation and mapping step as defined in RFC 5895

	// or UTS 46, tailored to, for example, domain registration or lookup.

	mapping func(p *Profile, s string) (mapped string, isBidi bool, err error)

	// bidirule, if specified, checks whether s conforms to the Bidi Rule

	// defined in RFC 5893.

	bidirule func(s string) bool
}

// A Profile defines the configuration of an IDNA mapper.

type Profile struct {
	options
}

func apply(o *options, opts []Option) {

	for _, f := range opts {

		f(o)

	}

}

// New creates a new Profile.

//

// With no options, the returned Profile is the most permissive and equals the

// Punycode Profile. Options can be passed to further restrict the Profile. The

// MapForLookup and ValidateForRegistration options set a collection of options,

// for lookup and registration purposes respectively, which can be tailored by

// adding more fine-grained options, where later options override earlier

// options.

func New(o ...Option) *Profile {

	p := &Profile{}

	apply(&p.options, o)

	return p

}

// ToASCII converts a domain or domain label to its ASCII form. For example,

// ToASCII("bücher.example.com") is "xn--bcher-kva.example.com", and

// ToASCII("golang") is "golang". If an error is encountered it will return

// an error and a (partially) processed result.

func (p *Profile) ToASCII(s string) (string, error) {

	return p.process(s, true)

}

// ToUnicode converts a domain or domain label to its Unicode form. For example,

// ToUnicode("xn--bcher-kva.example.com") is "bücher.example.com", and

// ToUnicode("golang") is "golang". If an error is encountered it will return

// an error and a (partially) processed result.

func (p *Profile) ToUnicode(s string) (string, error) {

	pp := *p

	pp.transitional = false

	return pp.process(s, false)

}

// String reports a string with a description of the profile for debugging

// purposes. The string format may change with different versions.

func (p *Profile) String() string {

	s := ""

	if p.transitional {

		s = "Transitional"

	} else {

		s = "NonTransitional"

	}

	if p.useSTD3Rules {

		s += ":UseSTD3Rules"

	}

	if p.checkHyphens {

		s += ":CheckHyphens"

	}

	if p.checkJoiners {

		s += ":CheckJoiners"

	}

	if p.verifyDNSLength {

		s += ":VerifyDNSLength"

	}

	return s

}

var (

	// Punycode is a Profile that does raw punycode processing with a minimum

	// of validation.

	Punycode *Profile = punycode

	// Lookup is the recommended profile for looking up domain names, according

	// to Section 5 of RFC 5891. The exact configuration of this profile may

	// change over time.

	Lookup *Profile = lookup

	// Display is the recommended profile for displaying domain names.

	// The configuration of this profile may change over time.

	Display *Profile = display

	// Registration is the recommended profile for checking whether a given

	// IDN is valid for registration, according to Section 4 of RFC 5891.

	Registration *Profile = registration

	punycode = &Profile{}

	lookup = &Profile{options{

		transitional: transitionalLookup,

		useSTD3Rules: true,

		checkHyphens: true,

		checkJoiners: true,

		trie: trie,

		fromPuny: validateFromPunycode,

		mapping: validateAndMap,

		bidirule: bidirule.ValidString,
	}}

	display = &Profile{options{

		useSTD3Rules: true,

		checkHyphens: true,

		checkJoiners: true,

		trie: trie,

		fromPuny: validateFromPunycode,

		mapping: validateAndMap,

		bidirule: bidirule.ValidString,
	}}

	registration = &Profile{options{

		useSTD3Rules: true,

		verifyDNSLength: true,

		checkHyphens: true,

		checkJoiners: true,

		trie: trie,

		fromPuny: validateFromPunycode,

		mapping: validateRegistration,

		bidirule: bidirule.ValidString,
	}}

	// TODO: profiles

	// Register: recommended for approving domain names: don't do any mappings

	// but rather reject on invalid input. Bundle or block deviation characters.

)

type labelError struct{ label, code_ string }

func (e labelError) code() string { return e.code_ }

func (e labelError) Error() string {

	return fmt.Sprintf("idna: invalid label %q", e.label)

}

type runeError rune

func (e runeError) code() string { return "P1" }

func (e runeError) Error() string {

	return fmt.Sprintf("idna: disallowed rune %U", e)

}

// process implements the algorithm described in section 4 of UTS #46,

// see https://www.unicode.org/reports/tr46.

func (p *Profile) process(s string, toASCII bool) (string, error) {

	var err error

	var isBidi bool

	if p.mapping != nil {

		s, isBidi, err = p.mapping(p, s)

	}

	// Remove leading empty labels.

	if p.removeLeadingDots {

		for ; len(s) > 0 && s[0] == '.'; s = s[1:] {

		}

	}

	// TODO: allow for a quick check of the tables data.

	// It seems like we should only create this error on ToASCII, but the

	// UTS 46 conformance tests suggests we should always check this.

	if err == nil && p.verifyDNSLength && s == "" {

		err = &labelError{s, "A4"}

	}

	labels := labelIter{orig: s}

	for ; !labels.done(); labels.next() {

		label := labels.label()

		if label == "" {

			// Empty labels are not okay. The label iterator skips the last

			// label if it is empty.

			if err == nil && p.verifyDNSLength {

				err = &labelError{s, "A4"}

			}

			continue

		}

		if strings.HasPrefix(label, acePrefix) {

			u, err2 := decode(label[len(acePrefix):])

			if err2 != nil {

				if err == nil {

					err = err2

				}

				// Spec says keep the old label.

				continue

			}

			isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight

			labels.set(u)

			if err == nil && p.fromPuny != nil {

				err = p.fromPuny(p, u)

			}

			if err == nil {

				// This should be called on NonTransitional, according to the

				// spec, but that currently does not have any effect. Use the

				// original profile to preserve options.

				err = p.validateLabel(u)

			}

		} else if err == nil {

			err = p.validateLabel(label)

		}

	}

	if isBidi && p.bidirule != nil && err == nil {

		for labels.reset(); !labels.done(); labels.next() {

			if !p.bidirule(labels.label()) {

				err = &labelError{s, "B"}

				break

			}

		}

	}

	if toASCII {

		for labels.reset(); !labels.done(); labels.next() {

			label := labels.label()

			if !ascii(label) {

				a, err2 := encode(acePrefix, label)

				if err == nil {

					err = err2

				}

				label = a

				labels.set(a)

			}

			n := len(label)

			if p.verifyDNSLength && err == nil && (n == 0 || n > 63) {

				err = &labelError{label, "A4"}

			}

		}

	}

	s = labels.result()

	if toASCII && p.verifyDNSLength && err == nil {

		// Compute the length of the domain name minus the root label and its dot.

		n := len(s)

		if n > 0 && s[n-1] == '.' {

			n--

		}

		if len(s) < 1 || n > 253 {

			err = &labelError{s, "A4"}

		}

	}

	return s, err

}

func normalize(p *Profile, s string) (mapped string, isBidi bool, err error) {

	// TODO: consider first doing a quick check to see if any of these checks

	// need to be done. This will make it slower in the general case, but

	// faster in the common case.

	mapped = norm.NFC.String(s)

	isBidi = bidirule.DirectionString(mapped) == bidi.RightToLeft

	return mapped, isBidi, nil

}

func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error) {

	// TODO: filter need for normalization in loop below.

	if !norm.NFC.IsNormalString(s) {

		return s, false, &labelError{s, "V1"}

	}

	for i := 0; i < len(s); {

		v, sz := trie.lookupString(s[i:])

		if sz == 0 {

			return s, bidi, runeError(utf8.RuneError)

		}

		bidi = bidi || info(v).isBidi(s[i:])

		// Copy bytes not copied so far.

		switch p.simplify(info(v).category()) {

		// TODO: handle the NV8 defined in the Unicode idna data set to allow

		// for strict conformance to IDNA2008.

		case valid, deviation:

		case disallowed, mapped, unknown, ignored:

			r, _ := utf8.DecodeRuneInString(s[i:])

			return s, bidi, runeError(r)

		}

		i += sz

	}

	return s, bidi, nil

}

func (c info) isBidi(s string) bool {

	if !c.isMapped() {

		return c&attributesMask == rtl

	}

	// TODO: also store bidi info for mapped data. This is possible, but a bit

	// cumbersome and not for the common case.

	p, _ := bidi.LookupString(s)

	switch p.Class() {

	case bidi.R, bidi.AL, bidi.AN:

		return true

	}

	return false

}

func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error) {

	var (
		b []byte

		k int
	)

	// combinedInfoBits contains the or-ed bits of all runes. We use this

	// to derive the mayNeedNorm bit later. This may trigger normalization

	// overeagerly, but it will not do so in the common case. The end result

	// is another 10% saving on BenchmarkProfile for the common case.

	var combinedInfoBits info

	for i := 0; i < len(s); {

		v, sz := trie.lookupString(s[i:])

		if sz == 0 {

			b = append(b, s[k:i]...)

			b = append(b, "\ufffd"...)

			k = len(s)

			if err == nil {

				err = runeError(utf8.RuneError)

			}

			break

		}

		combinedInfoBits |= info(v)

		bidi = bidi || info(v).isBidi(s[i:])

		start := i

		i += sz

		// Copy bytes not copied so far.

		switch p.simplify(info(v).category()) {

		case valid:

			continue

		case disallowed:

			if err == nil {

				r, _ := utf8.DecodeRuneInString(s[start:])

				err = runeError(r)

			}

			continue

		case mapped, deviation:

			b = append(b, s[k:start]...)

			b = info(v).appendMapping(b, s[start:i])

		case ignored:

			b = append(b, s[k:start]...)

			// drop the rune

		case unknown:

			b = append(b, s[k:start]...)

			b = append(b, "\ufffd"...)

		}

		k = i

	}

	if k == 0 {

		// No changes so far.

		if combinedInfoBits&mayNeedNorm != 0 {

			s = norm.NFC.String(s)

		}

	} else {

		b = append(b, s[k:]...)

		if norm.NFC.QuickSpan(b) != len(b) {

			b = norm.NFC.Bytes(b)

		}

		// TODO: the punycode converters require strings as input.

		s = string(b)

	}

	return s, bidi, err

}

// A labelIter allows iterating over domain name labels.

type labelIter struct {
	orig string

	slice []string

	curStart int

	curEnd int

	i int
}

func (l *labelIter) reset() {

	l.curStart = 0

	l.curEnd = 0

	l.i = 0

}

func (l *labelIter) done() bool {

	return l.curStart >= len(l.orig)

}

func (l *labelIter) result() string {

	if l.slice != nil {

		return strings.Join(l.slice, ".")

	}

	return l.orig

}

func (l *labelIter) label() string {

	if l.slice != nil {

		return l.slice[l.i]

	}

	p := strings.IndexByte(l.orig[l.curStart:], '.')

	l.curEnd = l.curStart + p

	if p == -1 {

		l.curEnd = len(l.orig)

	}

	return l.orig[l.curStart:l.curEnd]

}

// next sets the value to the next label. It skips the last label if it is empty.

func (l *labelIter) next() {

	l.i++

	if l.slice != nil {

		if l.i >= len(l.slice) || l.i == len(l.slice)-1 && l.slice[l.i] == "" {

			l.curStart = len(l.orig)

		}

	} else {

		l.curStart = l.curEnd + 1

		if l.curStart == len(l.orig)-1 && l.orig[l.curStart] == '.' {

			l.curStart = len(l.orig)

		}

	}

}

func (l *labelIter) set(s string) {

	if l.slice == nil {

		l.slice = strings.Split(l.orig, ".")

	}

	l.slice[l.i] = s

}

// acePrefix is the ASCII Compatible Encoding prefix.

const acePrefix = "xn--"

func (p *Profile) simplify(cat category) category {

	switch cat {

	case disallowedSTD3Mapped:

		if p.useSTD3Rules {

			cat = disallowed

		} else {

			cat = mapped

		}

	case disallowedSTD3Valid:

		if p.useSTD3Rules {

			cat = disallowed

		} else {

			cat = valid

		}

	case deviation:

		if !p.transitional {

			cat = valid

		}

	case validNV8, validXV8:

		// TODO: handle V2008

		cat = valid

	}

	return cat

}

func validateFromPunycode(p *Profile, s string) error {

	if !norm.NFC.IsNormalString(s) {

		return &labelError{s, "V1"}

	}

	// TODO: detect whether string may have to be normalized in the following

	// loop.

	for i := 0; i < len(s); {

		v, sz := trie.lookupString(s[i:])

		if sz == 0 {

			return runeError(utf8.RuneError)

		}

		if c := p.simplify(info(v).category()); c != valid && c != deviation {

			return &labelError{s, "V6"}

		}

		i += sz

	}

	return nil

}

const (
	zwnj = "\u200c"

	zwj = "\u200d"
)

type joinState int8

const (
	stateStart joinState = iota

	stateVirama

	stateBefore

	stateBeforeVirama

	stateAfter

	stateFAIL
)

var joinStates = [][numJoinTypes]joinState{

	stateStart: {

		joiningL: stateBefore,

		joiningD: stateBefore,

		joinZWNJ: stateFAIL,

		joinZWJ: stateFAIL,

		joinVirama: stateVirama,
	},

	stateVirama: {

		joiningL: stateBefore,

		joiningD: stateBefore,
	},

	stateBefore: {

		joiningL: stateBefore,

		joiningD: stateBefore,

		joiningT: stateBefore,

		joinZWNJ: stateAfter,

		joinZWJ: stateFAIL,

		joinVirama: stateBeforeVirama,
	},

	stateBeforeVirama: {

		joiningL: stateBefore,

		joiningD: stateBefore,

		joiningT: stateBefore,
	},

	stateAfter: {

		joiningL: stateFAIL,

		joiningD: stateBefore,

		joiningT: stateAfter,

		joiningR: stateStart,

		joinZWNJ: stateFAIL,

		joinZWJ: stateFAIL,

		joinVirama: stateAfter, // no-op as we can't accept joiners here

	},

	stateFAIL: {

		0: stateFAIL,

		joiningL: stateFAIL,

		joiningD: stateFAIL,

		joiningT: stateFAIL,

		joiningR: stateFAIL,

		joinZWNJ: stateFAIL,

		joinZWJ: stateFAIL,

		joinVirama: stateFAIL,
	},
}

// validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are

// already implicitly satisfied by the overall implementation.

func (p *Profile) validateLabel(s string) (err error) {

	if s == "" {

		if p.verifyDNSLength {

			return &labelError{s, "A4"}

		}

		return nil

	}

	if p.checkHyphens {

		if len(s) > 4 && s[2] == '-' && s[3] == '-' {

			return &labelError{s, "V2"}

		}

		if s[0] == '-' || s[len(s)-1] == '-' {

			return &labelError{s, "V3"}

		}

	}

	if !p.checkJoiners {

		return nil

	}

	trie := p.trie // p.checkJoiners is only set if trie is set.

	// TODO: merge the use of this in the trie.

	v, sz := trie.lookupString(s)

	x := info(v)

	if x.isModifier() {

		return &labelError{s, "V5"}

	}

	// Quickly return in the absence of zero-width (non) joiners.

	if strings.Index(s, zwj) == -1 && strings.Index(s, zwnj) == -1 {

		return nil

	}

	st := stateStart

	for i := 0; ; {

		jt := x.joinType()

		if s[i:i+sz] == zwj {

			jt = joinZWJ

		} else if s[i:i+sz] == zwnj {

			jt = joinZWNJ

		}

		st = joinStates[st][jt]

		if x.isViramaModifier() {

			st = joinStates[st][joinVirama]

		}

		if i += sz; i == len(s) {

			break

		}

		v, sz = trie.lookupString(s[i:])

		x = info(v)

	}

	if st == stateFAIL || st == stateAfter {

		return &labelError{s, "C"}

	}

	return nil

}

func ascii(s string) bool {

	for i := 0; i < len(s); i++ {

		if s[i] >= utf8.RuneSelf {

			return false

		}

	}

	return true

}