}
            System.arraycopy(Strings.getUNIBytes(str), 0, dst, dstIndex, str.length() * 2);
            dstIndex += str.length() * 2;
            dst[ dstIndex++ ] = (byte) '\0';
            dst[ dstIndex++ ] = (byte) '\0';
        }
        else {
            byte[] b = Strings.getOEMBytes(str, this.getConfig());
            System.arraycopy(b, 0, dst, dstIndex, b.length);

        if(( dst.length - dstIndex ) < pipeDataLen ) {
            if( log.level >= 3 )
                log.println( "TransCallNamedPipe data too long for buffer" );
            return 0;
        }
        System.arraycopy( pipeData, pipeDataOff, dst, dstIndex, pipeDataLen );
        return pipeDataLen;
    }
    int readParametersWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }

        }
        return bufferIndex - start;
    }
    int readBytesWireFormat( byte[] buffer, int bufferIndex ) {
        int start = bufferIndex;

        if (extendedSecurity) {
            System.arraycopy(buffer, bufferIndex, blob, 0, blob.length);
            bufferIndex += blob.length;
        }
        nativeOs = readString( buffer, bufferIndex );
        bufferIndex += stringWireLength( nativeOs, bufferIndex );

        int start = dstIndex;
        SMBUtil.writeInt2(24, dst, dstIndex);
        dstIndex += 2;
        dstIndex += 2; // Reserved1
        dstIndex += 4; // Reserved2

        System.arraycopy(this.fileId, 0, dst, dstIndex, 16);
        dstIndex += 16;

        return dstIndex - start;
    }


    /**
     * {@inheritDoc}
     *

        if (len >= partLen) {
            System.arraycopy(input, offset, buffer, bufferNdx, partLen);


            transform(buffer, 0);

            for (i = partLen; i + BLOCK_LENGTH - 1 < len; i+= BLOCK_LENGTH)
                transform(input, offset + i);
            bufferNdx = 0;
        }
        // buffer remaining input
        if (i < len)
            System.arraycopy(input, offset + i, buffer, bufferNdx, len - i);

        int createContextLengthOffset = dstIndex;
        dstIndex += 4; // createContextLength

        SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, nameOffsetOffset);

        System.arraycopy(nameBytes, 0, dst, dstIndex, nameBytes.length);
        if ( nameBytes.length == 0 ) {
            // buffer must contain at least one byte
            dstIndex++;
        }
        else {

        if ( len > this.outputBuffer.length ) {
            throw new SMBProtocolDecodingException("Payload exceeds buffer size");
        }
        System.arraycopy(buffer, bufferIndex, this.outputBuffer, 0, len);
        return len;

    }


    @Override
    public String toString () {
        return new String("TransTransactNamedPipeResponse[" + super.toString() + "]");

        int start = dstIndex;

        dst[dstIndex++] = (byte)0x01; /* BufferFormat */
        writeInt2( count, dst, dstIndex ); /* DataLength? */
        dstIndex += 2;
        System.arraycopy( b, off, dst, dstIndex, count );
        dstIndex += count;

        return dstIndex - start;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }

        int offsetOffset = dstIndex;
        SMBUtil.writeInt2(data.length, dst, dstIndex + 2);
        dstIndex += 4;
        SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, offsetOffset);

        System.arraycopy(data, 0, dst, dstIndex, data.length);
        dstIndex += data.length;
        return dstIndex - start;
    }


    /**
     * {@inheritDoc}
     *

        new ByteProcessor<byte[]>() {
          int pos;

          @Override
          public boolean processBytes(byte[] buf, int off, int len) throws IOException {
            System.arraycopy(buf, off, processedBytes, pos, len);
            pos += len;
            return true;
          }

          @Override
          public byte[] getResult() {
            return processedBytes;
          }