package main

func gettid() int {
	return 0
}

func tidExists(tid int) (exists, supported bool, err error) {
	return false, false, nil
}

func getcwd() (string, error) {
	return "", nil
}

func unshareFs() error {
	return nil
}

func chdir(path string) error {
	return nil

	// This is imperative for checking for OS thread state
	// after an unshare since os.Getwd might just check the
	// environment, or use some other mechanism.
	var buf [4096]byte
	n, err := syscall.Getcwd(buf[:])
	if err != nil {
		return "", err
	}
	// Subtract one for null terminator.
	return string(buf[:n-1]), nil
}

func unshareFs() error {
	err := syscall.Unshare(syscall.CLONE_FS)
	if testenv.SyscallIsNotSupported(err) {

		runtime.LockOSThread()

		// Unshare details about the FS, like the CWD, with
		// the rest of the process on this thread.
		// On systems other than Linux, this is a no-op.
		if err := unshareFs(); err != nil {
			if err == errNotPermitted {
				println("unshare not permitted")
				os.Exit(0)
			}
			println("failed to unshare fs:", err.Error())
			os.Exit(1)
		}

		}
		t.Fatalf("unshare failed: %v\n%s", err, out)
	} else if len(out) != 0 {
		if bytes.HasPrefix(out, []byte(mountNotSupported)) {
			t.Skipf("skipping: helper process reported %s", out)
		}
		t.Fatalf("unexpected output from helper process: %s", out)
	}

	// How do we tell if the namespace was really unshared? It turns out

				goto childerror
			}
		}

		// The unshare system call in Linux doesn't unshare mount points
		// mounted with --shared. Systemd mounts / with --shared. For a
		// long discussion of the pros and cons of this see debian bug 739593.
		// The Go model of unsharing is more like Plan 9, where you ask
		// to unshare and the namespaces are unconditionally unshared.
		// To make this model work we must further mark / as MS_PRIVATE.

package dependencies

import (
	"testing"

	// Create a new network namespace. This will have the 'lo' interface ready but nothing else.
	_ "github.com/howardjohn/unshare-go/netns"
	// Create a new user namespace. This will map the current UID to 0.
	_ "github.com/howardjohn/unshare-go/userns"
	"github.com/vishvananda/netns"

	"istio.io/istio/pkg/test/util/assert"
	"istio.io/istio/pkg/test/util/file"
)

    /**
     * Get transport connection
     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport ( CIFSContext tc, Address address, int port, boolean exclusive );


    /**
     * Get transport connection

    /**
     * @param url
     * @param tc
     * @param unshared
     * @throws DcerpcException
     * @throws MalformedURLException
     */
    public DcerpcPipeHandle ( String url, CIFSContext tc, boolean unshared ) throws DcerpcException, MalformedURLException {
        super(tc, DcerpcHandle.parseBinding(url));
        this.pipe = new SmbNamedPipe(makePipeUrl(), pipeFlags, unshared, tc);

     * @param pipeType
     * @param unshared
     *            whether to use an exclusive connection for this pipe
     * @param tc
     * @throws MalformedURLException
     */

    public SmbNamedPipe ( String url, int pipeType, boolean unshared, CIFSContext tc ) throws MalformedURLException {
        super(url, tc);
        this.pipeType = pipeType;
        setNonPooled(unshared);
        if ( !getLocator().isIPC() ) {

	}
	// setupSandbox builds the sandbox.
	setupSandbox := func() error {
		// First, unshare the mount namespace. This allows us to create custom mounts without impacting the host
		if err := unix.Unshare(unix.CLONE_NEWNS); err != nil {
			return fmt.Errorf("failed to unshare to new mount namespace: %v", err)
		}
		if err := n.Set(); err != nil {