* path is just "\" and not "\example.com\root".
             */
            link = "\\";
        } else if (path.charAt(path.length() - 1) == '\\') {
            // strip trailing slash
            link = path.substring(0, path.length() - 1);
        } else {
            link = path;
        }

        if (log.isTraceEnabled()) {
            log.trace("Initial link is " + link);
        }

				// We may be in a situation where we have a directory and an object with the same name.
				// In that case we will drop the directory entry.
				// This should however not be confused with an object with a trailing slash.
				dirMatches := best.isDir() == other.isDir()
				suffixMatches := strings.HasSuffix(best.name, slashSeparator) == strings.HasSuffix(other.name, slashSeparator)

				// Simple case. Both are same type with same suffix.

		fi := v.h.FileInfo()
		h2, err := FileInfoHeader(fi, "")
		if err != nil {
			t.Error(err)
			continue
		}
		if strings.Contains(fi.Name(), "/") {
			t.Errorf("FileInfo of %q contains slash: %q", v.h.Name, fi.Name())
		}
		name := path.Base(v.h.Name)
		if fi.IsDir() {
			name += "/"
		}
		if got, want := h2.Name, name; got != want {
			t.Errorf("i=%d: Name: got %v, want %v", i, got, want)
		}

	BaseDir string

	// Scan/return only content with prefix.
	Prefix string

	// FilterPrefix will return only results with this prefix when scanning.
	// Should never contain a slash.
	// Prefix should still be set.
	FilterPrefix string

	// Marker to resume listing.
	// The response will be the first entry >= this object name.
	Marker string

	// Limit the number of results.
	Limit int

			}
			if gnuLongLink != "" {
				hdr.Linkname = gnuLongLink
			}
			if hdr.Typeflag == TypeRegA {
				if strings.HasSuffix(hdr.Name, "/") {
					hdr.Typeflag = TypeDir // Legacy archives use trailing slash for directories
				} else {
					hdr.Typeflag = TypeReg
				}
			}

			// The extended headers may have updated the size.
			// Thus, setup the regFileReader again after merging PAX headers.

	if xdir != ydir {
		return strings.Compare(xdir, ydir)
	}
	return strings.Compare(xelem, yelem)
}

// Open opens the named file in the ZIP archive,
// using the semantics of fs.FS.Open:
// paths are always slash separated, with no
// leading / or ../ elements.
func (r *Reader) Open(name string) (fs.File, error) {
	r.initFileList()

	if !fs.ValidPath(name) {

		objects = objects[:maxKeys]
		loi.IsTruncated = true
	}
	for _, obj := range objects {
		if obj.IsDir && obj.ModTime.IsZero() && delimiter != "" {
			// Only add each once.
			// With slash delimiter we only get the directory once.
			found := false
			if delimiter != slashSeparator {
				for _, p := range loi.Prefixes {
					if found {
						break
					}
					found = p == obj.Name

            log.debug("Resolving DFS path " + path);
        }

        if (path.length() >= 2 && path.charAt(0) == '\\' && path.charAt(1) == '\\') {
            throw new SmbException("Path must not start with double slash: " + path);
        }

        try (SmbSessionImpl sess = getSmbSession(ctx, targetHost, targetDomain);
                SmbTransportImpl transport = sess.getTransport();

 * to referencing files and directories, jCIFS can also address servers,
 * and workgroups.
 * <p>
 * <strong><i>Important: all SMB URLs that represent
 * workgroups, servers, shares, or directories require a trailing slash '/'.
 * </i></strong>
 * <p>
 * When using the {@code java.net.URL} class with
 * 'smb://' URLs it is necessary to first call the static
 * {@code jcifs.Config.registerSmbURLHandler();} method. This is required

				"GNU.sparse.major":    "1",
				"GNU.sparse.minor":    "0",
				"GNU.sparse.realsize": "1000",
				"GNU.sparse.name":     "sparse.db",
			},
			Format: FormatPAX,
		}},
	}, {
		file: "testdata/trailing-slash.tar",
		headers: []*Header{{
			Typeflag: TypeDir,
			Name:     strings.Repeat("123456789/", 30),
			ModTime:  time.Unix(0, 0),
			PAXRecords: map[string]string{
				"path": strings.Repeat("123456789/", 30),