package org.snmp4j.agent;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Vector;
import org.snmp4j.CommandResponder;
import org.snmp4j.CommandResponderEvent;
import org.snmp4j.MessageDispatcher;
import org.snmp4j.MessageException;
import org.snmp4j.PDU;
import org.snmp4j.SNMP4JSettings;
import org.snmp4j.ScopedPDU;
import org.snmp4j.agent.mo.lock.LockRequest;
import org.snmp4j.agent.mo.snmp.CoexistenceInfo;
import org.snmp4j.agent.mo.snmp.CoexistenceInfoProvider;
import org.snmp4j.agent.request.Request;
import org.snmp4j.agent.request.RequestFactory;
import org.snmp4j.agent.request.SnmpRequest;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.agent.security.VACM;
import org.snmp4j.agent.util.TemporaryList;
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.mp.SnmpConstants;
import org.snmp4j.mp.StateReference;
import org.snmp4j.mp.StatusInformation;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TimeTicks;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.util.WorkerPool;
import org.snmp4j.util.WorkerTask;

/* JADX INFO: loaded from: classes.dex */
public class CommandProcessor implements CommandResponder, NotificationOriginator {
    private static final int MAX_INTERNAL_REQUEST_TIMEOUT = 300000;
    private static final LogAdapter logger = LogFactory.getLogger(CommandProcessor.class);
    protected CoexistenceInfoProvider coexistenceProvider;
    private transient Vector<CounterListener> counterListeners;
    protected Vector<MOServer> moServers;
    protected NotificationOriginator notificationOriginator;
    protected ProxyMap proxyForwarder;
    protected RequestFactory<CommandResponderEvent, PDU, SnmpRequest> requestFactory;
    protected TemporaryList<Request> requestList;
    protected WorkerPool threadPool = null;
    protected VACM vacm = null;
    protected List<OctetString> ownContextEngineIDs = new ArrayList(2);
    protected final Vector<RequestHandler<SnmpRequest>> pduHandler = new Vector<>();

    /* JADX INFO: renamed from: org.snmp4j.agent.CommandProcessor$1, reason: invalid class name */
    static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$org$snmp4j$agent$mo$lock$LockRequest$LockStatus;

        static {
            int[] iArr = new int[LockRequest.LockStatus.values().length];
            $SwitchMap$org$snmp4j$agent$mo$lock$LockRequest$LockStatus = iArr;
            try {
                iArr[LockRequest.LockStatus.locked.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$org$snmp4j$agent$mo$lock$LockRequest$LockStatus[LockRequest.LockStatus.lockedAfterTimeout.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
        }
    }

    class Command implements WorkerTask {
        private CoexistenceInfo cinfo;
        private CommandResponderEvent request;

        public Command(CommandResponderEvent commandResponderEvent, CoexistenceInfo coexistenceInfo) {
            this.request = commandResponderEvent;
            this.cinfo = coexistenceInfo;
        }

        @Override // org.snmp4j.util.WorkerTask
        public void interrupt() {
        }

        @Override // org.snmp4j.util.WorkerTask
        public void join() throws InterruptedException {
        }

        @Override // java.lang.Runnable
        public void run() {
            CommandProcessor.this.dispatchCommand(this.request, this.cinfo);
        }

        @Override // org.snmp4j.util.WorkerTask
        public void terminate() {
        }
    }

    static class DefaultRequestFactory implements RequestFactory<CommandResponderEvent, PDU, SnmpRequest> {
        DefaultRequestFactory() {
        }

        @Override // org.snmp4j.agent.request.RequestFactory
        public SnmpRequest createRequest(CommandResponderEvent commandResponderEvent, CoexistenceInfo coexistenceInfo) {
            return new SnmpRequest(commandResponderEvent, coexistenceInfo);
        }
    }

    class GetBulkHandler implements RequestHandler<SnmpRequest> {
        GetBulkHandler() {
        }

        @Override // org.snmp4j.agent.RequestHandler
        public boolean isSupported(int i2) {
            return i2 == -91;
        }

        @Override // org.snmp4j.agent.RequestHandler
        public void processPdu(SnmpRequest snmpRequest, MOServer mOServer) {
            CommandProcessor.initRequestPhase(snmpRequest);
            OctetString context = snmpRequest.getContext();
            int nonRepeaters = snmpRequest.getNonRepeaters();
            try {
                Iterator<SnmpRequest.SnmpSubRequest> it = snmpRequest.iterator();
                for (int i2 = 0; i2 < nonRepeaters && it.hasNext(); i2++) {
                    SnmpRequest.SnmpSubRequest next = it.next();
                    if (!next.isComplete()) {
                        CommandProcessor.this.processNextSubRequest(snmpRequest, mOServer, context, next);
                    }
                }
                if (snmpRequest.getMaxRepetitions() <= 0) {
                    while (it.hasNext()) {
                        it.next().completed();
                    }
                    return;
                }
                while (it.hasNext()) {
                    SnmpRequest.SnmpSubRequest next2 = it.next();
                    if (!next2.isComplete()) {
                        CommandProcessor.this.processNextSubRequest(snmpRequest, mOServer, context, next2);
                        next2.updateNextRepetition();
                    }
                }
            } catch (NoSuchElementException unused) {
                if (CommandProcessor.logger.isDebugEnabled()) {
                    CommandProcessor.logger.debug("GETBULK request response PDU size limit reached");
                }
            }
        }
    }

    class GetHandler implements RequestHandler<SnmpRequest> {
        GetHandler() {
        }

        @Override // org.snmp4j.agent.RequestHandler
        public boolean isSupported(int i2) {
            return i2 == -96;
        }

        /* JADX WARN: Removed duplicated region for block: B:42:0x00f2  */
        @Override // org.snmp4j.agent.RequestHandler
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public void processPdu(org.snmp4j.agent.request.SnmpRequest r20, org.snmp4j.agent.MOServer r21) {
            /*
                Method dump skipped, instruction units count: 261
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.CommandProcessor.GetHandler.processPdu(org.snmp4j.agent.request.SnmpRequest, org.snmp4j.agent.MOServer):void");
        }
    }

    class GetNextHandler implements RequestHandler<SnmpRequest> {
        GetNextHandler() {
        }

        @Override // org.snmp4j.agent.RequestHandler
        public boolean isSupported(int i2) {
            return i2 == -95;
        }

        @Override // org.snmp4j.agent.RequestHandler
        public void processPdu(SnmpRequest snmpRequest, MOServer mOServer) {
            CommandProcessor.initRequestPhase(snmpRequest);
            OctetString context = snmpRequest.getContext();
            try {
                Iterator<SnmpRequest.SnmpSubRequest> it = snmpRequest.iterator();
                while (it.hasNext()) {
                    CommandProcessor.this.processNextSubRequest(snmpRequest, mOServer, context, it.next());
                }
            } catch (NoSuchElementException e2) {
                if (CommandProcessor.logger.isDebugEnabled()) {
                    e2.printStackTrace();
                }
                CommandProcessor.logger.error("SubRequest not found");
                snmpRequest.setErrorStatus(5);
            }
        }
    }

    class ProxyCommand implements WorkerTask {
        private ProxyForwarder forwarder;
        private ProxyForwardRequest request;

        public ProxyCommand(ProxyForwarder proxyForwarder, ProxyForwardRequest proxyForwardRequest) {
            this.forwarder = proxyForwarder;
            this.request = proxyForwardRequest;
        }

        @Override // org.snmp4j.util.WorkerTask
        public void interrupt() {
        }

        @Override // org.snmp4j.util.WorkerTask
        public void join() throws InterruptedException {
        }

        @Override // java.lang.Runnable
        public void run() {
            if (this.forwarder.forward(this.request)) {
                PDU responsePDU = this.request.getResponsePDU();
                if (responsePDU != null) {
                    CommandProcessor.this.sendResponse(this.request.getCommandEvent(), responsePDU);
                    return;
                }
                return;
            }
            if (this.request.getProxyType() != 3) {
                CounterEvent counterEvent = new CounterEvent(this, SnmpConstants.snmpProxyDrops);
                CommandProcessor.this.fireIncrementCounter(counterEvent);
                CommandResponderEvent commandEvent = this.request.getCommandEvent();
                if (commandEvent.getMessageProcessingModel() != 3 || commandEvent.getStateReference() == null) {
                    return;
                }
                ScopedPDU scopedPDU = new ScopedPDU();
                scopedPDU.setType(-88);
                scopedPDU.setContextEngineID(this.request.getContextEngineID());
                scopedPDU.setContextName(this.request.getContext());
                scopedPDU.add(new VariableBinding(SnmpConstants.snmpProxyDrops, counterEvent.getCurrentValue()));
                CommandProcessor.this.sendResponse(this.request.getCommandEvent(), scopedPDU);
            }
        }

        @Override // org.snmp4j.util.WorkerTask
        public void terminate() {
        }
    }

    class SetHandler implements RequestHandler<SnmpRequest> {
        SetHandler() {
        }

        protected void cleanup(OctetString octetString, SnmpRequest snmpRequest, MOServer mOServer) {
            try {
                for (SnmpRequest.SnmpSubRequest snmpSubRequest : snmpRequest) {
                    if (!snmpSubRequest.isComplete()) {
                        OID oid = snmpSubRequest.getVariableBinding().getOid();
                        ManagedObject targetMO = snmpSubRequest.getTargetMO();
                        if (targetMO == null) {
                            targetMO = mOServer.lookup(new DefaultMOQuery(new DefaultMOContextScope(octetString, oid, true, oid, true)));
                        }
                        if (targetMO == null) {
                            snmpSubRequest.completed();
                        } else {
                            mOServer.unlock(snmpSubRequest.getRequest(), targetMO);
                            try {
                                targetMO.cleanup(snmpSubRequest);
                                snmpSubRequest.getStatus().setPhaseComplete(true);
                            } catch (Exception e2) {
                                if (CommandProcessor.logger.isDebugEnabled()) {
                                    e2.printStackTrace();
                                }
                                CommandProcessor.logger.error(e2);
                                if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                                    throw new RuntimeException(e2);
                                }
                            }
                        }
                    }
                }
            } catch (NoSuchElementException e3) {
                CommandProcessor.logger.error("Cannot find sub-request: ", e3);
                if (CommandProcessor.logger.isDebugEnabled()) {
                    e3.printStackTrace();
                }
            }
        }

        protected void commit(OctetString octetString, SnmpRequest snmpRequest, MOServer mOServer) {
            try {
                Iterator<SnmpRequest.SnmpSubRequest> it = snmpRequest.iterator();
                while (snmpRequest.getErrorStatus() == 0 && it.hasNext()) {
                    SnmpRequest.SnmpSubRequest next = it.next();
                    if (!next.isComplete()) {
                        OID oid = next.getVariableBinding().getOid();
                        ManagedObject targetMO = next.getTargetMO();
                        if (targetMO == null) {
                            targetMO = mOServer.lookup(new MOQueryWithSource(new DefaultMOContextScope(octetString, oid, true, oid, true), true, snmpRequest));
                        }
                        if (targetMO == null) {
                            next.getStatus().setErrorStatus(14);
                        } else {
                            try {
                                targetMO.commit(next);
                            } catch (Exception e2) {
                                if (CommandProcessor.logger.isDebugEnabled()) {
                                    e2.printStackTrace();
                                }
                                CommandProcessor.logger.error(e2);
                                if (next.getStatus().getErrorStatus() == 0) {
                                    next.getStatus().setErrorStatus(14);
                                }
                                if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                                    throw new RuntimeException(e2);
                                }
                            }
                        }
                    }
                }
            } catch (NoSuchElementException e3) {
                if (CommandProcessor.logger.isDebugEnabled()) {
                    e3.printStackTrace();
                }
                CommandProcessor.logger.error("Cannot find sub-request: ", e3);
                snmpRequest.setErrorStatus(5);
            }
        }

        @Override // org.snmp4j.agent.RequestHandler
        public boolean isSupported(int i2) {
            return i2 == -93;
        }

        public void prepare(OctetString octetString, SnmpRequest snmpRequest, MOServer mOServer) {
            SnmpRequest.SnmpSubRequest snmpSubRequest;
            SetHandler setHandler = this;
            try {
                Iterator<SnmpRequest.SnmpSubRequest> it = snmpRequest.iterator();
                LockRequest lockRequest = new LockRequest(snmpRequest, CommandProcessor.this.requestList.getTimeout());
                while (!snmpRequest.isPhaseComplete() && it.hasNext()) {
                    SnmpRequest.SnmpSubRequest next = it.next();
                    if (!next.isComplete()) {
                        MOScope scope = next.getScope();
                        MOQuery query = next.getQuery();
                        if (query == null) {
                            snmpSubRequest = next;
                            VACMQuery vACMQuery = CommandProcessor.this.new VACMQuery(octetString, scope.getLowerBound(), scope.isLowerIncluded(), scope.getUpperBound(), scope.isUpperIncluded(), snmpRequest.getViewName(), true, snmpRequest);
                            snmpSubRequest.setQuery(vACMQuery);
                            query = vACMQuery;
                        } else {
                            snmpSubRequest = next;
                        }
                        if (query.getScope().isCovered(new DefaultMOContextScope(octetString, scope))) {
                            ManagedObject managedObjectLookup = mOServer.lookup(query, lockRequest);
                            if (managedObjectLookup == null) {
                                if (!(query instanceof VACMQuery) || ((VACMQuery) query).isAccessAllowed(scope.getLowerBound())) {
                                    snmpSubRequest.getStatus().setErrorStatus(11);
                                    return;
                                } else {
                                    snmpSubRequest.getStatus().setErrorStatus(6);
                                    return;
                                }
                            }
                            snmpSubRequest.setTargetMO(managedObjectLookup);
                            if (lockRequest.getLockRequestStatus() == LockRequest.LockStatus.lockTimedOut) {
                                CommandProcessor.logger.warn("Set request " + snmpRequest + " failed because " + managedObjectLookup + " could not be locked");
                                if (snmpSubRequest.getStatus().getErrorStatus() == 0) {
                                    snmpSubRequest.getStatus().setErrorStatus(5);
                                }
                            } else {
                                try {
                                    managedObjectLookup.prepare(snmpSubRequest);
                                } catch (Exception e2) {
                                    CommandProcessor.logger.error("Set request " + snmpRequest + " failed with exception", e2);
                                    if (snmpSubRequest.getStatus().getErrorStatus() == 0) {
                                        snmpSubRequest.getStatus().setErrorStatus(5);
                                    }
                                    if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                                        throw new RuntimeException(e2);
                                    }
                                }
                            }
                        } else {
                            snmpSubRequest.getStatus().setErrorStatus(6);
                        }
                        setHandler = this;
                    }
                }
            } catch (NoSuchElementException e3) {
                if (CommandProcessor.logger.isDebugEnabled()) {
                    e3.printStackTrace();
                }
                CommandProcessor.logger.error("Cannot find sub-request: ", e3);
                snmpRequest.setErrorStatus(5);
            }
        }

        protected void undo(OctetString octetString, SnmpRequest snmpRequest, MOServer mOServer) {
            try {
                for (SnmpRequest.SnmpSubRequest snmpSubRequest : snmpRequest) {
                    if (!snmpSubRequest.isComplete()) {
                        OID oid = snmpSubRequest.getVariableBinding().getOid();
                        ManagedObject targetMO = snmpSubRequest.getTargetMO();
                        if (targetMO == null) {
                            targetMO = mOServer.lookup(new MOQueryWithSource(new DefaultMOContextScope(octetString, oid, true, oid, true), true, snmpRequest));
                        }
                        if (targetMO == null) {
                            snmpSubRequest.getStatus().setErrorStatus(15);
                        } else {
                            try {
                                targetMO.undo(snmpSubRequest);
                            } catch (Exception e2) {
                                if (CommandProcessor.logger.isDebugEnabled()) {
                                    e2.printStackTrace();
                                }
                                CommandProcessor.logger.error(e2);
                                if (snmpSubRequest.getStatus().getErrorStatus() == 0) {
                                    snmpSubRequest.getStatus().setErrorStatus(15);
                                }
                                if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                                    throw new RuntimeException(e2);
                                }
                            }
                        }
                    }
                }
            } catch (NoSuchElementException e3) {
                if (CommandProcessor.logger.isDebugEnabled()) {
                    e3.printStackTrace();
                }
                CommandProcessor.logger.error("Cannot find sub-request: ", e3);
                snmpRequest.setErrorStatus(5);
            }
        }

        @Override // org.snmp4j.agent.RequestHandler
        public void processPdu(SnmpRequest snmpRequest, MOServer mOServer) {
            OctetString context = snmpRequest.getContext();
            do {
                try {
                    if (snmpRequest.getPhase() < 4) {
                        int iNextPhase = snmpRequest.nextPhase();
                        if (iNextPhase == 1) {
                            prepare(context, snmpRequest, mOServer);
                        } else if (iNextPhase == 2) {
                            commit(context, snmpRequest, mOServer);
                        } else if (iNextPhase == 3) {
                            undo(context, snmpRequest, mOServer);
                        } else if (iNextPhase == 4) {
                            cleanup(context, snmpRequest, mOServer);
                            return;
                        }
                    }
                } catch (Exception e2) {
                    if (CommandProcessor.logger.isDebugEnabled()) {
                        e2.printStackTrace();
                    }
                    CommandProcessor.logger.error("Failed to process SET request, trying to clean it up...", e2);
                    if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                        throw new RuntimeException(e2);
                    }
                }
                cleanup(context, snmpRequest, mOServer);
                return;
            } while (snmpRequest.isPhaseComplete());
        }
    }

    public CommandProcessor(OctetString octetString) {
        this.ownContextEngineIDs.add(octetString);
        this.ownContextEngineIDs.add(MPv3.LOCAL_ENGINE_ID);
        this.moServers = new Vector<>();
        this.requestList = new TemporaryList<>(300000);
        this.pduHandler.add(new GetHandler());
        this.pduHandler.add(new GetNextHandler());
        this.pduHandler.add(new SetHandler());
        this.pduHandler.add(new GetBulkHandler());
        this.requestFactory = new DefaultRequestFactory();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void initRequestPhase(Request request) {
        if (request.getPhase() == -1) {
            request.nextPhase();
        }
    }

    private void sendUnknownPDUHandlersReport(CommandResponderEvent commandResponderEvent) {
        logger.info("No PDU handler found for request " + commandResponderEvent);
        CounterEvent counterEvent = new CounterEvent(this, SnmpConstants.snmpUnknownPDUHandlers);
        fireIncrementCounter(counterEvent);
        if (commandResponderEvent.getMessageProcessingModel() != 3 || !(commandResponderEvent.getPDU() instanceof ScopedPDU)) {
            PDU pdu = (PDU) commandResponderEvent.getPDU().clone();
            pdu.setErrorStatus(5);
            sendResponse(commandResponderEvent, pdu);
            return;
        }
        ScopedPDU scopedPDU = (ScopedPDU) commandResponderEvent.getPDU();
        ScopedPDU scopedPDU2 = new ScopedPDU();
        scopedPDU2.setContextEngineID(scopedPDU.getContextEngineID());
        scopedPDU2.setContextName(scopedPDU.getContextName());
        scopedPDU2.setType(-88);
        scopedPDU2.add(new VariableBinding(counterEvent.getOid(), counterEvent.getCurrentValue()));
        sendResponse(commandResponderEvent, scopedPDU2);
    }

    public synchronized void addCounterListener(CounterListener counterListener) {
        if (this.counterListeners == null) {
            this.counterListeners = new Vector<>(2);
        }
        this.counterListeners.add(counterListener);
    }

    public void addMOServer(MOServer mOServer) {
        this.moServers.add(mOServer);
    }

    public void addPduHandler(RequestHandler<SnmpRequest> requestHandler) {
        this.pduHandler.add(requestHandler);
    }

    public ProxyForwarder addProxyForwarder(ProxyForwarder proxyForwarder, OctetString octetString, int i2) {
        if (this.proxyForwarder == null) {
            this.proxyForwarder = new ProxyMap();
        }
        return this.proxyForwarder.add(proxyForwarder, octetString, i2);
    }

    protected void dispatchCommand(CommandResponderEvent commandResponderEvent, CoexistenceInfo coexistenceInfo) {
        RequestHandler<SnmpRequest> handler = getHandler(commandResponderEvent.getPDU().getType());
        if (handler != null) {
            processRequest(commandResponderEvent, coexistenceInfo, handler);
        } else {
            sendUnknownPDUHandlersReport(commandResponderEvent);
        }
    }

    protected void finalizeRequest(CommandResponderEvent commandResponderEvent, SnmpRequest snmpRequest, MOServer mOServer) {
        if (snmpRequest.isComplete()) {
            this.requestList.remove(snmpRequest);
            sendResponse(commandResponderEvent, snmpRequest.getResponse());
            if (mOServer != null) {
                release(mOServer, snmpRequest);
            }
        }
    }

    protected void fireIncrementCounter(CounterEvent counterEvent) {
        Vector<CounterListener> vector = this.counterListeners;
        if (vector != null) {
            int size = vector.size();
            for (int i2 = 0; i2 < size; i2++) {
                vector.elementAt(i2).incrementCounter(counterEvent);
            }
        }
    }

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

    public OctetString getContextEngineID() {
        return this.ownContextEngineIDs.get(0);
    }

    protected RequestHandler<SnmpRequest> getHandler(int i2) {
        synchronized (this.pduHandler) {
            for (RequestHandler<SnmpRequest> requestHandler : this.pduHandler) {
                if (requestHandler.isSupported(i2)) {
                    return requestHandler;
                }
            }
            return null;
        }
    }

    public int getInternalRequestTimeout() {
        return this.requestList.getTimeout();
    }

    public NotificationOriginator getNotificationOriginator() {
        return this.notificationOriginator;
    }

    public ProxyMap getProxyForwarder() {
        return this.proxyForwarder;
    }

    public TemporaryList<Request> getRequestList() {
        return this.requestList;
    }

    public MOServer getServer(OctetString octetString) {
        for (MOServer mOServer : this.moServers) {
            if (mOServer.isContextSupported(octetString)) {
                return mOServer;
            }
        }
        return null;
    }

    public VACM getVacm() {
        return this.vacm;
    }

    protected OctetString getViewName(CommandResponderEvent commandResponderEvent, CoexistenceInfo coexistenceInfo, int i2) {
        return this.vacm.getViewName(coexistenceInfo.getContextName(), coexistenceInfo.getSecurityName(), commandResponderEvent.getSecurityModel(), commandResponderEvent.getSecurityLevel(), i2);
    }

    @Override // org.snmp4j.agent.NotificationOriginator
    public Object notify(OctetString octetString, OID oid, VariableBinding[] variableBindingArr) {
        return notify(octetString, oid, null, variableBindingArr);
    }

    /*  JADX ERROR: JadxRuntimeException in pass: ConstructorVisitor
        jadx.core.utils.exceptions.JadxRuntimeException: Can't remove SSA var: r0v18 ??, still in use, count: 1, list:
          (r0v18 ?? I:org.snmp4j.agent.MOQuery) from 0x0032: INVOKE (r19v0 ?? I:org.snmp4j.agent.request.SubRequest), (r0v18 ?? I:org.snmp4j.agent.MOQuery) INTERFACE call: org.snmp4j.agent.request.SubRequest.setQuery(org.snmp4j.agent.MOQuery):void A[MD:(org.snmp4j.agent.MOQuery):void (m)] (LINE:9)
        	at jadx.core.utils.InsnRemover.removeSsaVar(InsnRemover.java:162)
        	at jadx.core.utils.InsnRemover.unbindResult(InsnRemover.java:127)
        	at jadx.core.utils.InsnRemover.lambda$unbindInsns$1(InsnRemover.java:99)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1604)
        	at jadx.core.utils.InsnRemover.unbindInsns(InsnRemover.java:98)
        	at jadx.core.utils.InsnRemover.perform(InsnRemover.java:73)
        	at jadx.core.dex.visitors.ConstructorVisitor.replaceInvoke(ConstructorVisitor.java:59)
        	at jadx.core.dex.visitors.ConstructorVisitor.visit(ConstructorVisitor.java:42)
        */
    protected void processNextSubRequest(
    /*  JADX ERROR: JadxRuntimeException in pass: ConstructorVisitor
        jadx.core.utils.exceptions.JadxRuntimeException: Can't remove SSA var: r0v18 ??, still in use, count: 1, list:
          (r0v18 ?? I:org.snmp4j.agent.MOQuery) from 0x0032: INVOKE (r19v0 ?? I:org.snmp4j.agent.request.SubRequest), (r0v18 ?? I:org.snmp4j.agent.MOQuery) INTERFACE call: org.snmp4j.agent.request.SubRequest.setQuery(org.snmp4j.agent.MOQuery):void A[MD:(org.snmp4j.agent.MOQuery):void (m)] (LINE:9)
        	at jadx.core.utils.InsnRemover.removeSsaVar(InsnRemover.java:162)
        	at jadx.core.utils.InsnRemover.unbindResult(InsnRemover.java:127)
        	at jadx.core.utils.InsnRemover.lambda$unbindInsns$1(InsnRemover.java:99)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1604)
        	at jadx.core.utils.InsnRemover.unbindInsns(InsnRemover.java:98)
        	at jadx.core.utils.InsnRemover.perform(InsnRemover.java:73)
        	at jadx.core.dex.visitors.ConstructorVisitor.replaceInvoke(ConstructorVisitor.java:59)
        */
    /*  JADX ERROR: Method generation error
        jadx.core.utils.exceptions.JadxRuntimeException: Code variable not set in r16v0 ??
        	at jadx.core.dex.instructions.args.SSAVar.getCodeVar(SSAVar.java:236)
        	at jadx.core.codegen.MethodGen.addMethodArguments(MethodGen.java:224)
        	at jadx.core.codegen.MethodGen.addDefinition(MethodGen.java:169)
        	at jadx.core.codegen.ClassGen.addMethodCode(ClassGen.java:407)
        	at jadx.core.codegen.ClassGen.addMethod(ClassGen.java:337)
        	at jadx.core.codegen.ClassGen.lambda$addInnerClsAndMethods$2(ClassGen.java:303)
        	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:186)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1604)
        	at java.base/java.util.stream.SortedOps$RefSortingSink.end(SortedOps.java:395)
        	at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
        	at java.base/java.util.stream.ReferencePipeline$7$1FlatMap.end(ReferencePipeline.java:284)
        	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:571)
        	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:560)
        	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:153)
        	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:176)
        	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:265)
        	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:632)
        	at jadx.core.codegen.ClassGen.addInnerClsAndMethods(ClassGen.java:299)
        	at jadx.core.codegen.ClassGen.addClassBody(ClassGen.java:288)
        	at jadx.core.codegen.ClassGen.addClassBody(ClassGen.java:272)
        	at jadx.core.codegen.ClassGen.addClassCode(ClassGen.java:159)
        	at jadx.core.codegen.ClassGen.makeClass(ClassGen.java:103)
        	at jadx.core.codegen.CodeGen.wrapCodeGen(CodeGen.java:45)
        	at jadx.core.codegen.CodeGen.generateJavaCode(CodeGen.java:34)
        	at jadx.core.codegen.CodeGen.generate(CodeGen.java:22)
        	at jadx.core.ProcessClass.process(ProcessClass.java:88)
        	at jadx.core.ProcessClass.generateCode(ProcessClass.java:126)
        	at jadx.core.dex.nodes.ClassNode.generateClassCode(ClassNode.java:405)
        	at jadx.core.dex.nodes.ClassNode.decompile(ClassNode.java:393)
        	at jadx.core.dex.nodes.ClassNode.getCode(ClassNode.java:343)
        */

    @Override // org.snmp4j.CommandResponder
    public void processPdu(CommandResponderEvent commandResponderEvent) {
        if (commandResponderEvent.getPDU() != null) {
            CoexistenceInfo coexistenceInfo = null;
            OctetString octetString = new OctetString(commandResponderEvent.getSecurityName());
            if (commandResponderEvent.getPDU() instanceof ScopedPDU) {
                ScopedPDU scopedPDU = (ScopedPDU) commandResponderEvent.getPDU();
                coexistenceInfo = new CoexistenceInfo(octetString, scopedPDU.getContextEngineID(), scopedPDU.getContextName());
            } else {
                CoexistenceInfoProvider coexistenceInfoProvider = this.coexistenceProvider;
                if (coexistenceInfoProvider != null) {
                    CoexistenceInfo[] coexistenceInfo2 = coexistenceInfoProvider.getCoexistenceInfo(octetString);
                    if (coexistenceInfo2 == null || coexistenceInfo2.length <= 0) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Community name '" + octetString + "' not found in SNMP-COMMUNITY-MIB");
                        }
                        fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpInBadCommunityNames));
                        return;
                    }
                    int length = coexistenceInfo2.length;
                    int i2 = 0;
                    while (true) {
                        if (i2 >= length) {
                            break;
                        }
                        CoexistenceInfo coexistenceInfo3 = coexistenceInfo2[i2];
                        if (this.coexistenceProvider.passesFilter(commandResponderEvent.getPeerAddress(), coexistenceInfo3)) {
                            coexistenceInfo = coexistenceInfo3;
                            break;
                        }
                        i2++;
                    }
                    if (coexistenceInfo == null) {
                        logger.warn("Access attempt from " + commandResponderEvent.getPeerAddress() + " denied because of source address filtering");
                        fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpInBadCommunityNames));
                        return;
                    }
                    commandResponderEvent.setMaxSizeResponsePDU(coexistenceInfo.getMaxMessageSize());
                }
            }
            if (coexistenceInfo == null || this.ownContextEngineIDs.contains(coexistenceInfo.getContextEngineID())) {
                commandResponderEvent.setProcessed(true);
                Command command = new Command(commandResponderEvent, coexistenceInfo);
                WorkerPool workerPool = this.threadPool;
                if (workerPool != null) {
                    workerPool.execute(command);
                    return;
                } else {
                    command.run();
                    return;
                }
            }
            if (this.proxyForwarder == null) {
                fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpSilentDrops));
                return;
            }
            ProxyForwardRequest proxyForwardRequest = new ProxyForwardRequest(commandResponderEvent, coexistenceInfo);
            ProxyForwarder proxyForwarder = this.proxyForwarder.get(coexistenceInfo.getContextEngineID(), proxyForwardRequest.getProxyType());
            ProxyCommand proxyCommand = new ProxyCommand(proxyForwarder, proxyForwardRequest);
            if (proxyForwarder == null) {
                fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpProxyDrops));
                return;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Processsing proxy request with proxy forwarder " + proxyForwarder);
            }
            WorkerPool workerPool2 = this.threadPool;
            if (workerPool2 != null) {
                workerPool2.execute(proxyCommand);
            } else {
                proxyCommand.run();
            }
        }
    }

    protected void processRequest(CommandResponderEvent commandResponderEvent, CoexistenceInfo coexistenceInfo, RequestHandler<SnmpRequest> requestHandler) {
        MOServer server;
        SnmpRequest snmpRequest = (SnmpRequest) this.requestFactory.createRequest(commandResponderEvent, coexistenceInfo);
        this.requestList.add(snmpRequest);
        OctetString context = snmpRequest.getContext();
        OctetString viewName = getViewName(commandResponderEvent, coexistenceInfo, snmpRequest.getViewType());
        if (viewName == null) {
            setAuthorizationError(snmpRequest, 2);
            server = null;
        } else {
            snmpRequest.setViewName(viewName);
            server = getServer(context);
            processRequest(server, requestHandler, snmpRequest);
        }
        finalizeRequest(commandResponderEvent, snmpRequest, server);
    }

    protected void release(MOServer mOServer, SnmpRequest snmpRequest) {
        for (SnmpRequest.SnmpSubRequest snmpSubRequest : snmpRequest) {
            if (snmpSubRequest.getTargetMO() != null) {
                mOServer.unlock(snmpRequest, snmpSubRequest.getTargetMO());
            }
        }
    }

    public synchronized void removeCounterListener(CounterListener counterListener) {
        if (this.counterListeners != null) {
            this.counterListeners.remove(counterListener);
        }
    }

    public void removeMOServer(MOServer mOServer) {
        this.moServers.remove(mOServer);
    }

    public void removePduHandler(RequestHandler requestHandler) {
        this.pduHandler.remove(requestHandler);
    }

    public ProxyForwarder removeProxyForwarder(OctetString octetString, int i2) {
        ProxyMap proxyMap = this.proxyForwarder;
        if (proxyMap != null) {
            return proxyMap.remove(octetString, i2);
        }
        return null;
    }

    protected void reprocessRequest(MOServer mOServer, SnmpRequest snmpRequest) {
        RequestHandler<SnmpRequest> handler = getHandler(snmpRequest.getSource().getPDU().getType());
        if (handler == null) {
            sendUnknownPDUHandlersReport(snmpRequest.getSource());
            return;
        }
        snmpRequest.resetProcessedStatus();
        snmpRequest.incReprocessCounter();
        processRequest(mOServer, handler, snmpRequest);
    }

    protected void sendResponse(CommandResponderEvent commandResponderEvent, PDU pdu) {
        MessageDispatcher messageDispatcher = commandResponderEvent.getMessageDispatcher();
        try {
            if (pdu.getBERLength() > commandResponderEvent.getMaxSizeResponsePDU()) {
                if (pdu.getType() != -88) {
                    if (commandResponderEvent.getPDU().getType() == -91) {
                        while (pdu.size() > 0 && pdu.getBERLength() > commandResponderEvent.getMaxSizeResponsePDU()) {
                            pdu.trim();
                        }
                    } else {
                        pdu.clear();
                        pdu.setRequestID(commandResponderEvent.getPDU().getRequestID());
                        pdu.setErrorStatus(1);
                    }
                }
                if (pdu.getBERLength() > commandResponderEvent.getMaxSizeResponsePDU()) {
                    fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpSilentDrops));
                    return;
                }
            }
            StatusInformation statusInformation = new StatusInformation();
            StateReference stateReference = commandResponderEvent.getStateReference();
            if (stateReference != null) {
                stateReference.setTransportMapping(commandResponderEvent.getTransportMapping());
                messageDispatcher.returnResponsePdu(commandResponderEvent.getMessageProcessingModel(), commandResponderEvent.getSecurityModel(), commandResponderEvent.getSecurityName(), commandResponderEvent.getSecurityLevel(), pdu, commandResponderEvent.getMaxSizeResponsePDU(), commandResponderEvent.getStateReference(), statusInformation);
                return;
            }
            logger.warn("No state reference available for requestEvent=" + commandResponderEvent + ". Cannot return response=" + pdu);
        } catch (MessageException e2) {
            logger.error("Failed to send response to request " + commandResponderEvent, e2);
        }
    }

    protected void setAuthorizationError(Request request, int i2) {
        if (request.size() > 0) {
            ((SubRequest) request.iterator().next()).getStatus().setErrorStatus(16);
        } else {
            request.setErrorStatus(16);
        }
    }

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

    public void setContextEngineID(OctetString octetString) {
        this.ownContextEngineIDs.set(0, octetString);
    }

    public void setInternalRequestTimeout(int i2) {
        this.requestList.setTimeout(i2);
    }

    public void setNotificationOriginator(NotificationOriginator notificationOriginator) {
        this.notificationOriginator = notificationOriginator;
    }

    public void setThreadPool(WorkerPool workerPool) {
        this.threadPool = workerPool;
    }

    public void setVacm(VACM vacm) {
        this.vacm = vacm;
    }

    public void setWorkerPool(WorkerPool workerPool) {
        this.threadPool = workerPool;
    }

    protected void unlockManagedObjectIfLockedByLookup(MOServer mOServer, ManagedObject managedObject, LockRequest lockRequest) {
        int i2 = AnonymousClass1.$SwitchMap$org$snmp4j$agent$mo$lock$LockRequest$LockStatus[lockRequest.getLockRequestStatus().ordinal()];
        if (i2 == 1 || i2 == 2) {
            mOServer.unlock(lockRequest.getLockOwner(), managedObject);
        }
    }

    @Override // org.snmp4j.agent.NotificationOriginator
    public Object notify(OctetString octetString, OID oid, TimeTicks timeTicks, VariableBinding[] variableBindingArr) {
        NotificationOriginator notificationOriginator = this.notificationOriginator;
        if (notificationOriginator != null) {
            NotificationTask notificationTask = new NotificationTask(notificationOriginator, octetString, oid, timeTicks, variableBindingArr);
            WorkerPool workerPool = this.threadPool;
            if (workerPool != null) {
                workerPool.execute(notificationTask);
                return notificationTask;
            }
            notificationTask.run();
            return notificationTask.getResponses();
        }
        logger.warn("Could not sent notification '" + oid + "'=" + Arrays.asList(variableBindingArr) + " because NotificationOriginator not set");
        return null;
    }

    class VACMQuery extends MOQueryWithSource {
        private OctetString viewName;

        public VACMQuery(OctetString octetString, OID oid, boolean z, OID oid2, boolean z2, OctetString octetString2) {
            super(new DefaultMOContextScope(octetString, oid, z, oid2, z2), false, null);
            this.viewName = octetString2;
        }

        public boolean isAccessAllowed(OID oid) {
            return CommandProcessor.this.vacm.isAccessAllowed(this.viewName, oid) == 0;
        }

        public boolean isSearchQuery() {
            MOContextScope scope = getScope();
            return !scope.isLowerIncluded() && (scope.getUpperBound() == null || !scope.getUpperBound().equals(scope.getLowerBound()));
        }

        @Override // org.snmp4j.agent.DefaultMOQuery, org.snmp4j.agent.MOQuery
        public boolean matchesQuery(ManagedObject managedObject) {
            OID lowerBound;
            if (isSearchQuery()) {
                lowerBound = managedObject.find(getScope());
                if (lowerBound == null) {
                    return false;
                }
            } else {
                lowerBound = getScope().getLowerBound();
            }
            return CommandProcessor.this.vacm.isAccessAllowed(this.viewName, lowerBound) == 0;
        }

        @Override // org.snmp4j.agent.DefaultMOQuery
        public String toString() {
            return super.toString() + "[viewName=" + this.viewName + "]";
        }

        public VACMQuery(OctetString octetString, OID oid, boolean z, OID oid2, boolean z2, OctetString octetString2, boolean z3, SnmpRequest snmpRequest) {
            super(new DefaultMOContextScope(octetString, oid, z, oid2, z2), z3, snmpRequest);
            this.viewName = octetString2;
        }
    }

    protected <R extends Request<Source, Response, ? extends SubRequest>, Source, Response> void processRequest(MOServer mOServer, RequestHandler<R> requestHandler, R r) {
        if (mOServer == null) {
            logger.error("No server for " + r.getContext() + " found -> request cannot be processed");
            r.setErrorStatus(5);
            return;
        }
        requestHandler.processPdu(r, mOServer);
    }
}