package org.snmp4j.agent.mo.snmp;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
import org.snmp4j.CertifiedTarget;
import org.snmp4j.CommunityTarget;
import org.snmp4j.MessageDispatcher;
import org.snmp4j.Target;
import org.snmp4j.UserTarget;
import org.snmp4j.agent.DuplicateRegistrationException;
import org.snmp4j.agent.MOGroup;
import org.snmp4j.agent.MOServer;
import org.snmp4j.agent.mo.DefaultMOMutableRow2PC;
import org.snmp4j.agent.mo.DefaultMOMutableRow2PCFactory;
import org.snmp4j.agent.mo.DefaultMOMutableTableModel;
import org.snmp4j.agent.mo.DefaultMOTable;
import org.snmp4j.agent.mo.DefaultMOTableRow;
import org.snmp4j.agent.mo.MOAccessImpl;
import org.snmp4j.agent.mo.MOColumn;
import org.snmp4j.agent.mo.MOMutableColumn;
import org.snmp4j.agent.mo.MOScalar;
import org.snmp4j.agent.mo.MOTableIndex;
import org.snmp4j.agent.mo.MOTableModel;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.agent.mo.MOTableRowEvent;
import org.snmp4j.agent.mo.MOTableRowFactory;
import org.snmp4j.agent.mo.MOTableRowListener;
import org.snmp4j.agent.mo.MOTableSubIndex;
import org.snmp4j.agent.mo.MOValueValidationEvent;
import org.snmp4j.agent.mo.MOValueValidationListener;
import org.snmp4j.agent.mo.snmp.SnmpTlsTmMib;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.event.CounterEvent;
import org.snmp4j.event.CounterListener;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.mp.MPv3;
import org.snmp4j.security.SecurityModels;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.Counter32;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;

/* JADX INFO: loaded from: classes.dex */
public class SnmpTargetMIB implements MOGroup, CounterListener, MOTableRowListener {
    public static final long ADDRESS_CACHE_TIMEOUT = 3600000000000L;
    private static final OID[] DEFAULT_TDOMAINS;
    private static final int colSnmpTargetAddrParams = 7;
    private static final int colSnmpTargetAddrRetryCount = 5;
    private static final int colSnmpTargetAddrRowStatus = 9;
    private static final int colSnmpTargetAddrStorageType = 8;
    private static final int colSnmpTargetAddrTAddress = 3;
    private static final int colSnmpTargetAddrTDomain = 2;
    private static final int colSnmpTargetAddrTagList = 6;
    private static final int colSnmpTargetAddrTimeout = 4;
    private static final int colSnmpTargetParamsMPModel = 2;
    private static final int colSnmpTargetParamsRowStatus = 7;
    private static final int colSnmpTargetParamsSecurityLevel = 5;
    private static final int colSnmpTargetParamsSecurityModel = 3;
    private static final int colSnmpTargetParamsSecurityName = 4;
    private static final int colSnmpTargetParamsStorageType = 6;
    static final int idxSnmpTargetAddrParams = 5;
    static final int idxSnmpTargetAddrRetryCount = 3;
    static final int idxSnmpTargetAddrRowStatus = 7;
    static final int idxSnmpTargetAddrStorageType = 6;
    static final int idxSnmpTargetAddrTAddress = 1;
    static final int idxSnmpTargetAddrTDomain = 0;
    static final int idxSnmpTargetAddrTagList = 4;
    static final int idxSnmpTargetAddrTimeout = 2;
    static final int idxSnmpTargetParamsMPModel = 0;
    static final int idxSnmpTargetParamsRowStatus = 5;
    static final int idxSnmpTargetParamsSecurityLevel = 3;
    static final int idxSnmpTargetParamsSecurityModel = 1;
    static final int idxSnmpTargetParamsSecurityName = 2;
    static final int idxSnmpTargetParamsStorageType = 4;
    private static final OID oidSnmpTargetAddrEntry;
    private static MOTableIndex snmpTargetAddrEntryIndex;
    private static MOTableSubIndex[] snmpTargetAddrEntryIndexes;
    private static MOTableIndex snmpTargetParamsEntryIndex;
    private static MOTableSubIndex[] snmpTargetParamsEntryIndexes;
    private CoexistenceInfoProvider coexistenceProvider;
    private MessageDispatcher messageDispatcher;
    private DefaultMOTable<SnmpTargetAddrEntryRow, MOColumn, DefaultMOMutableTableModel<SnmpTargetAddrEntryRow>> snmpTargetAddrEntry;
    private DefaultMOMutableTableModel<SnmpTargetAddrEntryRow> snmpTargetAddrEntryModel;
    private DefaultMOTable<DefaultMOMutableRow2PC, MOColumn, DefaultMOMutableTableModel<DefaultMOMutableRow2PC>> snmpTargetParamsEntry;
    private DefaultMOMutableTableModel<DefaultMOMutableRow2PC> snmpTargetParamsEntryModel;
    private SnmpTlsTmMib tlsTmMib;
    private static final LogAdapter logger = LogFactory.getLogger(SnmpTargetMIB.class);
    private static final OID oidSnmpTargetSpinLock = new OID(new int[]{1, 3, 6, 1, 6, 3, 12, 1, 1, 0});
    private static final OID oidSnmpUnknownContexts = new OID(new int[]{1, 3, 6, 1, 6, 3, 12, 1, 5, 0});
    private static final OID oidSnmpUnavailableContexts = new OID(new int[]{1, 3, 6, 1, 6, 3, 12, 1, 4, 0});
    private static final OID oidSnmpTargetParamsEntry = new OID(new int[]{1, 3, 6, 1, 6, 3, 12, 1, 3, 1});
    private Map<OctetString, Set<SnmpTargetAddrEntryRow>> snmpTargetAddrTagIndex = new Hashtable();
    private Hashtable<OID, TDomainAddressFactory> supportedAddressClasses = new Hashtable<>();
    private long addressCacheTimeoutNanos = ADDRESS_CACHE_TIMEOUT;
    private MOScalar snmpTargetSpinLock = new TestAndIncr(oidSnmpTargetSpinLock);
    private MOScalar snmpUnknownContexts = new MOScalar(oidSnmpUnknownContexts, MOAccessImpl.ACCESS_READ_ONLY, new Counter32());
    private MOScalar snmpUnavailableContexts = new MOScalar(oidSnmpUnavailableContexts, MOAccessImpl.ACCESS_READ_ONLY, new Counter32());

    class SnmpTargetAddrEntryFactory implements MOTableRowFactory<SnmpTargetAddrEntryRow> {
        SnmpTargetAddrEntryFactory() {
        }

        @Override // org.snmp4j.agent.mo.MOTableRowFactory
        public void freeRow(SnmpTargetAddrEntryRow snmpTargetAddrEntryRow) {
        }

        @Override // org.snmp4j.agent.mo.MOTableRowFactory
        public SnmpTargetAddrEntryRow createRow(OID oid, Variable[] variableArr) throws UnsupportedOperationException {
            return SnmpTargetMIB.this.new SnmpTargetAddrEntryRow(oid, variableArr);
        }
    }

    public class SnmpTargetAddrEntryRow extends DefaultMOMutableRow2PC {
        private volatile transient Address cachedAddress;
        private transient long lastAddressUdpate;

        public SnmpTargetAddrEntryRow(OID oid, Variable[] variableArr) {
            super(oid, variableArr);
            updateUserObject(this);
        }

        private void updateIndex(Set<OctetString> set, Set<OctetString> set2) {
            if (set != null) {
                for (OctetString octetString : set) {
                    Collection collection = (Collection) SnmpTargetMIB.this.snmpTargetAddrTagIndex.get(octetString);
                    if (collection != null) {
                        synchronized (collection) {
                            if (!collection.remove(this)) {
                                SnmpTargetMIB.logger.error("Inconsistent tag value '" + octetString + "' for rows: " + collection);
                            }
                        }
                    } else {
                        SnmpTargetMIB.logger.error("Tag value '" + octetString + "' not found in tag index");
                    }
                }
            }
            for (OctetString octetString2 : set2) {
                Set hashSet = (Set) SnmpTargetMIB.this.snmpTargetAddrTagIndex.get(octetString2);
                if (hashSet == null) {
                    hashSet = new HashSet();
                }
                synchronized (hashSet) {
                    if (!hashSet.add(this)) {
                        hashSet.remove(this);
                        hashSet.add(this);
                    }
                }
                SnmpTargetMIB.this.snmpTargetAddrTagIndex.put(octetString2, hashSet);
            }
        }

        /* JADX INFO: Access modifiers changed from: private */
        public void updateUserObject(MOTableRow mOTableRow) {
            Variable value = mOTableRow.getValue(4);
            if (value != null) {
                Set<OctetString> set = (Set) getUserObject();
                Set<OctetString> tags = SnmpTagList.getTags((OctetString) value);
                if (set != null) {
                    set.removeAll(tags);
                }
                setUserObject(tags);
                updateIndex(set, tags);
            }
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableRow2PC
        public void commitRow(SubRequest subRequest, MOTableRow mOTableRow) {
            super.commitRow(subRequest, mOTableRow);
            updateUserObject(mOTableRow);
        }

        public Address getAddress() {
            if (this.cachedAddress != null && System.nanoTime() - this.lastAddressUdpate < SnmpTargetMIB.this.addressCacheTimeoutNanos) {
                return this.cachedAddress;
            }
            OID oid = (OID) getValue(0);
            TDomainAddressFactory tDomainAddressFactory = (TDomainAddressFactory) SnmpTargetMIB.this.supportedAddressClasses.get(oid);
            if (tDomainAddressFactory == null) {
                return null;
            }
            Address addressCreateAddress = tDomainAddressFactory.createAddress(oid, (OctetString) getValue(1));
            this.cachedAddress = addressCreateAddress;
            this.lastAddressUdpate = System.nanoTime();
            return addressCreateAddress;
        }

        public OctetString getTAddress(Address address) {
            OID oid = (OID) getValue(0);
            TDomainAddressFactory tDomainAddressFactory = (TDomainAddressFactory) SnmpTargetMIB.this.supportedAddressClasses.get(oid);
            for (OID oid2 : tDomainAddressFactory.getTransportDomain(address)) {
                if (oid2.equals(oid)) {
                    return tDomainAddressFactory.getAddress(address);
                }
            }
            return null;
        }

        /* JADX WARN: Type inference failed for: r1v4, types: [org.snmp4j.agent.mo.MOTableRow] */
        public Target getTarget(OctetString octetString, OctetString octetString2) {
            SnmpTlsTmMib.SnmpTlstmAddrEntryRow snmpTlstmAddrEntryRow;
            Address address = getAddress();
            ?? row = SnmpTargetMIB.this.snmpTargetParamsEntryModel.getRow(((OctetString) getValue(5)).toSubIndex(true));
            Target communityTarget = null;
            if (row == 0) {
                return null;
            }
            if (row.getValue(0).toInt() == 3) {
                SnmpTlsTmMib snmpTlsTmMib = SnmpTargetMIB.this.tlsTmMib;
                if (snmpTlsTmMib != null && (snmpTlstmAddrEntryRow = (SnmpTlsTmMib.SnmpTlstmAddrEntryRow) snmpTlsTmMib.getSnmpTlstmAddrEntry().getModel().getRow(this.index)) != null) {
                    communityTarget = new CertifiedTarget(address, snmpTlstmAddrEntryRow.getSnmpTlstmAddrServerIdentity(), snmpTlstmAddrEntryRow.getSnmpTlstmAddrServerFingerprint(), null);
                }
                if (communityTarget == null) {
                    communityTarget = new UserTarget(address, (OctetString) row.getValue(2), octetString.getValue(), row.getValue(3).toInt());
                }
            } else {
                OctetString community = (OctetString) row.getValue(2);
                if (SnmpTargetMIB.this.coexistenceProvider != null && (community = SnmpTargetMIB.this.coexistenceProvider.getCommunity(community, octetString, octetString2)) == null) {
                    return null;
                }
                communityTarget = new CommunityTarget(address, community);
            }
            communityTarget.setRetries(getValue(3).toInt());
            communityTarget.setTimeout(getValue(2).toInt() * 10);
            communityTarget.setVersion(row.getValue(0).toInt());
            return communityTarget;
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableRow2PC
        public void prepareRow(SubRequest subRequest, MOTableRow mOTableRow) {
            OID oid = (OID) getResultingValue(0, mOTableRow);
            OctetString octetString = (OctetString) getResultingValue(1, mOTableRow);
            if (oid == null) {
                if (octetString != null) {
                    subRequest.getStatus().setErrorStatus(12);
                }
            } else {
                TDomainAddressFactory tDomainAddressFactory = (TDomainAddressFactory) SnmpTargetMIB.this.supportedAddressClasses.get(oid);
                if (tDomainAddressFactory == null || !tDomainAddressFactory.isValidAddress(oid, octetString)) {
                    subRequest.getStatus().setErrorStatus(12);
                }
            }
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableTableRow
        public void setValue(int i2, Variable variable) {
            this.cachedAddress = null;
            super.setValue(i2, variable);
        }
    }

    class SnmpTargetAddrParamsValidator implements MOValueValidationListener {
        SnmpTargetAddrParamsValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            OctetString octetString = (OctetString) mOValueValidationEvent.getNewValue();
            if (octetString.length() < 1 || octetString.length() > 32) {
                mOValueValidationEvent.setValidationStatus(8);
                return;
            }
            if (SnmpTargetMIB.this.snmpTargetParamsEntryModel.getRow(octetString.toSubIndex(true)) == 0) {
                mOValueValidationEvent.setValidationStatus(12);
            }
        }
    }

    static class SnmpTargetAddrRetryCountValidator implements MOValueValidationListener {
        SnmpTargetAddrRetryCountValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            long value = ((Integer32) mOValueValidationEvent.getNewValue()).getValue();
            if (value < 0 || value > 255) {
                mOValueValidationEvent.setValidationStatus(10);
            }
        }
    }

    static class SnmpTargetAddrTAddressValidator implements MOValueValidationListener {
        SnmpTargetAddrTAddressValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            OctetString octetString = (OctetString) mOValueValidationEvent.getNewValue();
            if (octetString.length() < 1 || octetString.length() > 255) {
                mOValueValidationEvent.setValidationStatus(8);
            }
        }
    }

    class SnmpTargetAddrTDomainValidator implements MOValueValidationListener {
        SnmpTargetAddrTDomainValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            Variable newValue = mOValueValidationEvent.getNewValue();
            if (!(newValue instanceof OID)) {
                mOValueValidationEvent.setValidationStatus(7);
                return;
            }
            if (SnmpTargetMIB.this.supportedAddressClasses.containsKey((OID) newValue)) {
                return;
            }
            mOValueValidationEvent.setValidationStatus(3);
        }
    }

    static class SnmpTargetAddrTimeoutValidator implements MOValueValidationListener {
        SnmpTargetAddrTimeoutValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            if (((Integer32) mOValueValidationEvent.getNewValue()).getValue() < 0) {
                mOValueValidationEvent.setValidationStatus(10);
            }
        }
    }

    class SnmpTargetParamsEntryRowStatusListener implements RowStatusListener {
        SnmpTargetParamsEntryRowStatusListener() {
        }

        @Override // org.snmp4j.agent.mo.snmp.RowStatusListener
        public void rowStatusChanged(RowStatusEvent rowStatusEvent) {
            if (rowStatusEvent.getNewStatus() == 6) {
                OctetString octetString = (OctetString) SnmpTargetMIB.snmpTargetParamsEntryIndex.getIndexValues(rowStatusEvent.getRow().getIndex())[0];
                synchronized (SnmpTargetMIB.this.snmpTargetAddrEntryModel) {
                    for (MOTableRow mOTableRow : SnmpTargetMIB.this.snmpTargetAddrEntryModel) {
                        Integer32 integer32 = (Integer32) mOTableRow.getValue(7);
                        if (integer32 != null && integer32.getValue() == 1 && octetString.equals(mOTableRow.getValue(5))) {
                            rowStatusEvent.setDenyReason(12);
                            return;
                        }
                    }
                }
            }
        }
    }

    class SnmpTargetParamsMPModelValidator implements MOValueValidationListener {
        SnmpTargetParamsMPModelValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            if (SnmpTargetMIB.this.messageDispatcher.getMessageProcessingModel(((Integer32) mOValueValidationEvent.getNewValue()).getValue()) == null) {
                mOValueValidationEvent.setValidationStatus(10);
            }
        }
    }

    public static final class SnmpTargetParamsSecurityLevelEnum {
        public static final int authNoPriv = 2;
        public static final int authPriv = 3;
        public static final int noAuthNoPriv = 1;
    }

    static class SnmpTargetParamsSecurityModelValidator implements MOValueValidationListener {
        SnmpTargetParamsSecurityModelValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            Integer32 integer32 = (Integer32) mOValueValidationEvent.getNewValue();
            if (integer32.getValue() == 3 && SecurityModels.getInstance().getSecurityModel(integer32) == null) {
                mOValueValidationEvent.setValidationStatus(10);
            }
        }
    }

    static {
        MOTableSubIndex[] mOTableSubIndexArr = {new MOTableSubIndex(4, 1, 32)};
        snmpTargetParamsEntryIndexes = mOTableSubIndexArr;
        snmpTargetParamsEntryIndex = new MOTableIndex(mOTableSubIndexArr, true);
        oidSnmpTargetAddrEntry = new OID(new int[]{1, 3, 6, 1, 6, 3, 12, 1, 2, 1});
        MOTableSubIndex[] mOTableSubIndexArr2 = {new MOTableSubIndex(4, 1, 32)};
        snmpTargetAddrEntryIndexes = mOTableSubIndexArr2;
        snmpTargetAddrEntryIndex = new MOTableIndex(mOTableSubIndexArr2, true);
        DEFAULT_TDOMAINS = new OID[]{TransportDomains.snmpUDPDomain, TransportDomains.transportDomainTcpIpv4, TransportDomains.transportDomainTcpIpv6, TransportDomains.transportDomainUdpIpv4, TransportDomains.transportDomainUdpIpv6, TransportDomains.transportDomainUdpDns, TransportDomains.transportDomainTcpDns};
    }

    public SnmpTargetMIB(MessageDispatcher messageDispatcher) {
        this.messageDispatcher = messageDispatcher;
        createSnmpTargetParamsEntry();
        createSnmpTargetAddrEntry();
    }

    private void createSnmpTargetAddrEntry() {
        ((MOMutableColumn) mOColumnArr[0]).addMOValueValidationListener(new SnmpTargetAddrTDomainValidator());
        ((MOMutableColumn) mOColumnArr[1]).addMOValueValidationListener(new SnmpTargetAddrTAddressValidator());
        ((MOMutableColumn) mOColumnArr[2]).addMOValueValidationListener(new SnmpTargetAddrTimeoutValidator());
        ((MOMutableColumn) mOColumnArr[3]).addMOValueValidationListener(new SnmpTargetAddrRetryCountValidator());
        ((MOMutableColumn) mOColumnArr[5]).addMOValueValidationListener(new SnmpTargetAddrParamsValidator());
        MOColumn[] mOColumnArr = {new MOMutableColumn(2, 6, MOAccessImpl.ACCESS_READ_CREATE, null, false), new MOMutableColumn(3, 4, MOAccessImpl.ACCESS_READ_CREATE, null, false), new MOMutableColumn(4, 2, MOAccessImpl.ACCESS_READ_CREATE, new Integer32(1500), true), new MOMutableColumn(5, 2, MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true), new SnmpTagList(6, MOAccessImpl.ACCESS_READ_CREATE, new OctetString(new byte[0]), true), new MOMutableColumn(7, 4, MOAccessImpl.ACCESS_READ_CREATE, new OctetString(), true), new StorageType(8, MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true), new RowStatus(9)};
        this.snmpTargetAddrEntry = new DefaultMOTable<>(oidSnmpTargetAddrEntry, snmpTargetAddrEntryIndex, mOColumnArr);
        DefaultMOMutableTableModel<SnmpTargetAddrEntryRow> defaultMOMutableTableModel = new DefaultMOMutableTableModel<>();
        this.snmpTargetAddrEntryModel = defaultMOMutableTableModel;
        defaultMOMutableTableModel.setRowFactory(new SnmpTargetAddrEntryFactory());
        this.snmpTargetAddrEntry.setModel(this.snmpTargetAddrEntryModel);
    }

    private void createSnmpTargetParamsEntry() {
        ((MOMutableColumn) mOColumnArr[0]).addMOValueValidationListener(new SnmpTargetParamsMPModelValidator());
        ((MOMutableColumn) mOColumnArr[1]).addMOValueValidationListener(new SnmpTargetParamsSecurityModelValidator());
        MOColumn[] mOColumnArr = {new MOMutableColumn(2, 2, MOAccessImpl.ACCESS_READ_CREATE, null, false), new MOMutableColumn(3, 2, MOAccessImpl.ACCESS_READ_CREATE, null, false), new SnmpAdminString(4, MOAccessImpl.ACCESS_READ_CREATE, null, false), new Enumerated(5, 2, MOAccessImpl.ACCESS_READ_CREATE, null, false, new int[]{1, 3, 2}), new StorageType(6, MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true), new RowStatus(7, MOAccessImpl.ACCESS_READ_CREATE)};
        ((RowStatus) mOColumnArr[5]).addRowStatusListener(new SnmpTargetParamsEntryRowStatusListener());
        this.snmpTargetParamsEntry = new DefaultMOTable<>(oidSnmpTargetParamsEntry, snmpTargetParamsEntryIndex, mOColumnArr);
        DefaultMOMutableTableModel<DefaultMOMutableRow2PC> defaultMOMutableTableModel = new DefaultMOMutableTableModel<>();
        this.snmpTargetParamsEntryModel = defaultMOMutableTableModel;
        defaultMOMutableTableModel.setRowFactory(new DefaultMOMutableRow2PCFactory());
        this.snmpTargetParamsEntry.setModel(this.snmpTargetParamsEntryModel);
    }

    public void addDefaultTDomains() {
        TDomainAddressFactoryImpl tDomainAddressFactoryImpl = new TDomainAddressFactoryImpl();
        for (OID oid : DEFAULT_TDOMAINS) {
            this.supportedAddressClasses.put(oid, tDomainAddressFactoryImpl);
        }
    }

    public void addSupportedTDomain(OID oid, TDomainAddressFactory tDomainAddressFactory) {
        this.supportedAddressClasses.put(oid, tDomainAddressFactory);
    }

    public boolean addTargetAddress(OctetString octetString, OID oid, OctetString octetString2, int i2, int i3, OctetString octetString3, OctetString octetString4, int i4) {
        Variable[] variableArr = new Variable[this.snmpTargetAddrEntry.getColumnCount()];
        variableArr[0] = oid;
        variableArr[1] = octetString2;
        variableArr[2] = new Integer32(i2);
        variableArr[3] = new Integer32(i3);
        variableArr[4] = octetString3;
        variableArr[5] = octetString4;
        variableArr[6] = new Integer32(i4);
        variableArr[7] = new Integer32(1);
        this.snmpTargetAddrEntry.addRow((SnmpTargetAddrEntryRow) this.snmpTargetAddrEntry.createRow(octetString.toSubIndex(true), variableArr));
        return true;
    }

    public boolean addTargetParams(OctetString octetString, int i2, int i3, OctetString octetString2, int i4, int i5) {
        Variable[] variableArr = new Variable[this.snmpTargetParamsEntry.getColumnCount()];
        variableArr[0] = new Integer32(i2);
        variableArr[1] = new Integer32(i3);
        variableArr[2] = octetString2;
        variableArr[3] = new Integer32(i4);
        variableArr[4] = new Integer32(i5);
        variableArr[5] = new Integer32(1);
        this.snmpTargetParamsEntry.addRow((DefaultMOMutableRow2PC) this.snmpTargetParamsEntry.createRow(octetString.toSubIndex(true), variableArr));
        return true;
    }

    public long getAddressCacheTimeoutNanos() {
        return this.addressCacheTimeoutNanos;
    }

    public CoexistenceInfoProvider getCoexistenceProvider() {
        return this.coexistenceProvider;
    }

    public byte[] getLocalEngineID() {
        MPv3 mPv3 = (MPv3) this.messageDispatcher.getMessageProcessingModel(3);
        if (mPv3 == null) {
            return null;
        }
        return mPv3.getLocalEngineID();
    }

    public DefaultMOTable<SnmpTargetAddrEntryRow, ? extends MOColumn, ? extends MOTableModel<SnmpTargetAddrEntryRow>> getSnmpTargetAddrEntry() {
        return this.snmpTargetAddrEntry;
    }

    public DefaultMOTable<DefaultMOMutableRow2PC, MOColumn, DefaultMOMutableTableModel<DefaultMOMutableRow2PC>> getSnmpTargetParamsEntry() {
        return this.snmpTargetParamsEntry;
    }

    public Target getTarget(OctetString octetString, OctetString octetString2, OctetString octetString3) {
        SnmpTargetAddrEntryRow row = this.snmpTargetAddrEntryModel.getRow(octetString.toSubIndex(true));
        if (row != null) {
            return row.getTarget(octetString2, octetString3);
        }
        return null;
    }

    public Collection<SnmpTargetAddrEntryRow> getTargetAddrRowsForTag(OctetString octetString) {
        ArrayList arrayList;
        Set<SnmpTargetAddrEntryRow> set = this.snmpTargetAddrTagIndex.get(octetString);
        if (set == null) {
            return Collections.emptySet();
        }
        synchronized (set) {
            arrayList = new ArrayList(set);
        }
        return arrayList;
    }

    public Address getTargetAddress(OctetString octetString) {
        SnmpTargetAddrEntryRow row = this.snmpTargetAddrEntryModel.getRow(octetString.toSubIndex(true));
        if (row != null) {
            return row.getAddress();
        }
        return null;
    }

    public MOTableRow getTargetParamsRow(OctetString octetString) {
        if (octetString == null) {
            return null;
        }
        return this.snmpTargetParamsEntryModel.getRow(octetString.toSubIndex(true));
    }

    public SnmpTlsTmMib getTlsTmMib() {
        return this.tlsTmMib;
    }

    @Override // org.snmp4j.event.CounterListener
    public void incrementCounter(CounterEvent counterEvent) {
        if (counterEvent.getOid().equals(this.snmpUnavailableContexts.getOid())) {
            ((Counter32) this.snmpUnavailableContexts.getValue()).increment();
            counterEvent.setCurrentValue(this.snmpUnavailableContexts.getValue());
        } else if (counterEvent.getOid().equals(this.snmpUnknownContexts.getOid())) {
            ((Counter32) this.snmpUnknownContexts.getValue()).increment();
            counterEvent.setCurrentValue(this.snmpUnknownContexts.getValue());
        }
    }

    @Override // org.snmp4j.agent.MOGroup
    public void registerMOs(MOServer mOServer, OctetString octetString) throws DuplicateRegistrationException {
        mOServer.register(this.snmpTargetSpinLock, octetString);
        mOServer.register(this.snmpUnknownContexts, octetString);
        mOServer.register(this.snmpUnavailableContexts, octetString);
        mOServer.register(this.snmpTargetParamsEntry, octetString);
        mOServer.register(this.snmpTargetAddrEntry, octetString);
    }

    protected void removeRowFromTargetAddrTagIndex(MOTableRow mOTableRow) {
        Set<OctetString> tags = SnmpTagList.getTags((OctetString) mOTableRow.getValue(4));
        if (tags == null || this.snmpTargetAddrTagIndex == null) {
            return;
        }
        for (OctetString octetString : tags) {
            Set<SnmpTargetAddrEntryRow> set = this.snmpTargetAddrTagIndex.get(octetString);
            if (set != null) {
                synchronized (set) {
                    set.remove(mOTableRow);
                    if (set.isEmpty()) {
                        this.snmpTargetAddrTagIndex.remove(octetString);
                    }
                }
            }
        }
    }

    public MOTableRow removeTargetAddress(OctetString octetString) {
        MOTableRow mOTableRowRemoveRow = this.snmpTargetAddrEntry.removeRow(octetString.toSubIndex(true));
        if (mOTableRowRemoveRow != null) {
            removeRowFromTargetAddrTagIndex(mOTableRowRemoveRow);
        }
        return mOTableRowRemoveRow;
    }

    public MOTableRow removeTargetParams(OctetString octetString) {
        return this.snmpTargetParamsEntry.removeRow(octetString.toSubIndex(true));
    }

    @Override // org.snmp4j.agent.mo.MOTableRowListener
    public void rowChanged(MOTableRowEvent mOTableRowEvent) {
        if (mOTableRowEvent.getType() == 3 && (mOTableRowEvent.getRow() instanceof SnmpTargetAddrEntryRow)) {
            Variable[] variableArr = new Variable[mOTableRowEvent.getRow().size()];
            variableArr[4] = new OctetString();
            ((SnmpTargetAddrEntryRow) mOTableRowEvent.getRow()).updateUserObject(new DefaultMOTableRow(mOTableRowEvent.getRow().getIndex(), variableArr));
        }
    }

    public void setAddressCacheTimeoutNanos(long j2) {
        this.addressCacheTimeoutNanos = j2;
    }

    public void setCoexistenceProvider(CoexistenceInfoProvider coexistenceInfoProvider) {
        this.coexistenceProvider = coexistenceInfoProvider;
    }

    public void setTlsTmMib(SnmpTlsTmMib snmpTlsTmMib) {
        this.tlsTmMib = snmpTlsTmMib;
    }

    @Override // org.snmp4j.agent.MOGroup
    public void unregisterMOs(MOServer mOServer, OctetString octetString) {
        mOServer.unregister(this.snmpTargetSpinLock, octetString);
        mOServer.unregister(this.snmpUnknownContexts, octetString);
        mOServer.unregister(this.snmpUnavailableContexts, octetString);
        mOServer.unregister(this.snmpTargetParamsEntry, octetString);
        mOServer.unregister(this.snmpTargetAddrEntry, octetString);
    }

    public MOTableRow getTargetParamsRow(OctetString octetString, boolean z) {
        MOTableRow targetParamsRow = getTargetParamsRow(octetString);
        if (!z || targetParamsRow == null || ((Integer32) targetParamsRow.getValue(5)).getValue() == 1) {
            return targetParamsRow;
        }
        return null;
    }
}