err = r.PipeReader.CloseWithError(err)
	r.wait()
	return err
}

// WaitPipe implements wait-group backend io.Pipe to provide
// synchronization between read() end with write() end.
func WaitPipe() (*PipeReader, *PipeWriter) {
	r, w := io.Pipe()
	var wg sync.WaitGroup
	wg.Add(1)
	return &PipeReader{
			PipeReader: r,
			wait:       wg.Wait,
		}, &PipeWriter{
			PipeWriter: w,

    /**
     * @param pipe
     */
    public SmbPipeHandleImpl ( SmbNamedPipe pipe ) {
        this.pipe = pipe;
        this.transact = ( pipe.getPipeType() & SmbPipeResource.PIPE_TYPE_TRANSACT ) == SmbPipeResource.PIPE_TYPE_TRANSACT;
        this.call = ( pipe.getPipeType() & SmbPipeResource.PIPE_TYPE_CALL ) == SmbPipeResource.PIPE_TYPE_CALL;
        this.openFlags = ( pipe.getPipeType() & 0xFFFF00FF ) | SmbConstants.O_EXCL;

 * new SmbNamedPipe( "smb1://server/IPC$/PIPE/foo",
 *         SmbNamedPipe.PIPE_TYPE_RDWR |
 *         SmbNamedPipe.PIPE_TYPE_CALL );
 * </pre></td><td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td></tr>
 * <tr><td width="20%"><pre>
 * new SmbNamedPipe( "smb1://server/IPC$/foo",
 *         SmbNamedPipe.PIPE_TYPE_RDWR |

    private String path;
    private SmbNamedPipe pipe;
    private byte[] tmp = new byte[1];
    private boolean dcePipe;

    TransactNamedPipeOutputStream( SmbNamedPipe pipe ) throws IOException {
        super(pipe, false, (pipe.pipeType & 0xFFFF00FF) | SmbFile.O_EXCL);
        this.pipe = pipe;
        this.dcePipe = ( pipe.pipeType & SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT ) == SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT;
        path = pipe.unc;
    }

 * stream created from a Named Pipe this method will query the server using a
 * "peek named pipe" operation and return the number of available bytes
 * on the server.
 */
    public int available() throws IOException {
        SmbNamedPipe pipe;
        TransPeekNamedPipe req;
        TransPeekNamedPipeResponse resp;

        if( file.type != SmbFile.TYPE_NAMED_PIPE ) {
            return 0;
        }

 */

package jcifs.smb1.smb1;

class TransCallNamedPipeResponse extends SmbComTransactionResponse {

    private SmbNamedPipe pipe;

    TransCallNamedPipeResponse( SmbNamedPipe pipe ) {
        this.pipe = pipe;
    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        return 0;

 */

package jcifs.smb1.smb1;

class TransTransactNamedPipeResponse extends SmbComTransactionResponse {

    private SmbNamedPipe pipe;

    TransTransactNamedPipeResponse( SmbNamedPipe pipe ) {
        this.pipe = pipe;
    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {

        "The security ID structure is invalid.", "The file system is full.", "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.", "File is a directory.", "A duplicate name exists on the network.",

    private static final int INIT_PIPE_SIZE = 4096;

    private byte[] pipe_buf = new byte[INIT_PIPE_SIZE];
    private int beg_idx, nxt_idx, used;
    private boolean dcePipe;

    Object lock;

    TransactNamedPipeInputStream( SmbNamedPipe pipe ) throws SmbException,
                MalformedURLException, UnknownHostException {
        super( pipe, ( pipe.pipeType & 0xFFFF00FF ) | SmbFile.O_EXCL );

     * The pipe should be opened for both reading and writing.
     */

    public static final int PIPE_TYPE_RDWR = SmbConstants.O_RDWR;

    /**
     * Pipe operations should behave like the <code>CallNamedPipe</code> Win32 Named Pipe function.
     */

    public static final int PIPE_TYPE_CALL = 0x0100;

    /**
     * Pipe operations should behave like the <code>TransactNamedPipe</code> Win32 Named Pipe function.
     */