return new LockingAndXRange(this.largeFile);
    }


    @Override
    public String toString () {
        return new String(
            "SmbComLockingAndX[" + super.toString() + ",fid=" + this.fid + ",typeOfLock=" + this.typeOfLock + ",newOplockLevel=" + this.newOpLockLevel
                    + "]");
    }

            }
        });
        sambaHelper.init();

        assertEquals("1test user", sambaHelper.getAccountId(USER_SID));

    }

    private static final SID USER_SID = new SID() {

        @Override
        public SID getDomainSid() {
            return null;
        }

        @Override
        public int getRid() {
            return 0;
        }

        @Override

    private int fid;
    private long lastWriteTime;


    /**
     * 
     * @param config
     * @param fid
     * @param lastWriteTime
     */
    public SmbComClose ( Configuration config, int fid, long lastWriteTime ) {
        super(config, SMB_COM_CLOSE);
        this.fid = fid;
        this.lastWriteTime = lastWriteTime;
    }


    /**

class SmbComWrite extends ServerMessageBlock {

    private int fid,
        count,
        offset,
        remaining,
        off;
    private byte[] b;

    SmbComWrite() {
        super();
        command = SMB_COM_WRITE;
    }
    SmbComWrite( int fid, int offset, int remaining, byte[] b, int off, int len ) {
        this.fid = fid;
        this.count = len;
        this.offset = offset;

    private long initialSize;


    /**
     * @param cfg
     * @param fid
     * @param tree
     * @param unc
     * @param options
     * @param attrs
     * @param access
     * @param flags
     * @param initialSize
     */
    public SmbFileHandleImpl ( Configuration cfg, byte[] fid, SmbTreeHandleImpl tree, String unc, int flags, int access, int attrs, int options,
            long initialSize ) {

 * "The .NET Developer's Guide to Windows Security" (which is also
 * available online).
 * <p>
 * Direct ACEs are evaluated first in order. The SID of the user performing
 * the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags
 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access

import jcifs.internal.util.SMBUtil;
import jcifs.smb.SID;


/**
 * Internal use only
 * 
 * @internal
 */
public class SecurityDescriptor implements SecurityInfo {

    /**
     * Descriptor type
     */
    private int type;

    /**
     * ACEs
     */
    private ACE[] aces;
    private SID ownerUserSid, ownerGroupSid;


    /**
     * 
     */

    /**
     * @param tc
     * @param authorityServerName
     * @param domsid
     * @param rid
     * @param flags
     * @return the SIDs of the group members
     * @throws CIFSException
     */
    SID[] getGroupMemberSids ( CIFSContext tc, String authorityServerName, SID domsid, int rid, int flags ) throws CIFSException;

class SmbComClose extends ServerMessageBlock {

    private int fid;
    private long lastWriteTime;

    SmbComClose( int fid, long lastWriteTime ) {
        this.fid = fid;
        this.lastWriteTime = lastWriteTime;
        command = SMB_COM_CLOSE;
    }

    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {
        writeInt2( fid, dst, dstIndex );
        dstIndex += 2;

    private int fid;


    /**
     * 
     * @param config
     * @param pipeName
     * @param fid
     */
    public TransPeekNamedPipe ( Configuration config, String pipeName, int fid ) {
        super(config, SMB_COM_TRANSACTION, TRANS_PEEK_NAMED_PIPE);
        this.name = pipeName;
        this.fid = fid;
        this.timeout = 0xFFFFFFFF;