package org.snmp4j.agent.mo.snmp;

import org.snmp4j.agent.DuplicateRegistrationException;
import org.snmp4j.agent.MOAccess;
import org.snmp4j.agent.MOGroup;
import org.snmp4j.agent.MOServer;
import org.snmp4j.agent.mo.DefaultMOFactory;
import org.snmp4j.agent.mo.MOFactory;
import org.snmp4j.agent.mo.MOScalar;
import org.snmp4j.agent.mo.MOValueValidationEvent;
import org.snmp4j.agent.mo.MOValueValidationListener;
import org.snmp4j.agent.mo.snmp.tc.TruthValueTC;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.mp.DefaultCounterListener;
import org.snmp4j.security.TSM;
import org.snmp4j.smi.Counter32;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;

/* JADX INFO: loaded from: classes.dex */
public class SnmpTsmMib implements MOGroup {
    private static final String TC_MODULE_SNMPV2_TC = "SNMPv2-TC";
    private static final String TC_TRUTHVALUE = "TruthValue";
    private DefaultCounterListener counterListener;
    private MOFactory moFactory;
    private MOScalar<Integer32> snmpTsmConfigurationUsePrefix;
    private MOScalar<Counter32> snmpTsmInadequateSecurityLevels;
    private MOScalar<Counter32> snmpTsmInvalidCaches;
    private MOScalar<Counter32> snmpTsmInvalidPrefixes;
    private MOScalar<Counter32> snmpTsmUnknownPrefixes;
    private TSM tsm;
    private static final LogAdapter LOGGER = LogFactory.getLogger(SnmpTsmMib.class);
    public static final OID oidSnmpTsmMib = new OID(new int[]{1, 3, 6, 1, 2, 1, 190});
    public static final OID oidSnmpTsmInvalidCaches = new OID(new int[]{1, 3, 6, 1, 2, 1, 190, 1, 1, 1, 0});
    public static final OID oidSnmpTsmInadequateSecurityLevels = new OID(new int[]{1, 3, 6, 1, 2, 1, 190, 1, 1, 2, 0});
    public static final OID oidSnmpTsmUnknownPrefixes = new OID(new int[]{1, 3, 6, 1, 2, 1, 190, 1, 1, 3, 0});
    public static final OID oidSnmpTsmInvalidPrefixes = new OID(new int[]{1, 3, 6, 1, 2, 1, 190, 1, 1, 4, 0});
    public static final OID oidSnmpTsmConfigurationUsePrefix = new OID(new int[]{1, 3, 6, 1, 2, 1, 190, 1, 2, 1, 0});

    public class SnmpTsmConfigurationUsePrefix extends MOScalar<Integer32> {
        SnmpTsmConfigurationUsePrefix(OID oid, MOAccess mOAccess) {
            super(oid, mOAccess, new Integer32());
        }

        @Override // org.snmp4j.agent.mo.MOScalar
        public int isValueOK(SubRequest subRequest) {
            subRequest.getVariableBinding().getVariable();
            int iIsValueOK = super.isValueOK(subRequest);
            if (iIsValueOK != 0) {
            }
            return iIsValueOK;
        }

        @Override // org.snmp4j.agent.mo.MOScalar
        public Integer32 getValue() {
            return (Integer32) super.getValue();
        }

        @Override // org.snmp4j.agent.mo.MOScalar
        public int setValue(Integer32 integer32) {
            TSM tsm = SnmpTsmMib.this.tsm;
            if (tsm != null) {
                tsm.setUsePrefix(TruthValueTC.getBooleanValue(integer32));
            }
            return super.setValue(integer32);
        }
    }

    static class SnmpTsmConfigurationUsePrefixValidator implements MOValueValidationListener {
        SnmpTsmConfigurationUsePrefixValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            mOValueValidationEvent.getNewValue();
        }
    }

    protected SnmpTsmMib() {
        this.moFactory = DefaultMOFactory.getInstance();
        DefaultCounterListener defaultCounterListener = new DefaultCounterListener();
        this.counterListener = defaultCounterListener;
        defaultCounterListener.setCountRegisteredOnly(true);
    }

    public void addImportedTCsToFactory(MOFactory mOFactory) {
    }

    protected void addTCsToFactory(MOFactory mOFactory) {
    }

    protected void createMO(MOFactory mOFactory) {
        addTCsToFactory(mOFactory);
        this.snmpTsmInvalidCaches = mOFactory.createScalar(oidSnmpTsmInvalidCaches, mOFactory.createAccess(9), new Counter32());
        this.snmpTsmInadequateSecurityLevels = mOFactory.createScalar(oidSnmpTsmInadequateSecurityLevels, mOFactory.createAccess(9), new Counter32());
        this.snmpTsmUnknownPrefixes = mOFactory.createScalar(oidSnmpTsmUnknownPrefixes, mOFactory.createAccess(9), new Counter32());
        this.snmpTsmInvalidPrefixes = mOFactory.createScalar(oidSnmpTsmInvalidPrefixes, mOFactory.createAccess(9), new Counter32());
        SnmpTsmConfigurationUsePrefix snmpTsmConfigurationUsePrefix = new SnmpTsmConfigurationUsePrefix(oidSnmpTsmConfigurationUsePrefix, mOFactory.createAccess(11));
        this.snmpTsmConfigurationUsePrefix = snmpTsmConfigurationUsePrefix;
        snmpTsmConfigurationUsePrefix.addMOValueValidationListener(new SnmpTsmConfigurationUsePrefixValidator());
    }

    public MOScalar<Integer32> getSnmpTsmConfigurationUsePrefix() {
        return this.snmpTsmConfigurationUsePrefix;
    }

    public MOScalar<Counter32> getSnmpTsmInadequateSecurityLevels() {
        return this.snmpTsmInadequateSecurityLevels;
    }

    public MOScalar<Counter32> getSnmpTsmInvalidCaches() {
        return this.snmpTsmInvalidCaches;
    }

    public MOScalar<Counter32> getSnmpTsmInvalidPrefixes() {
        return this.snmpTsmInvalidPrefixes;
    }

    public MOScalar<Counter32> getSnmpTsmUnknownPrefixes() {
        return this.snmpTsmUnknownPrefixes;
    }

    public TSM getTsm() {
        return this.tsm;
    }

    @Override // org.snmp4j.agent.MOGroup
    public void registerMOs(MOServer mOServer, OctetString octetString) throws DuplicateRegistrationException {
        mOServer.register(this.snmpTsmInvalidCaches, octetString);
        mOServer.register(this.snmpTsmInadequateSecurityLevels, octetString);
        mOServer.register(this.snmpTsmUnknownPrefixes, octetString);
        mOServer.register(this.snmpTsmInvalidPrefixes, octetString);
        mOServer.register(this.snmpTsmConfigurationUsePrefix, octetString);
    }

    public void setTsm(TSM tsm) {
        TSM tsm2 = this.tsm;
        if (tsm2 != null) {
            tsm2.getCounterSupport().removeCounterListener(this.counterListener);
        }
        this.tsm = tsm;
        tsm.getCounterSupport().addCounterListener(this.counterListener);
        tsm.setUsePrefix(TruthValueTC.getBooleanValue((Integer32) this.snmpTsmConfigurationUsePrefix.getValue()));
    }

    @Override // org.snmp4j.agent.MOGroup
    public void unregisterMOs(MOServer mOServer, OctetString octetString) {
        mOServer.unregister(this.snmpTsmInvalidCaches, octetString);
        mOServer.unregister(this.snmpTsmInadequateSecurityLevels, octetString);
        mOServer.unregister(this.snmpTsmUnknownPrefixes, octetString);
        mOServer.unregister(this.snmpTsmInvalidPrefixes, octetString);
        mOServer.unregister(this.snmpTsmConfigurationUsePrefix, octetString);
    }

    public SnmpTsmMib(MOFactory mOFactory) {
        this();
        createMO(mOFactory);
        this.counterListener.add(this.snmpTsmInvalidCaches.getOid(), (Counter32) this.snmpTsmInvalidCaches.getValue());
        this.counterListener.add(this.snmpTsmInadequateSecurityLevels.getOid(), (Counter32) this.snmpTsmInadequateSecurityLevels.getValue());
        this.counterListener.add(this.snmpTsmUnknownPrefixes.getOid(), (Counter32) this.snmpTsmUnknownPrefixes.getValue());
        this.counterListener.add(this.snmpTsmInvalidPrefixes.getOid(), (Counter32) this.snmpTsmInvalidPrefixes.getValue());
    }
}