InputStream errorStream = connection.getErrorStream();
        if (errorStream != null && errorStream.available() != 0) {
            int count;
            byte[] buf = new byte[1024];
            while ((count = errorStream.read(buf, 0, 1024)) != -1);
        }
        String authHeader;
        if (response == HTTP_UNAUTHORIZED) {
            authHeader = "WWW-Authenticate";
            authProperty = "Authorization";

                    if ( type == SmbConstants.TYPE_NAMED_PIPE ) {
                        request.setMinCount(1024);
                        request.setMaxCount(1024);
                        request.setRemaining(1024);
                    }
                    else if ( this.largeReadX ) {
                        request.setMaxCount(r & 0xFFFF);

                if ( ( getPipeType() & SmbPipeResource.PIPE_TYPE_DCE_TRANSACT ) == SmbPipeResource.PIPE_TYPE_DCE_TRANSACT ) {
                    req.setMaxDataCount(1024);
                }
                th.send(req, resp, RequestParam.NO_RETRY);
                return resp.getResponseLength();
            }
            else if ( this.call ) {

                // + 64 byte header
                // + 8 byte query response overhead
                // + 110 bytes entry
                // -> 1022 predicted message size <= 1023 maximum buffer size
                // 112 bytes to alignment
                // -> aligned to 1024 > 1023 maximum buffer size

                // 110 byte entry = 16 byte name = 8 char length
                try ( SmbResource r = f.resolve(repeat('Y', 8)) ) {

    static final int DEFAULT_SO_TIMEOUT = 35000;
    static final int DEFAULT_RCV_BUF_SIZE = 0xFFFF;
    static final int DEFAULT_SND_BUF_SIZE = 0xFFFF;
    static final int DEFAULT_NOTIFY_BUF_SIZE = 1024;

    static final int DEFAULT_SSN_LIMIT = 250;
    static final int DEFAULT_CONN_TIMEOUT = 35000;

    static final int FLAGS_NONE = 0x00;
    static final int FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK = 0x01;

                // can we resume this if we loose the file descriptor?

                int maxChunks = 256;
                int maxChunkSize = 1024 * 1024;
                int byteLimit = 16 * 1024 * 1024;
                boolean retry = false;
                do {
                    long ooff = 0;
                    while ( ooff < size ) {
                        long wsize = size - ooff;

            try {
SmbComReadAndX request = new SmbComReadAndX( file.fid, fp, r, null );
if( file.type == SmbFile.TYPE_NAMED_PIPE ) {
    request.minCount = request.maxCount = request.remaining = 1024;
}
                file.send( request, response );
            } catch( SmbException se ) {
                if( file.type == SmbFile.TYPE_NAMED_PIPE &&

            try ( SmbPipeHandle p = f.openPipe() ) {
                try ( OutputStream os = p.getOutput() ) {
                    writeRandom(1024, 1024, os);
                    try ( InputStream is = p.getInput() ) {
                        verifyRandom(1024, 1024, is);
                    }
                }
            }
            catch ( SmbException e ) {
                if ( e.getNtStatus() == 0xC00000BB ) {

            }
            finally {
                f.delete();
            }
        }
    }


    @Test
    public void testCopyFileLarge () throws IOException {
        long length = 4096 * 16 * 1024;
        try ( SmbFile f = createTestFile();
              SmbTreeHandle treeHandle = f.getTreeHandle() ) {
            // this is tremendously slow on SMB1
            try {

    }


    @Test
    public void testReadWrite () throws IOException {
        try ( SmbFile f = createTestFile() ) {
            try {
                int bufSize = 4096;
                long l = 1024;
                try ( SmbRandomAccessFile raf = new SmbRandomAccessFile(f, "rw") ) {
                    writeRandom(bufSize, l, raf);
                    assertEquals(l, raf.getFilePointer());