static final int CAP_LOCK_AND_READ = 0x0100;
    static final int CAP_NT_FIND = 0x0200;
    static final int CAP_DFS = 0x1000;
    static final int CAP_LARGE_READX = 0x4000;
    static final int CAP_LARGE_WRITEX = 0x8000;
    static final int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /**
     * File is marked read-only
     */
    static final int ATTR_READONLY = 0x01;

        fp = 0L;
    }

    public int read() throws SmbException {
        if( read( tmp, 0, 1 ) == -1 ) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }
    public int read( byte b[] ) throws SmbException {
        return read( b, 0, b.length );
    }
    public int read( byte b[], int off, int len ) throws SmbException {
        if( len <= 0 ) {

        }
        else if ( ( shareAccess & SmbConstants.FILE_SHARE_READ ) == 0 ) {
            this.desiredAccess |= SHARING_DENY_READ_EXECUTE;
        }
        else {
            // neither SHARE_READ nor SHARE_WRITE are set
            this.desiredAccess |= SHARING_DENY_READ_WRITE_EXECUTE;
        }

        this.desiredAccess &= ~0x1; // Win98 doesn't like GENERIC_READ ?! -- get Access Denied.

        // searchAttributes

            // yes, there really is non ASN.1/DER data inside the tagged object
            int read = 0;
            int readLow = stream.read() & 0xff;
            int readHigh = stream.read() & 0xff;
            read = ( readHigh << 8 ) + readLow;
            if ( read != 0x01 )
                throw new PACDecodingException("Malformed kerberos token");

 * both <tt>FILE_READ_DATA</tt> and <tt>FILE_WRITE_DATA</tt> access.
 */

public class ACE {

    public static final int FILE_READ_DATA        = 0x00000001; // 1
    public static final int FILE_WRITE_DATA       = 0x00000002; // 2
    public static final int FILE_APPEND_DATA      = 0x00000004; // 3
    public static final int FILE_READ_EA          = 0x00000008; // 4

        type = TYPE_NAMED_PIPE;
    }

    /**
     * Return the <code>InputStream</code> used to read information
     * from this pipe instance. Presumably data would first be written
     * to the <code>OutputStream</code> associated with this Named
     * Pipe instance although this is not a requirement (e.g. a
     * read-only named pipe would write data to this stream on

        super(config, SMB_COM_READ_ANDX);
        this.openTimeout = 0xFFFFFFFF;
    }


    /**
     * 
     * @param config
     * @param fid
     * @param offset
     * @param maxCount
     * @param andx
     */
    public SmbComReadAndX ( Configuration config, int fid, long offset, int maxCount, ServerMessageBlock andx ) {
        super(config, SMB_COM_READ_ANDX, andx);
        this.fid = fid;

                log.trace("Short read, have " + n + ", want " + this.byteCount);
            }
            bufferIndex += this.byteCount;
        }

        /*
         * if there is an andx and it itself is an andx then just recur by
         * calling this method for it. otherwise just read it's parameter words

    private static int id = 0;
    private static final Logger log = LoggerFactory.getLogger(Transport.class);


    /**
     * Read bytes from the input stream into a buffer
     * 
     * @param in
     * @param b
     * @param off
     * @param len
     * @return number of bytes read
     * @throws IOException
     */
    public static int readn ( InputStream in, byte[] b, int off, int len ) throws IOException {

from jCIFS or another application will fail with the "file is being
accessed by another process" error. The <code>FILE_SHARE_READ</code>,
<code>FILE_SHARE_WRITE</code>, and <code>FILE_SHARE_DELETE</code> may be
combined with the bitwise OR '|' to specify that other peocesses may read,
write, and/or delete the file while the jCIFS user has the file open.
 * 
 * @param url An smb URL representing the file to write to