75,051 matches across 25 files for func main lang:Go
snippet_mode: auto · sorted by relevance
3// license that can be found in the LICENSE file.
4
5▶// Package modload provides module and package loading functionality.
6package modload
7
· · ·
40// TODO(#40775): See if these can be plumbed as explicit parameters.
41var (
42▶ // ExplicitWriteGoMod prevents LoadPackages, ListModules, and other functions
43 // from updating go.mod and go.sum or reporting errors when updates are
44 // needed. A package should set this if it would cause go.mod to be written
· · ·
58// NewForModroot creates a new module loader in single-module mode for the module at
59// the given modroot..
60▶func NewForModroot(ctx context.Context, modroot string) *Loader {
61 ld := NewLoader()
62 ld.modRoots = []string{modroot}
· · ·
66
67// NewForWorkspace creates a new loader for workspace mode from the given module mode loader ld,
68▶// applying ld's updated requirements to the main module to the corresponding module in the workspace.
69func (ld *Loader) NewForWorkspace(ctx context.Context) (*Loader, error) {
70 // Find the identity of the main module that will be updated before we reset modload state.
· · ·
69▶func (ld *Loader) NewForWorkspace(ctx context.Context) (*Loader, error) {
70 // Find the identity of the main module that will be updated before we reset modload state.
71 mm := ld.MainModules.mustGetSingleMainModule(ld)
+ 211 more matches in this file
26// The scheduler's job is to distribute ready-to-run goroutines over worker threads.
27//
28▶// The main concepts are:
29// G - goroutine.
30// M - worker thread, or machine.
· · ·
84// utilization.
85//
86▶// The main implementation complication is that we need to be very careful
87// during spinning->non-spinning thread transition. This transition can race
88// with submission of new work, and either one part or another needs to unpark
· · ·
129var runtime_inittasks []*initTask
130
131▶// mainInitDone is a signal used by cgocallbackg that initialization
132// has been completed. If this is false, wait on mainInitDoneChan.
133var mainInitDone atomic.Bool
· · ·
132▶// has been completed. If this is false, wait on mainInitDoneChan.
133var mainInitDone atomic.Bool
134
· · ·
133▶var mainInitDone atomic.Bool
134
135// mainInitDoneChan is closed after initialization has been completed.
+ 390 more matches in this file
30)
31
32▶func (b branch) String() string {
33 switch b {
34 case unknown:
· · ·
76}
77
78▶func (r relation) String() string {
79 if r < relation(len(relationStrings)) {
80 return relationStrings[r]
· · ·
83}
84
85▶// domain represents the domain of a variable pair in which a set
86// of relations is known. For example, relations learned for unsigned
87// pairs cannot be transferred to signed pairs because the same bit
· · ·
88// representation can mean something else.
89▶type domain uint
90
91const (
· · ·
92▶ signed domain = 1 << iota
93 unsigned
94 pointer
+ 130 more matches in this file
69// from newer pre-release or development versions.
70//
71▶// The allowed function (which may be nil) is used to filter out unsuitable
72// versions (see AllowedFunc documentation for details). If the query refers to
73// a specific revision (for example, "master"; see IsRevisionQuery), and the
· · ·
72▶// versions (see AllowedFunc documentation for details). If the query refers to
73// a specific revision (for example, "master"; see IsRevisionQuery), and the
74// revision is disallowed by allowed, Query returns the error. If the query
· · ·
76// acts as if versions disallowed by allowed do not exist.
77//
78▶// If path is the path of the main module and the query is "latest",
79// Query returns Target.Version as the version.
80//
· · ·
81// Query often returns a non-nil *RevInfo with a non-nil error,
82// to provide an info.Origin that can allow the error to be cached.
83▶func Query(ld *Loader, ctx context.Context, path, query, current string, allowed AllowedFunc) (*modfetch.RevInfo, error) {
84 ctx, span := trace.StartSpan(ctx, "modload.Query "+path)
85 defer span.Done()
· · ·
90// queryReuse is like Query but also takes a map of module info that can be reused
91// if the validation criteria in Origin are met.
92▶func queryReuse(ld *Loader, ctx context.Context, path, query, current string, allowed AllowedFunc, reuse map[module.Version]*modinfo.ModulePublic) (*modfetch.RevInfo, error) {
93 var info *modfetch.RevInfo
94 err := modfetch.TryProxies(func(proxy string) (err error) {
+ 141 more matches in this file
6
7// This file contains the module-mode package loader, as well as some accessory
8▶// functions pertaining to the package import graph.
9//
10// There are two exported entry points into package loading — LoadPackages and
· · ·
12// manipulates an instance of the loader struct.
13//
14▶// Although most of the loading state is maintained in the loader struct,
15// one key piece - the build list - is a global, so that it can be modified
16// separate from the loading operation, such as during "go get"
· · ·
28// computed from the package import graph, and therefore cannot be an initial
29// input to loading that graph. Instead, the root packages for the "all" pattern
30▶// are those contained in the main module, and allPatternIsRoot parameter to the
31// loader instructs it to dynamically expand those roots to the full "all"
32// pattern as loading progresses.
· · ·
35// package is known to match the "all" meta-pattern.
36// A package matches the "all" pattern if:
37▶// - it is in the main module, or
38// - it is imported by any test in the main module, or
39// - it is imported by a tool of the main module, or
· · ·
38▶// - it is imported by any test in the main module, or
39// - it is imported by a tool of the main module, or
40// - it is imported by another package in "all", or
+ 139 more matches in this file
136 Long: `
137The go command can run version control commands like git
138▶to download imported code. This functionality is critical to the decentralized
139Go package ecosystem, in which code can be imported from any server,
140but it is also a potential security problem, if a malicious server finds a
· · ·
141way to cause the invoked version control command to run unintended code.
142
143▶To balance the functionality and security concerns, the go command
144by default will only use git and hg to download code from public servers.
145But it will use any known version control system (fossil, git, hg, svn)
· · ·
227}
228
229▶func (*upgradeFlag) IsBoolFlag() bool { return true } // allow -u
230
231func (v *upgradeFlag) Set(s string) error {
· · ·
231▶func (v *upgradeFlag) Set(s string) error {
232 if s == "false" {
233 v.version = ""
· · ·
243}
244
245▶func (v *upgradeFlag) String() string { return "" }
246
247// dFlag is a custom flag.Value for the deprecated -d flag
+ 134 more matches in this file
5// Package testing provides support for automated testing of Go packages.
6// It is intended to be used in concert with the "go test" command, which automates
7▶// execution of any function of the form
8//
9// func TestXxx(*testing.T)
· · ·
9▶// func TestXxx(*testing.T)
10//
11// where Xxx does not start with a lowercase letter. The function name
· · ·
11▶// where Xxx does not start with a lowercase letter. The function name
12// serves to identify the test routine.
13//
· · ·
14▶// Within these functions, use [T.Error], [T.Fail] or related methods to signal failure.
15//
16// To write a new test suite, create a file that
· · ·
17▶// contains the TestXxx functions as described here,
18// and give that file a name ending in "_test.go".
19// The file will be excluded from regular
+ 286 more matches in this file
74// Hook points used for testing.
75// Outside of tests, t.transportTestHooks is nil and these all have minimal implementations.
76▶// Inside tests, see the testSyncHooks function docs.
77
78type transportTestHooks struct {
· · ·
79▶ newclientconn func(*ClientConn)
80}
81
· · ·
82▶func (t *Transport) maxHeaderListSize() uint32 {
83 n := t.t1.MaxHeaderListSize()
84 if b := t.t1.MaxResponseHeaderBytes(); b != 0 {
· · ·
97}
98
99▶func (t *Transport) disableCompression() bool {
100 return t.t1 != nil && t.t1.DisableCompression()
101}
· · ·
102
103▶func NewTransport(t1 TransportConfig) *Transport {
104 connPool := new(clientConnPool)
105 t2 := &Transport{
+ 189 more matches in this file
85 Incomplete bool `json:",omitempty"` // was there an error loading this package or dependencies?
86
87▶ DefaultGODEBUG string `json:",omitempty"` // default GODEBUG setting (only for Name=="main")
88
89 // Stale and StaleReason remain here *only* for the list command.
· · ·
89▶ // Stale and StaleReason remain here *only* for the list command.
90 // They are only initialized in preparation for list execution.
91 // The regular build determines staleness on the fly during action execution.
· · ·
152// The go/build package filtered others out (like foo_wrongGOARCH.s)
153// and that's OK.
154▶func (p *Package) AllFiles() []string {
155 files := str.StringList(
156 p.GoFiles,
· · ·
196
197// Desc returns the package "description", for use in b.showOutput.
198▶func (p *Package) Desc() string {
199 if p.ForTest != "" {
200 return p.ImportPath + " [" + p.ForTest + ".test]"
· · ·
201 }
202▶ if p.Internal.ForMain != "" {
203 return p.ImportPath + " [" + p.Internal.ForMain + "]"
204 }
+ 221 more matches in this file
45 // rootModules is the set of root modules of the graph, sorted and capped to
46 // length. It may contain duplicates, and may contain multiple versions for a
47▶ // given module path. The root modules of the graph are the set of main
48 // modules in workspace mode, and the main module's direct requirements
49 // outside workspace mode.
· · ·
48▶ // modules in workspace mode, and the main module's direct requirements
49 // outside workspace mode.
50 //
· · ·
55
56 // direct is the set of module paths for which we believe the module provides
57▶ // a package directly imported by a package or test in the main module.
58 //
59 // The "direct" map controls which modules are annotated with "// indirect"
· · ·
69 //
70 // The direct map is keyed by module paths, not module versions. When a
71▶ // module's selected version changes, we assume that it remains direct if the
72 // previous version was a direct dependency. That assumption might not hold in
73 // rare cases (such as if a dependency splits out a nested module, or merges a
· · ·
86}
87
88▶func mustHaveGoRoot(roots []module.Version) {
89 for _, m := range roots {
90 if m.Path == "go" {
+ 110 more matches in this file
35// isPrintable reports whether the given b is in the ASN.1 PrintableString set.
36// This is a simplified version of encoding/asn1.isPrintable.
37▶func isPrintable(b byte) bool {
38 return 'a' <= b && b <= 'z' ||
39 'A' <= b && b <= 'Z' ||
· · ·
60// from the respective encoding/asn1.parse... methods, rather than just
61// increasing the API surface of that package.
62▶func parseASN1String(tag cryptobyte_asn1.Tag, value []byte) (string, error) {
63 switch tag {
64 case cryptobyte_asn1.T61String:
· · ·
65▶ // T.61 is a defunct ITU 8-bit character encoding which preceded Unicode.
66 // T.61 uses a code page layout that _almost_ exactly maps to the code
67 // page layout of the ISO 8859-1 (Latin-1) character encoding, with the
· · ·
91 return string(value), nil
92 case cryptobyte_asn1.Tag(asn1.TagBMPString):
93▶ // BMPString uses the defunct UCS-2 16-bit character encoding, which
94 // covers the Basic Multilingual Plane (BMP). UTF-16 was an extension of
95 // UCS-2, containing all of the same code points, but also including
· · ·
142
143// readASN1Any parses types documented at [pkix.AttributeTypeAndValue].
144▶func readASN1Any(der *cryptobyte.String) (any, error) {
145 var fullValue cryptobyte.String
146 var valueTag cryptobyte_asn1.Tag
+ 48 more matches in this file
30// ReadModFile reads and parses the mod file at gomod. ReadModFile properly applies the
31// overlay, locks the file while reading, and applies fix, if applicable.
32▶func ReadModFile(gomod string, fix modfile.VersionFixer) (data []byte, f *modfile.File, err error) {
33 if fsys.Replaced(gomod) {
34 // Don't lock go.mod if it's part of the overlay.
· · ·
76}
77
78▶func shortPathErrorList(err error) error {
79 if el, ok := errors.AsType[modfile.ErrorList](err); ok {
80 for i := range el {
· · ·
114)
115
116▶func (p modPruning) String() string {
117 switch p {
118 case pruned:
· · ·
127}
128
129▶func pruningForGoVersion(goVersion string) modPruning {
130 if gover.Compare(goVersion, gover.ExplicitIndirectVersion) < 0 {
131 // The go.mod file does not duplicate relevant information about transitive
· · ·
137
138// CheckAllowed returns an error equivalent to ErrDisallowed if m is excluded by
139▶// the main module's go.mod or retracted by its author. Most version queries use
140// this to filter out versions that should not be used.
141func (ld *Loader) CheckAllowed(ctx context.Context, m module.Version) error {
+ 62 more matches in this file
146 // If WriteHeader is not called explicitly, the first call to Write
147 // will trigger an implicit WriteHeader(http.StatusOK).
148▶ // Thus explicit calls to WriteHeader are mainly used to
149 // send error codes or 1xx informational responses.
150 //
· · ·
202 //
203 // After a call to Hijack, the original Request.Body must not
204▶ // be used. The original Request's Context remains valid and
205 // is not canceled until the Request's ServeHTTP method
206 // returns.
· · ·
259
260 // cancelCtx cancels the connection-level context.
261▶ cancelCtx context.CancelFunc
262
263 // rwc is the underlying network connection.
· · ·
283 // r is bufr's read source. It's a wrapper around rwc that provides
284 // io.LimitedReader-style limiting (while reading request headers)
285▶ // and functionality to support CloseNotifier. See *connReader docs.
286 r *connReader
287
· · ·
309}
310
311▶func (c *conn) hijacked() bool {
312 c.mu.Lock()
313 defer c.mu.Unlock()
+ 238 more matches in this file
74//
75// This kind of key is commonly encoded in PEM blocks of type "PUBLIC KEY".
76▶func ParsePKIXPublicKey(derBytes []byte) (pub any, err error) {
77 var pki publicKeyInfo
78 if rest, err := asn1.Unmarshal(derBytes, &pki); err != nil {
· · ·
87}
88
89▶func marshalPublicKey(pub any) (publicKeyBytes []byte, publicKeyAlgorithm pkix.AlgorithmIdentifier, err error) {
90 switch pub := pub.(type) {
91 case *rsa.PublicKey:
· · ·
167//
168// This kind of key is commonly encoded in PEM blocks of type "PUBLIC KEY".
169▶func MarshalPKIXPublicKey(pub any) ([]byte, error) {
170 var publicKeyBytes []byte
171 var publicKeyAlgorithm pkix.AlgorithmIdentifier
· · ·
255)
256
257▶func (algo SignatureAlgorithm) isRSAPSS() bool {
258 for _, details := range signatureAlgorithmDetails {
259 if details.algo == algo {
· · ·
264}
265
266▶func (algo SignatureAlgorithm) hashFunc() crypto.Hash {
267 for _, details := range signatureAlgorithmDetails {
268 if details.algo == algo {
+ 106 more matches in this file
37
38// NewReader creates a new [Reader] reading from r.
39▶func NewReader(r io.Reader) *Reader {
40 return &Reader{r: r, curr: ®FileReader{r, 0}}
41}
· · ·
43// Next advances to the next entry in the tar archive.
44// The Header.Size determines how many bytes can be read for the next file.
45▶// Any remaining data in the current file is automatically discarded.
46// At the end of the archive, Next returns the error io.EOF.
47//
· · ·
53// Programs that want to accept non-local names can ignore
54// the [ErrInsecurePath] error and use the returned header.
55▶func (tr *Reader) Next() (*Header, error) {
56 if tr.err != nil {
57 return nil, tr.err
· · ·
68}
69
70▶func (tr *Reader) next() (*Header, error) {
71 var paxHdrs map[string]string
72 var gnuLongName, gnuLongLink string
· · ·
79 format := FormatUSTAR | FormatPAX | FormatGNU
80 for {
81▶ // Discard the remainder of the file and any padding.
82 if err := discard(tr.r, tr.curr.physicalRemaining()); err != nil {
83 return nil, err
+ 46 more matches in this file
40var services = map[string]map[string]int{
41 "udp": {
42▶ "domain": 53,
43 },
44 "tcp": {
· · ·
66const maxProtoLength = len("RSVP-E2E-IGNORE") + 10 // with room to grow
67
68▶func lookupProtocolMap(name string) (int, error) {
69 var lowerProtocol [maxProtoLength]byte
70 n := copy(lowerProtocol[:], name)
· · ·
84const maxPortBufSize = len("mobility-header") + 10
85
86▶func lookupPortMap(network, service string) (port int, error error) {
87 switch network {
88 case "ip": // no hints
· · ·
99}
100
101▶func lookupPortMapWithNetwork(network, errNetwork, service string) (port int, error error) {
102 if m, ok := services[network]; ok {
103 var lowerService [maxPortBufSize]byte
· · ·
114// ipVersion returns the provided network's IP version: '4', '6' or 0
115// if network does not end in a '4' or '6' byte.
116▶func ipVersion(network string) byte {
117 if network == "" {
118 return 0
+ 76 more matches in this file
36 allowMissingModuleImports bool
37
38▶ // modRoot is dependent on the value of ImportingMainModule and should be
39 // kept in sync.
40 modRoot string
· · ·
41▶ ImportingMainModule module.Version
42
43 // isStd indicates whether we would expect to find the package in the standard
· · ·
60}
61
62▶func (e *ImportMissingError) Error() string {
63 if e.Module.Path == "" {
64 if e.isStd {
· · ·
88 return fmt.Sprintf("%s: %v", message, e.QueryErr)
89 }
90▶ if e.ImportingMainModule.Path != "" && e.ImportingMainModule != e.modContainingCWD {
91 return fmt.Sprintf("%s; to add it:\n\tcd %s\n\tgo get %s", message, e.modRoot, e.Path)
92 }
· · ·
101}
102
103▶func (e *ImportMissingError) Unwrap() error {
104 return e.QueryErr
105}
+ 59 more matches in this file
55// actionList returns the list of actions in the dag rooted at root
56// as visited in a depth-first post-order traversal.
57▶func actionList(root *Action) []*Action {
58 seen := map[*Action]bool{}
59 all := []*Action{}
· · ·
60▶ var walk func(*Action)
61 walk = func(a *Action) {
62 if seen[a] {
· · ·
61▶ walk = func(a *Action) {
62 if seen[a] {
63 return
· · ·
74
75// Do runs the action graph rooted at root.
76▶func (b *Builder) Do(ctx context.Context, root *Action) {
77 ctx, span := trace.StartSpan(ctx, "exec.Builder.Do ("+root.Mode+" "+root.Target+")")
78 defer span.Done()
· · ·
81 // If we're doing real work, take time at the end to trim the cache.
82 c := cache.Default()
83▶ defer func() {
84 if err := c.Close(); err != nil {
85 base.Fatalf("go: failed to trim cache: %v", err)
+ 141 more matches in this file
15)
16
17▶func isDomainJoined() (bool, error) {
18 var domain *uint16
19 var status uint32
· · ·
18▶ var domain *uint16
19 var status uint32
20 err := syscall.NetGetJoinInformation(nil, &domain, &status)
· · ·
20▶ err := syscall.NetGetJoinInformation(nil, &domain, &status)
21 if err != nil {
22 return false, err
· · ·
23 }
24▶ syscall.NetApiBufferFree((*byte)(unsafe.Pointer(domain)))
25 return status == syscall.NetSetupDomainName, nil
26}
· · ·
25▶ return status == syscall.NetSetupDomainName, nil
26}
27
+ 66 more matches in this file
17)
18
19▶// A declInfo describes a package-level const, type, var, or func declaration.
20type declInfo struct {
21 file *Scope // scope of file containing this declaration
· · ·
26 inherited bool // if set, the init expression is inherited from a previous constant declaration
27 tdecl *syntax.TypeDecl // type declaration, or nil
28▶ fdecl *syntax.FuncDecl // func declaration, or nil
29
30 // The deps field tracks initialization expression dependencies.
· · ·
33
34// hasInitializer reports whether the declared object has an initialization
35▶// expression or function body.
36func (d *declInfo) hasInitializer() bool {
37 return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
· · ·
36▶func (d *declInfo) hasInitializer() bool {
37 return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
38}
· · ·
39
40// addDep adds obj to the set of objects d's init expression depends on.
41▶func (d *declInfo) addDep(obj Object) {
42 m := d.deps
43 if m == nil {
+ 43 more matches in this file
23)
24
25▶// PublicSuffixList provides the public suffix of a domain. For example:
26// - the public suffix of "example.com" is "com",
27// - the public suffix of "foo1.foo2.foo3.co.uk" is "co.uk", and
· · ·
38// [golang.org/x/net/publicsuffix].
39type PublicSuffixList interface {
40▶ // PublicSuffix returns the public suffix of domain.
41 //
42 // TODO: specify which of the caller and callee is responsible for IP
· · ·
43 // addresses, for leading and trailing dots, for case sensitivity, and
44 // for IDN/Punycode.
45▶ PublicSuffix(domain string) string
46
47 // String returns a description of the source of this public suffix
· · ·
54type Options struct {
55 // PublicSuffixList is the public suffix list that determines whether
56▶ // an HTTP server can set a cookie for a domain.
57 //
58 // A nil value is valid and may be useful for testing but it is not
· · ·
66 psList PublicSuffixList
67
68▶ // mu locks the remaining fields.
69 mu sync.Mutex
70
+ 73 more matches in this file
18)
19
20▶// A declInfo describes a package-level const, type, var, or func declaration.
21type declInfo struct {
22 file *Scope // scope of file containing this declaration
· · ·
27 inherited bool // if set, the init expression is inherited from a previous constant declaration
28 tdecl *ast.TypeSpec // type declaration, or nil
29▶ fdecl *ast.FuncDecl // func declaration, or nil
30
31 // The deps field tracks initialization expression dependencies.
· · ·
34
35// hasInitializer reports whether the declared object has an initialization
36▶// expression or function body.
37func (d *declInfo) hasInitializer() bool {
38 return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
· · ·
37▶func (d *declInfo) hasInitializer() bool {
38 return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
39}
· · ·
40
41// addDep adds obj to the set of objects d's init expression depends on.
42▶func (d *declInfo) addDep(obj Object) {
43 m := d.deps
44 if m == nil {
+ 44 more matches in this file
37type debugT bool
38
39▶func (d debugT) Printf(format string, args ...any) {
40 if d {
41 log.Printf(format, args...)
· · ·
52// The headers are parsed, and the body of the message will be available
53// for reading from msg.Body.
54▶func ReadMessage(r io.Reader) (msg *Message, err error) {
55 tp := textproto.NewReader(bufio.NewReader(r))
56
· · ·
71// restrictions of RFC 7230.
72// This package implements RFC 5322, which does not have those restrictions.
73▶// This function copies the relevant code from net/textproto,
74// simplified for RFC 5322.
75func readHeader(r *textproto.Reader) (map[string][]string, error) {
· · ·
75▶func readHeader(r *textproto.Reader) (map[string][]string, error) {
76 m := make(map[string][]string)
77
· · ·
116// Layouts suitable for passing to time.Parse.
117// These are tried in order.
118▶var dateLayouts = sync.OnceValue(func() []string {
119 // Generate layouts based on RFC 5322, section 3.3.
120
+ 63 more matches in this file
78 Match []string // command-line patterns matching this package
79 DepOnly bool // package is only a dependency, not explicitly listed
80▶ DefaultGODEBUG string // default GODEBUG setting, for main packages
81
82 // Source files
· · ·
144of list -m below.
145
146▶The template function "join" calls strings.Join.
147
148The template function "json" marshals its arguments to JSON.
· · ·
148▶The template function "json" marshals its arguments to JSON.
149
150The template function "context" returns the build context, defined as:
· · ·
150▶The template function "context" returns the build context, defined as:
151
152 type Context struct {
· · ·
164 }
165
166▶The template function "module" takes a module path as a parameter,
167and returns information about the module, defined as the Module struct below.
168
+ 50 more matches in this file
15)
16
17▶// This file contains the data structures and functions necessary for
18// efficiently checking X.509 name constraints. The method for constraint
19// checking implemented in this file is based on a technique originally
· · ·
57// Email addresses also require some additional logic, which does not make use
58// of nameConstraintsSet, to handle constraints which define full email
59▶// addresses (i.e. 'test@example.com'). For bare domain constraints, we use the
60// dnsConstraints type described above, querying the domain portion of the email
61// address. For full email addresses, we also hold a map of email addresses with
· · ·
60▶// dnsConstraints type described above, querying the domain portion of the email
61// address. For full email addresses, we also hold a map of email addresses with
62// the domain portion of the email lowercased, since it is case insensitive. When
· · ·
62▶// the domain portion of the email lowercased, since it is case insensitive. When
63// looking up an email address in the constraint set, we first check the full
64// email address map, and if we don't find anything, we check the domain portion
· · ·
64▶// email address map, and if we don't find anything, we check the domain portion
65// of the email address against the dnsConstraints.
66
+ 50 more matches in this file