*/
    protected SmbPipeHandleImpl getHandle () {
        return this.handle;
    }


    @Override
    public void close () {
        // ignore, the shared file descriptor is closed by the pipe handle
    }

 */
package jcifs;


import java.io.InputStream;
import java.io.OutputStream;


/**
 * Handle to an open named pipe
 * 
 * @author mbechler
 *
 */
public interface SmbPipeHandle extends AutoCloseable {

    /**
     * @return the pipe
     */
    SmbPipeResource getPipe ();


    /**
     * 
     * @return this pipe's input stream
     * @throws CIFSException
     */

    }


    @Test
    public void testSRVS () throws DcerpcException, IOException {
        try ( DcerpcHandle handle = DcerpcHandle
                .getHandle("ncacn_np:" + getTestServer() + "[\\PIPE\\srvsvc]", withTestNTLMCredentials(getContext())) ) {
            MsrpcShareEnum rpc = new MsrpcShareEnum(handle.getServerWithDfs());
            handle.sendrecv(rpc);
            assertEquals(0, rpc.retval);
        }
    }

    source2!!.close()
    assertThat(relay.isClosed).isTrue()
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun racingReaders() {
    val pipe = Pipe(1024)
    val sink = pipe.sink.buffer()
    val relay = edit(file, pipe.source, metadata, 5)
    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)

  // zero effect on the behavior of the WebSocket API which is why tests are only written once
  // from the perspective of a single peer.
  private val random = Random(0)
  private val client2Server = Pipe(8192L)
  private val server2client = Pipe(8192L)
  private val taskFaker = TaskFaker()
  private val client = TestStreams(true, taskFaker, server2client, client2Server)
  private val server = TestStreams(false, taskFaker, client2Server, server2client)

        "The security ID structure is invalid.",
        "All pipe instances are busy.",
        "All pipe instances are busy.",
        "The pipe state is invalid.",
        "All pipe instances are busy.",
        "No process is on the other end of the pipe.",
        "The pipe is being closed.",
        "Waiting for a process to open the other end of the pipe.",
        "Access is denied.",

If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

Regular Reads will block until data is available, but not wait for a full buffer. 
Writes will block until there is space available and writes bigger than the buffer will wait for reads to make space.

}

func retrieveListenerAddress(l *listener.Listener) string {
	sockAddr := l.Address.GetSocketAddress()
	if sockAddr != nil {
		return sockAddr.Address
	}

	pipe := l.Address.GetPipe()
	if pipe != nil {
		return pipe.Path
	}

	return ""
}

func retrieveListenerAdditionalAddresses(l *listener.Listener) []string {
	var addrs []string
	socketAddresses := l.GetAdditionalAddresses()

    /**
     * 
     * @param config
     */
    public NetShareEnum ( Configuration config ) {
        super(config, SMB_COM_TRANSACTION, NET_SHARE_ENUM);
        this.name = new String("\\PIPE\\LANMAN");
        this.maxParameterCount = 8;

        // maxDataCount = 4096; why was this set?
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 0;
        this.timeout = 5000;
    }

./mc mb sitea/delissue --insecure

./mc version enable sitea/delissue --insecure

echo hello | ./mc pipe sitea/delissue/hello --insecure

./mc version suspend sitea/delissue --insecure

./mc rm sitea/delissue/hello --insecure

./mc version enable sitea/delissue --insecure

echo hello | ./mc pipe sitea/delissue/hello --insecure

./mc version suspend sitea/delissue --insecure