* "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

            if (responseData.getUrl().startsWith("smb:")) {
                final SID[] allowedSids = (SID[]) metaDataMap.get(SmbClient.SMB_ALLOWED_SID_ENTRIES);
                if (allowedSids != null) {
                    for (final SID sid : allowedSids) {
                        final String accountId = sambaHelper.getAccountId(sid);
                        if (accountId != null) {

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;

/**
 * 
 */
public class SmbComFindClose2 extends ServerMessageBlock {

    private int sid;


    /**
     * 
     * @param config
     * @param sid
     */
    public SmbComFindClose2 ( Configuration config, int sid ) {
        super(config, SMB_COM_FIND_CLOSE2);
        this.sid = sid;
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {

            urlFilterService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlFilter for {}", sid, e);
        }

        try {
            // clear queue
            urlQueueService.clearCache();
            urlQueueService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlQueue for {}", sid, e);
        }

        try {

import jcifs.dcerpc.rpc.sid_t;
import jcifs.smb.SID;


class LsarSidArrayX extends lsarpc.LsarSidArray {

    LsarSidArrayX ( jcifs.SID[] sids ) {
        this.num_sids = sids.length;
        this.sids = new lsarpc.LsarSidPtr[sids.length];
        for ( int si = 0; si < sids.length; si++ ) {
            this.sids[ si ] = new lsarpc.LsarSidPtr();
            this.sids[ si ].sid = sids[ si ].unwrap(sid_t.class);
        }
    }

    private int sid, informationLevel, resumeKey, tflags;
    private String filename;
    private long maxItems;


    /**
     * 
     * @param config
     * @param sid
     * @param resumeKey
     * @param filename
     * @param batchCount
     * @param batchSize
     */

import jcifs.smb1.Config;
import jcifs.smb1.util.Hexdump;

class Trans2FindNext2 extends SmbComTransaction {

    private int sid, informationLevel, resumeKey, flags;
    private String filename;

    Trans2FindNext2( int sid, int resumeKey, String filename ) {
        this.sid = sid;
        this.resumeKey = resumeKey;
        this.filename = filename;
        command = SMB_COM_TRANSACTION2;

    public static class LsarSidPtr extends NdrObject {

        public rpc.sid_t sid;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(sid, 1);

            if (sid != null) {
                _dst = _dst.deferred;
                sid.encode(_dst);

            }
        }