package org.snmp4j.agent.mo.snmp;

import java.util.Iterator;
import java.util.Vector;
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.DefaultMOMutableRow2PC;
import org.snmp4j.agent.mo.DefaultMOMutableTableModel;
import org.snmp4j.agent.mo.DefaultMOTable;
import org.snmp4j.agent.mo.MOAccessImpl;
import org.snmp4j.agent.mo.MOColumn;
import org.snmp4j.agent.mo.MOMutableRow2PC;
import org.snmp4j.agent.mo.MOScalar;
import org.snmp4j.agent.mo.MOTableIndex;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.agent.mo.MOTableRowEvent;
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.request.SubRequest;
import org.snmp4j.event.CounterEvent;
import org.snmp4j.event.CounterListener;
import org.snmp4j.event.UsmUserEvent;
import org.snmp4j.event.UsmUserListener;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.security.AuthenticationProtocol;
import org.snmp4j.security.PrivacyProtocol;
import org.snmp4j.security.SecurityProtocols;
import org.snmp4j.security.USM;
import org.snmp4j.security.UsmUser;
import org.snmp4j.security.UsmUserEntry;
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 UsmMIB implements MOGroup, CounterListener, MOValueValidationListener, MOTableRowListener<MOMutableRow2PC>, UsmUserListener {
    public static final int colUsmUserAuthKey = 14;
    public static final int colUsmUserAuthKeyChange = 3;
    public static final int colUsmUserAuthPassword = 11;
    public static final int colUsmUserAuthProtocol = 2;
    public static final int colUsmUserCloneFrom = 1;
    public static final int colUsmUserLocalizationEngineID = 13;
    public static final int colUsmUserOwnAuthKeyChange = 4;
    public static final int colUsmUserOwnPrivKeyChange = 7;
    public static final int colUsmUserPrivKey = 15;
    public static final int colUsmUserPrivKeyChange = 6;
    public static final int colUsmUserPrivPassword = 12;
    public static final int colUsmUserPrivProtocol = 5;
    public static final int colUsmUserPublic = 8;
    public static final int colUsmUserSecurityName = 0;
    public static final int colUsmUserStatus = 10;
    public static final int colUsmUserStorageType = 9;
    private SecurityProtocols securityProtocols;
    private USM usm;
    private volatile boolean usmEventProcessing;
    private MOScalar[] usmStats;
    private DefaultMOTable<MOMutableRow2PC, MOColumn, DefaultMOMutableTableModel<MOMutableRow2PC>> usmUserEntry;
    private TestAndIncr usmUserSpinLock;
    private UsmTableModel usmUserTableModel;
    private static final LogAdapter logger = LogFactory.getLogger(UsmMIB.class);
    public static final OID noAuthProtocol = new OID(new int[]{1, 3, 6, 1, 6, 3, 10, 1, 1, 1});
    public static final OID noPrivProtocol = new OID(new int[]{1, 3, 6, 1, 6, 3, 10, 1, 2, 1});
    public static final OID usmUserSpinLockOID = new OID(new int[]{1, 3, 6, 1, 6, 3, 15, 1, 2, 1, 0});
    public static final OID usmUserEntryOID = new OID(new int[]{1, 3, 6, 1, 6, 3, 15, 1, 2, 2, 1});
    private static final int[][] keyChangeColumns = {new int[]{3, 4}, new int[]{6, 7}};
    private static final OID usmStatsPrefix = new OID(SnmpConstants.usmStatsUnsupportedSecLevels.getValue(), 0, SnmpConstants.usmStatsUnsupportedSecLevels.size() - 2);
    private static final OID[] usmStatOIDs = {SnmpConstants.usmStatsUnsupportedSecLevels, SnmpConstants.usmStatsNotInTimeWindows, SnmpConstants.usmStatsUnknownUserNames, SnmpConstants.usmStatsUnknownEngineIDs, SnmpConstants.usmStatsWrongDigests, SnmpConstants.usmStatsDecryptionErrors};

    class UsmRowPointer extends RowPointer {
        public UsmRowPointer(int i2, MOAccess mOAccess, OID oid, boolean z) {
            super(i2, mOAccess, oid, z);
        }

        @Override // org.snmp4j.agent.mo.snmp.RowPointer, org.snmp4j.agent.mo.MOMutableColumn
        public void prepare(SubRequest subRequest, MOTableRow mOTableRow, MOTableRow mOTableRow2, int i2) {
            super.prepare(subRequest, mOTableRow, mOTableRow2, i2);
            if (subRequest.hasError()) {
                return;
            }
            if (getTargetTable().getCellInfo((OID) subRequest.getVariableBinding().getVariable()).getIndex().equals(mOTableRow.getIndex())) {
                subRequest.getStatus().setErrorStatus(12);
            }
        }

        @Override // org.snmp4j.agent.mo.MOColumn
        public OID getValue(MOTableRow mOTableRow, int i2) {
            return SnmpConstants.zeroDotZero;
        }
    }

    public class UsmTableModel extends DefaultMOMutableTableModel<MOMutableRow2PC> {
        private MOTableIndex indexDef;

        public UsmTableModel(MOTableIndex mOTableIndex) {
            this.indexDef = mOTableIndex;
        }

        public MOTableIndex getIndexDef() {
            return this.indexDef;
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableTableModel, org.snmp4j.agent.mo.MOTableRowFactory
        public MOMutableRow2PC createRow(OID oid, Variable[] variableArr) {
            if (variableArr.length < 16) {
                Variable[] variableArr2 = new Variable[16];
                System.arraycopy(variableArr, 0, variableArr2, 0, variableArr.length);
                variableArr = variableArr2;
            }
            return UsmMIB.this.new UsmTableRow(this, oid, variableArr);
        }
    }

    public class UsmTableRow extends DefaultMOMutableRow2PC {
        private boolean cloned;
        private UsmTableModel tableModel;

        public UsmTableRow(UsmTableModel usmTableModel, OID oid, Variable[] variableArr) {
            super(oid, variableArr);
            this.cloned = false;
            this.tableModel = usmTableModel;
        }

        private OID getCloneFromIndex(MOTableRow mOTableRow) {
            OID oid = (OID) mOTableRow.getValue(1);
            if (oid == null) {
                oid = (OID) getValue(1);
            }
            if (oid == null || oid.size() <= UsmMIB.usmUserEntryOID.size()) {
                return null;
            }
            return new OID(oid.getValue(), UsmMIB.usmUserEntryOID.size() + 1, oid.size() - (UsmMIB.usmUserEntryOID.size() + 1));
        }

        /* JADX INFO: Access modifiers changed from: private */
        public OctetString[] getIndexValues() {
            Variable[] indexValues = getIndexDef().getIndexValues(getIndex());
            return new OctetString[]{(OctetString) indexValues[0], (OctetString) indexValues[1]};
        }

        /* JADX INFO: Access modifiers changed from: private */
        public UsmUserEntry getUserEntry() {
            Variable[] indexValues = getIndexDef().getIndexValues(getIndex());
            return UsmMIB.this.usm.getUser((OctetString) indexValues[0], (OctetString) indexValues[1]);
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableRow2PC
        public void cleanupRow(SubRequest subRequest, DefaultMOTable.ChangeSet changeSet) {
            setUserObject(null);
        }

        /* JADX WARN: Removed duplicated region for block: B:61:0x0132 A[Catch: all -> 0x0179, TryCatch #0 {, blocks: (B:4:0x0005, B:8:0x000d, B:10:0x002b, B:12:0x0047, B:14:0x0068, B:16:0x0074, B:18:0x007a, B:27:0x009a, B:29:0x009f, B:32:0x00aa, B:36:0x00b8, B:38:0x00c0, B:39:0x00c8, B:41:0x00d1, B:43:0x00e1, B:45:0x00e7, B:47:0x00ef, B:48:0x00f7, B:49:0x00fe, B:50:0x0102, B:51:0x0108, B:53:0x0116, B:59:0x012a, B:61:0x0132, B:67:0x0146, B:69:0x016a, B:74:0x0174, B:64:0x0138, B:65:0x013f, B:56:0x011c, B:57:0x0123, B:20:0x0080, B:22:0x0086, B:24:0x0092, B:13:0x005e), top: B:82:0x0005 }] */
        /* JADX WARN: Removed duplicated region for block: B:65:0x013f A[Catch: all -> 0x0179, TryCatch #0 {, blocks: (B:4:0x0005, B:8:0x000d, B:10:0x002b, B:12:0x0047, B:14:0x0068, B:16:0x0074, B:18:0x007a, B:27:0x009a, B:29:0x009f, B:32:0x00aa, B:36:0x00b8, B:38:0x00c0, B:39:0x00c8, B:41:0x00d1, B:43:0x00e1, B:45:0x00e7, B:47:0x00ef, B:48:0x00f7, B:49:0x00fe, B:50:0x0102, B:51:0x0108, B:53:0x0116, B:59:0x012a, B:61:0x0132, B:67:0x0146, B:69:0x016a, B:74:0x0174, B:64:0x0138, B:65:0x013f, B:56:0x011c, B:57:0x0123, B:20:0x0080, B:22:0x0086, B:24:0x0092, B:13:0x005e), top: B:82:0x0005 }] */
        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableRow2PC
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public synchronized void commitRow(org.snmp4j.agent.request.SubRequest r18, org.snmp4j.agent.mo.MOTableRow r19) {
            /*
                Method dump skipped, instruction units count: 382
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.mo.snmp.UsmMIB.UsmTableRow.commitRow(org.snmp4j.agent.request.SubRequest, org.snmp4j.agent.mo.MOTableRow):void");
        }

        public boolean containsHiddenValues() {
            int i2 = 11;
            while (true) {
                Variable[] variableArr = this.values;
                if (i2 >= variableArr.length) {
                    return false;
                }
                if (variableArr[i2] != null) {
                    return true;
                }
                i2++;
            }
        }

        public AuthenticationProtocol getAuthProtocol(MOTableRow mOTableRow) {
            return UsmMIB.this.securityProtocols.getAuthenticationProtocol(getAuthProtocolOID(mOTableRow));
        }

        public OID getAuthProtocolOID(MOTableRow mOTableRow) {
            OID oid = mOTableRow.getValue(1) == null ? (OID) mOTableRow.getValue(2) : null;
            if (oid == null) {
                oid = (OID) getValue(2);
            }
            if (UsmMIB.noAuthProtocol.equals(oid)) {
                return null;
            }
            return oid;
        }

        public MOTableIndex getIndexDef() {
            return this.tableModel.getIndexDef();
        }

        public PrivacyProtocol getPrivProtocol(MOTableRow mOTableRow) {
            return UsmMIB.this.securityProtocols.getPrivacyProtocol(getPrivProtocolOID(mOTableRow));
        }

        public OID getPrivProtocolOID(MOTableRow mOTableRow) {
            OID oid = mOTableRow.getValue(1) == null ? (OID) mOTableRow.getValue(5) : null;
            if (oid == null) {
                oid = (OID) getValue(5);
            }
            if (UsmMIB.noPrivProtocol.equals(oid)) {
                return null;
            }
            return oid;
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.DefaultMOTableRow, org.snmp4j.agent.mo.MOTableRow
        public Variable getValue(int i2) {
            UsmUserEntry userEntry;
            if (i2 > 10 && (userEntry = getUserEntry()) != null) {
                switch (i2) {
                    case 11:
                        setValue(i2, userEntry.getUsmUser().getAuthenticationPassphrase());
                        break;
                    case 12:
                        setValue(i2, userEntry.getUsmUser().getPrivacyPassphrase());
                        break;
                    case 13:
                        setValue(i2, userEntry.getUsmUser().isLocalized() ? userEntry.getUsmUser().getLocalizationEngineID() : null);
                        break;
                    case 14:
                        byte[] authenticationKey = userEntry.getAuthenticationKey();
                        setValue(i2, authenticationKey != null ? new OctetString(authenticationKey) : null);
                        break;
                    case 15:
                        byte[] privacyKey = userEntry.getPrivacyKey();
                        setValue(i2, privacyKey != null ? new OctetString(privacyKey) : null);
                        break;
                }
            }
            return super.getValue(i2);
        }

        public boolean isCloned() {
            return this.cloned;
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableRow2PC
        public void prepare(SubRequest subRequest, MOTableRow mOTableRow, int i2) {
            if (i2 != 2) {
                if (i2 == 5 && !((OID) subRequest.getVariableBinding().getVariable()).equals(UsmMIB.noPrivProtocol)) {
                    subRequest.getStatus().setErrorStatus(12);
                    return;
                }
                return;
            }
            if (!((OID) subRequest.getVariableBinding().getVariable()).equals(UsmMIB.noAuthProtocol)) {
                subRequest.getStatus().setErrorStatus(12);
                return;
            }
            OID oid = null;
            Variable value = mOTableRow.getValue(5);
            if (value instanceof OID) {
                oid = (OID) value;
            } else if (value == null) {
                oid = (OID) getValue(5);
            }
            if (oid == null || !oid.equals(UsmMIB.noPrivProtocol)) {
                subRequest.getStatus().setErrorStatus(12);
            }
        }

        public void setCloned(boolean z) {
            this.cloned = z;
        }

        @Override // org.snmp4j.agent.mo.DefaultMOMutableRow2PC, org.snmp4j.agent.mo.MOMutableRow2PC
        public void undoRow(SubRequest subRequest, DefaultMOTable.ChangeSet changeSet) {
            if (getUserObject() != null) {
                UsmMIB.this.usm.updateUser((UsmUserEntry) getUserObject());
            }
        }
    }

    public UsmMIB(USM usm, SecurityProtocols securityProtocols) {
        this.usm = usm;
        this.securityProtocols = securityProtocols;
        usm.getCounterSupport().addCounterListener(this);
        createUsmStats();
        createUsmUser();
    }

    private OID createIndex(OctetString octetString, OctetString octetString2) {
        if (octetString == null || octetString.length() == 0) {
            octetString = this.usm.getLocalEngineID();
        }
        OID subIndex = octetString.toSubIndex(false);
        subIndex.append(octetString2.toSubIndex(false));
        return subIndex;
    }

    private void createUsmStats() {
        this.usmStats = new MOScalar[usmStatOIDs.length];
        int i2 = 0;
        while (true) {
            MOScalar[] mOScalarArr = this.usmStats;
            if (i2 >= mOScalarArr.length) {
                return;
            }
            mOScalarArr[i2] = new MOScalar(usmStatOIDs[i2], MOAccessImpl.ACCESS_READ_ONLY, new Counter32(0L));
            i2++;
        }
    }

    private void createUsmUser() {
        this.usmUserSpinLock = new TestAndIncr(usmUserSpinLockOID);
        MOTableSubIndex[] mOTableSubIndexArr = {new MOTableSubIndex(4, 5, 32), new MOTableSubIndex(4, 1, 32)};
        MOColumn[] mOColumnArr = {new SnmpAdminString(3, MOAccessImpl.ACCESS_READ_ONLY, null, false), new UsmRowPointer(4, MOAccessImpl.ACCESS_READ_CREATE, null, true), new AutonomousType(5, MOAccessImpl.ACCESS_READ_CREATE, noAuthProtocol, true), new UsmKeyChange(6, MOAccessImpl.ACCESS_READ_CREATE, 0), new UsmOwnKeyChange(7, MOAccessImpl.ACCESS_READ_CREATE, 0), new AutonomousType(8, MOAccessImpl.ACCESS_READ_CREATE, noPrivProtocol, true), new UsmKeyChange(9, MOAccessImpl.ACCESS_READ_CREATE, 1), new UsmOwnKeyChange(10, MOAccessImpl.ACCESS_READ_CREATE, 1), new SnmpAdminString(11, MOAccessImpl.ACCESS_READ_CREATE, new OctetString(), true, 0, 32), new StorageType(12, MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true), new RowStatus(13, MOAccessImpl.ACCESS_READ_CREATE)};
        MOTableIndex mOTableIndex = new MOTableIndex(mOTableSubIndexArr, false);
        this.usmUserTableModel = new UsmTableModel(mOTableIndex);
        this.usmUserEntry = new DefaultMOTable<MOMutableRow2PC, MOColumn, DefaultMOMutableTableModel<MOMutableRow2PC>>(usmUserEntryOID, mOTableIndex, mOColumnArr, this.usmUserTableModel) { // from class: org.snmp4j.agent.mo.snmp.UsmMIB.1
            @Override // org.snmp4j.agent.mo.DefaultMOTable
            protected void fireRowChanged(MOTableRowEvent<MOMutableRow2PC> mOTableRowEvent) {
                Vector<MOTableRowListener<R>> vector = this.moTableRowListeners;
                if (vector != 0) {
                    Iterator it = vector.iterator();
                    while (it.hasNext()) {
                        MOTableRowListener mOTableRowListener = (MOTableRowListener) it.next();
                        if (!UsmMIB.this.usmEventProcessing || !(mOTableRowListener instanceof UsmMIB)) {
                            mOTableRowListener.rowChanged(mOTableRowEvent);
                        }
                    }
                }
            }
        };
        ((AutonomousType) mOColumnArr[2]).addMOValueValidationListener(this);
        ((AutonomousType) mOColumnArr[5]).addMOValueValidationListener(this);
        ((UsmRowPointer) mOColumnArr[1]).setTargetTable(this.usmUserEntry);
        this.usmUserEntry.addMOTableRowListener(this);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static byte[] getKey(UsmUserEntry usmUserEntry, int i2) {
        return i2 == 0 ? usmUserEntry.getAuthenticationKey() : usmUserEntry.getPrivacyKey();
    }

    private Variable[] getValuesFromUsmUser(UsmUserEntry usmUserEntry) {
        Variable[] variableArr = new Variable[this.usmUserEntry.getColumnCount() + 5];
        variableArr[0] = usmUserEntry.getUsmUser().getSecurityName();
        variableArr[1] = null;
        variableArr[2] = usmUserEntry.getUsmUser().getAuthenticationProtocol();
        variableArr[3] = null;
        variableArr[4] = null;
        variableArr[5] = usmUserEntry.getUsmUser().getPrivacyProtocol();
        variableArr[6] = null;
        variableArr[7] = null;
        variableArr[8] = new OctetString();
        variableArr[9] = new Integer32(3);
        variableArr[10] = new Integer32(1);
        variableArr[11] = usmUserEntry.getUsmUser().getAuthenticationPassphrase();
        variableArr[12] = usmUserEntry.getUsmUser().getPrivacyPassphrase();
        variableArr[13] = usmUserEntry.getUsmUser().getLocalizationEngineID();
        variableArr[14] = usmUserEntry.getAuthenticationKey() == null ? null : new OctetString(usmUserEntry.getAuthenticationKey());
        variableArr[15] = usmUserEntry.getPrivacyKey() != null ? new OctetString(usmUserEntry.getPrivacyKey()) : null;
        return variableArr;
    }

    private static boolean isKeyChanged(MOTableRow mOTableRow, int i2) {
        OctetString octetString = (OctetString) mOTableRow.getValue(i2);
        return octetString != null && octetString.length() > 0;
    }

    public DefaultMOTable getUsmUserEntry() {
        return this.usmUserEntry;
    }

    @Override // org.snmp4j.event.CounterListener
    public void incrementCounter(CounterEvent counterEvent) {
        if (!counterEvent.getOid().startsWith(usmStatsPrefix) || counterEvent.getOid().size() <= usmStatsPrefix.size()) {
            return;
        }
        Counter32 counter32 = (Counter32) this.usmStats[counterEvent.getOid().get(usmStatsPrefix.size()) - 1].getValue();
        counter32.increment();
        counterEvent.setCurrentValue((Counter32) counter32.clone());
    }

    @Override // org.snmp4j.agent.MOGroup
    public void registerMOs(MOServer mOServer, OctetString octetString) throws DuplicateRegistrationException {
        for (MOScalar mOScalar : this.usmStats) {
            mOServer.register(mOScalar, octetString);
        }
        mOServer.register(this.usmUserSpinLock, octetString);
        mOServer.register(this.usmUserEntry, octetString);
    }

    @Override // org.snmp4j.agent.mo.MOTableRowListener
    public synchronized void rowChanged(MOTableRowEvent mOTableRowEvent) {
        UsmUserEntry userEntry;
        UsmTableRow usmTableRow = (UsmTableRow) mOTableRowEvent.getRow();
        if (mOTableRowEvent.getType() == 1) {
            if (!usmTableRow.containsHiddenValues() && (usmTableRow.getAuthProtocolOID(usmTableRow) != null || usmTableRow.getPrivProtocolOID(usmTableRow) != null)) {
                return;
            }
            UsmUserEntry userEntry2 = usmTableRow.getUserEntry();
            if (userEntry2 != null) {
                this.usm.removeAllUsers(userEntry2.getUserName(), userEntry2.getEngineID());
            } else {
                OctetString[] indexValues = usmTableRow.getIndexValues();
                if (usmTableRow.size() > 13 && usmTableRow.getValue(11) != null) {
                    this.usm.addUser(indexValues[1], indexValues[0], new UsmUser(indexValues[1], usmTableRow.getAuthProtocolOID(usmTableRow), (OctetString) usmTableRow.getValue(11), usmTableRow.getPrivProtocolOID(usmTableRow), (OctetString) usmTableRow.getValue(12), (OctetString) usmTableRow.getValue(13)));
                } else if (usmTableRow.size() > 15) {
                    OctetString octetString = (OctetString) usmTableRow.getValue(14);
                    OctetString octetString2 = (OctetString) usmTableRow.getValue(15);
                    USM usm = this.usm;
                    byte[] value = indexValues[0].getValue();
                    OctetString octetString3 = indexValues[1];
                    OID authProtocolOID = usmTableRow.getAuthProtocolOID(usmTableRow);
                    byte[] value2 = null;
                    byte[] value3 = octetString == null ? null : octetString.getValue();
                    OID privProtocolOID = usmTableRow.getPrivProtocolOID(usmTableRow);
                    if (octetString2 != null) {
                        value2 = octetString2.getValue();
                    }
                    usm.addLocalizedUser(value, octetString3, authProtocolOID, value3, privProtocolOID, value2);
                } else {
                    logger.warn("Cannot add user '" + indexValues[1] + "' to the USM from USM-MIB because key information is missing");
                }
            }
        } else if (mOTableRowEvent.getType() == 3 && (userEntry = usmTableRow.getUserEntry()) != null) {
            this.usm.removeAllUsers(userEntry.getUserName(), userEntry.getEngineID());
        }
    }

    @Override // org.snmp4j.agent.MOGroup
    public void unregisterMOs(MOServer mOServer, OctetString octetString) {
        for (MOScalar mOScalar : this.usmStats) {
            mOServer.unregister(mOScalar, octetString);
        }
        mOServer.unregister(this.usmUserSpinLock, octetString);
        mOServer.unregister(this.usmUserEntry, octetString);
    }

    @Override // org.snmp4j.event.UsmUserListener
    public synchronized void usmUserChange(UsmUserEvent usmUserEvent) {
        this.usmEventProcessing = true;
        int type = usmUserEvent.getType();
        if (type == 1) {
            Variable[] valuesFromUsmUser = getValuesFromUsmUser(usmUserEvent.getUser());
            this.usmUserEntry.addRow((MOMutableRow2PC) this.usmUserEntry.createRow(createIndex(usmUserEvent.getUser().getEngineID(), usmUserEvent.getUser().getUserName()), valuesFromUsmUser));
        } else if (type != 2) {
            if (type == 3) {
                Variable[] valuesFromUsmUser2 = getValuesFromUsmUser(usmUserEvent.getUser());
                OID oidCreateIndex = createIndex(usmUserEvent.getUser().getEngineID(), usmUserEvent.getUser().getUserName());
                MOMutableRow2PC mOMutableRow2PC = (MOMutableRow2PC) ((DefaultMOMutableTableModel) this.usmUserEntry.getModel()).getRow(oidCreateIndex);
                if (mOMutableRow2PC != null) {
                    for (int i2 = 0; i2 < valuesFromUsmUser2.length; i2++) {
                        mOMutableRow2PC.setValue(i2, valuesFromUsmUser2[i2]);
                    }
                } else {
                    this.usmUserEntry.addRow((MOMutableRow2PC) this.usmUserEntry.createRow(oidCreateIndex, valuesFromUsmUser2));
                }
            }
        } else if (usmUserEvent.getUser() == null) {
            this.usmUserTableModel.clear();
        } else {
            this.usmUserEntry.removeRow(createIndex(usmUserEvent.getUser().getEngineID(), usmUserEvent.getUser().getUserName()));
        }
        this.usmEventProcessing = false;
    }

    @Override // org.snmp4j.agent.mo.MOValueValidationListener
    public void validate(MOValueValidationEvent mOValueValidationEvent) {
        if (mOValueValidationEvent.getSource() instanceof MOColumn) {
            int columnID = ((MOColumn) mOValueValidationEvent.getSource()).getColumnID() - 4;
            if (columnID == 2) {
                if (noAuthProtocol.equals((OID) mOValueValidationEvent.getNewValue()) || SecurityProtocols.getInstance().getAuthenticationProtocol((OID) mOValueValidationEvent.getNewValue()) != null) {
                    return;
                }
                mOValueValidationEvent.setValidationStatus(10);
                return;
            }
            if (columnID != 5) {
                return;
            }
            OID oid = (OID) mOValueValidationEvent.getNewValue();
            if (noPrivProtocol.equals(oid) || SecurityProtocols.getInstance().getPrivacyProtocol(oid) != null) {
                return;
            }
            mOValueValidationEvent.setValidationStatus(10);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static boolean isKeyChanged(MOTableRow mOTableRow) {
        return isKeyChanged(mOTableRow, 4) || isKeyChanged(mOTableRow, 3) || isKeyChanged(mOTableRow, 7) || isKeyChanged(mOTableRow, 6);
    }
}