package org.snmp4j.agent.mo.snmp;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import okhttp3.internal.http2.Settings;
import org.snmp4j.PDU;
import org.snmp4j.PDUv1;
import org.snmp4j.SNMP4JSettings;
import org.snmp4j.ScopedPDU;
import org.snmp4j.Session;
import org.snmp4j.Target;
import org.snmp4j.agent.ProxyForwardRequest;
import org.snmp4j.agent.ProxyForwarder;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.agent.mo.snmp.SnmpProxyMIB;
import org.snmp4j.agent.mo.snmp.SnmpTargetMIB;
import org.snmp4j.agent.request.SnmpRequest;
import org.snmp4j.event.CounterEvent;
import org.snmp4j.event.CounterListener;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.smi.Counter64;
import org.snmp4j.smi.IpAddress;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TimeTicks;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.util.DefaultPDUFactory;

/* JADX INFO: loaded from: classes.dex */
public class ProxyForwarderImpl implements ProxyForwarder {
    private static final LogAdapter logger = LogFactory.getLogger(ProxyForwarderImpl.class);
    private transient Vector<CounterListener> counterListeners;
    private SnmpProxyMIB proxyMIB;
    private Session session;
    private SnmpTargetMIB targetMIB;

    public ProxyForwarderImpl(Session session, SnmpProxyMIB snmpProxyMIB, SnmpTargetMIB snmpTargetMIB) {
        this.session = session;
        this.proxyMIB = snmpProxyMIB;
        this.targetMIB = snmpTargetMIB;
    }

    private void setScope(ProxyForwardRequest proxyForwardRequest, PDU pdu) {
        if (pdu instanceof ScopedPDU) {
            ScopedPDU scopedPDU = (ScopedPDU) pdu;
            scopedPDU.setContextEngineID(proxyForwardRequest.getContextEngineID());
            scopedPDU.setContextName(proxyForwardRequest.getContext());
        }
    }

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

    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);
            }
        }
    }

    @Override // org.snmp4j.agent.ProxyForwarder
    public boolean forward(ProxyForwardRequest proxyForwardRequest) {
        if (SnmpRequest.getViewType(proxyForwardRequest.getCommandEvent().getPDU().getType()) == 0) {
            return multipleForward(proxyForwardRequest);
        }
        ResponseEvent responseEventSingleForward = singleForward(proxyForwardRequest);
        if (responseEventSingleForward == null || responseEventSingleForward.getResponse() == null) {
            return false;
        }
        PDU response = responseEventSingleForward.getResponse();
        PDU pduCreatePDU = DefaultPDUFactory.createPDU(proxyForwardRequest.getCommandEvent().getSecurityModel());
        if (!pduCreatePDU.getClass().equals(response.getClass())) {
            pduCreatePDU.setType(response.getType());
            pduCreatePDU.addAll(response.toArray());
            pduCreatePDU.setErrorIndex(response.getErrorIndex());
            pduCreatePDU.setErrorStatus(response.getErrorStatus());
            response = pduCreatePDU;
        }
        if (response.getType() == -94) {
            response.setRequestID(proxyForwardRequest.getCommandEvent().getPDU().getRequestID());
            if ((response instanceof ScopedPDU) && (proxyForwardRequest.getCommandEvent().getPDU() instanceof ScopedPDU)) {
                ScopedPDU scopedPDU = (ScopedPDU) proxyForwardRequest.getCommandEvent().getPDU();
                ScopedPDU scopedPDU2 = (ScopedPDU) response;
                scopedPDU2.setContextEngineID(scopedPDU.getContextEngineID());
                scopedPDU2.setContextName(scopedPDU.getContextName());
            }
        }
        proxyForwardRequest.setResponsePDU(response);
        return true;
    }

    protected List getMatches(ProxyForwardRequest proxyForwardRequest) {
        List<SnmpProxyMIB.SnmpProxyRow> proxyRows = this.proxyMIB.getProxyRows(proxyForwardRequest.getProxyType(), proxyForwardRequest.getContextEngineID(), proxyForwardRequest.getContext());
        Iterator<SnmpProxyMIB.SnmpProxyRow> it = proxyRows.iterator();
        while (it.hasNext()) {
            OctetString snmpProxyTargetParamsIn = it.next().getSnmpProxyTargetParamsIn();
            if (logger.isDebugEnabled()) {
                logger.debug("Checking possible match for in parameter: " + snmpProxyTargetParamsIn);
            }
            if (!matchParameters(proxyForwardRequest, snmpProxyTargetParamsIn)) {
                it.remove();
            }
        }
        return proxyRows;
    }

    protected boolean matchParameters(ProxyForwardRequest proxyForwardRequest, OctetString octetString) {
        MOTableRow targetParamsRow = this.targetMIB.getTargetParamsRow(octetString, true);
        if (targetParamsRow != null) {
            int i2 = targetParamsRow.getValue(0).toInt();
            int i3 = targetParamsRow.getValue(1).toInt();
            int i4 = targetParamsRow.getValue(3).toInt();
            OctetString octetString2 = (OctetString) targetParamsRow.getValue(2);
            if (logger.isDebugEnabled()) {
                logger.debug("Matching request " + proxyForwardRequest + "  with mpModel=" + i2 + ", secModel=" + i3 + ", secLevel=" + i4 + ", secName=" + octetString2);
            }
            if (i2 == proxyForwardRequest.getCommandEvent().getMessageProcessingModel() && octetString2.equals(proxyForwardRequest.getSecurityName()) && ((i3 == 0 || i3 == proxyForwardRequest.getCommandEvent().getSecurityModel()) && i4 == proxyForwardRequest.getCommandEvent().getSecurityLevel())) {
                return true;
            }
        }
        return false;
    }

    protected boolean multipleForward(ProxyForwardRequest proxyForwardRequest) {
        ResponseEvent responseEventSend;
        Iterator it = getMatches(proxyForwardRequest).iterator();
        boolean z = true;
        while (it.hasNext()) {
            Set<OctetString> tags = SnmpTagList.getTags(((SnmpProxyMIB.SnmpProxyRow) it.next()).getSnmpProxyMultipleTargetOut());
            if (logger.isDebugEnabled()) {
                logger.debug("Proxy multiple targets out with tags " + tags);
            }
            Iterator<OctetString> it2 = tags.iterator();
            while (it2.hasNext()) {
                for (SnmpTargetMIB.SnmpTargetAddrEntryRow snmpTargetAddrEntryRow : this.targetMIB.getTargetAddrRowsForTag(it2.next())) {
                    Target target = snmpTargetAddrEntryRow.getTarget(proxyForwardRequest.getContextEngineID(), proxyForwardRequest.getContext());
                    if (target != null) {
                        try {
                            PDU pdu = proxyForwardRequest.getCommandEvent().getPDU();
                            PDU pduCreatePDU = DefaultPDUFactory.createPDU(target, pdu.getType());
                            setScope(proxyForwardRequest, pduCreatePDU);
                            proxyForwardTranslation(proxyForwardRequest, pdu, pduCreatePDU);
                            responseEventSend = this.session.send(pduCreatePDU, target);
                            if (logger.isInfoEnabled()) {
                                logger.info("Forwarded " + proxyForwardRequest.getCommandEvent() + " to target " + target + " with response " + responseEventSend);
                            }
                        } catch (IOException e2) {
                            if (logger.isDebugEnabled()) {
                                e2.printStackTrace();
                            }
                            logger.error("Failed to forward request " + proxyForwardRequest + " to target " + target);
                        }
                        if (proxyForwardRequest.getCommandEvent().getPDU().getType() == -90 && (responseEventSend.getResponse() == null || responseEventSend.getResponse().getType() == -88 || responseEventSend.getResponse().getErrorStatus() != 0)) {
                            z = false;
                        }
                    } else if (logger.isDebugEnabled()) {
                        logger.debug("Parameters for target " + snmpTargetAddrEntryRow + " not found");
                    }
                }
            }
        }
        return z;
    }

    protected boolean proxyBackwardTranslation(PDU pdu, PDU pdu2, ResponseEvent responseEvent) {
        if (responseEvent.getResponse() == null) {
            return false;
        }
        PDU response = responseEvent.getResponse();
        if (response.getErrorStatus() == 1 && pdu.getType() != -91) {
            responseEvent.getResponse().clear();
            responseEvent.getResponse().setErrorStatus(0);
            responseEvent.getResponse().setErrorIndex(0);
            return false;
        }
        if (response.getErrorStatus() == 1 && pdu.getType() == -91 && pdu2.getType() == -91) {
            if (pdu2.size() == 1) {
                responseEvent.getResponse().clear();
                responseEvent.getResponse().setErrorStatus(0);
                responseEvent.getResponse().setErrorIndex(0);
                return false;
            }
            while (pdu2.size() > 1) {
                pdu2.trim();
            }
            pdu2.setType(-95);
            return true;
        }
        if (!(pdu instanceof PDUv1) || (responseEvent.getResponse() instanceof PDUv1)) {
            return false;
        }
        boolean z = false;
        for (int i2 = 0; i2 < response.size(); i2++) {
            VariableBinding variableBinding = response.get(i2);
            if (variableBinding.getVariable() instanceof Counter64) {
                OID oid = new OID(variableBinding.getOid());
                if (oid.last() < 65535) {
                    oid.set(oid.size() - 1, Settings.DEFAULT_INITIAL_WINDOW_SIZE);
                } else {
                    oid.set(oid.size() - 1, -1);
                }
                pdu2.get(i2).setOid(variableBinding.getOid());
                z = true;
            }
        }
        if (!z || pdu.getType() == -95) {
            return true;
        }
        throw new IllegalArgumentException("GET response with Counter64 cannot be proxied");
    }

    protected void proxyForwardTranslation(ProxyForwardRequest proxyForwardRequest, PDU pdu, PDU pdu2) throws IllegalArgumentException {
        pdu2.clear();
        pdu2.setType(pdu.getType());
        boolean z = pdu2 instanceof PDUv1;
        if (!z && !(pdu instanceof PDUv1)) {
            pdu2.setMaxRepetitions(pdu.getMaxRepetitions());
            pdu2.setNonRepeaters(pdu.getNonRepeaters());
        }
        if (pdu.getType() == -92 && (pdu instanceof PDUv1) && !z) {
            PDUv1 pDUv1 = (PDUv1) pdu;
            pdu2.setType(-89);
            pdu2.add(new VariableBinding(SnmpConstants.sysUpTime, new TimeTicks(pDUv1.getTimestamp())));
            pdu2.add(new VariableBinding(SnmpConstants.snmpTrapOID, SnmpConstants.getTrapOID(pDUv1.getEnterprise(), pDUv1.getGenericTrap(), pDUv1.getSpecificTrap())));
            pdu2.addAll(pdu.toArray());
            pdu2.add(new VariableBinding(SnmpConstants.snmpTrapAddress, pDUv1.getAgentAddress()));
            pdu2.add(new VariableBinding(SnmpConstants.snmpTrapEnterprise, pDUv1.getEnterprise()));
            pdu2.add(new VariableBinding(SnmpConstants.snmpTrapCommunity, new OctetString(proxyForwardRequest.getCommandEvent().getSecurityName())));
            return;
        }
        if ((pdu.getType() != -89 && pdu.getType() != -90) || !z) {
            pdu2.addAll(pdu.toArray());
            return;
        }
        PDUv1 pDUv12 = (PDUv1) pdu2;
        pdu2.setType(-92);
        if (pdu.size() < 2 || !(pdu.get(0).getVariable() instanceof TimeTicks) || !(pdu.get(1).getVariable() instanceof OID)) {
            throw new IllegalArgumentException("Proxy source invalid notification PDU: " + pdu);
        }
        TimeTicks timeTicks = (TimeTicks) pdu.get(0).getVariable();
        OID oid = (OID) pdu.get(1).getVariable();
        int genericTrapID = SnmpConstants.getGenericTrapID(oid);
        if (genericTrapID < 0) {
            pDUv12.setGenericTrap(6);
            if (oid.size() > 2 && oid.get(oid.size() - 2) == 0) {
                pDUv12.setSpecificTrap(oid.get(oid.size() - 1));
                OID oid2 = new OID(oid);
                oid2.trim(2);
                pDUv12.setEnterprise(oid2);
            } else if (oid.size() > 1) {
                pDUv12.setSpecificTrap(oid.get(oid.size() - 1));
                OID oid3 = new OID(oid);
                oid3.trim(1);
                pDUv12.setEnterprise(oid3);
            }
        } else {
            pDUv12.setGenericTrap(genericTrapID);
            pDUv12.setSpecificTrap(0);
        }
        pdu2.addAll(pdu.toArray());
        if (proxyForwardRequest.getCommandEvent().getPeerAddress() instanceof IpAddress) {
            pDUv12.setAgentAddress(new IpAddress(((IpAddress) proxyForwardRequest.getCommandEvent().getPeerAddress()).getInetAddress()));
        } else {
            pDUv12.setAgentAddress(new IpAddress("0.0.0.0"));
        }
        pDUv12.setTimestamp(timeTicks.getValue());
    }

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

    public void setSession(Session session) {
        this.session = session;
    }

    protected ResponseEvent singleForward(ProxyForwardRequest proxyForwardRequest) {
        ResponseEvent responseEventSend;
        List matches = getMatches(proxyForwardRequest);
        if (matches == null || matches.isEmpty()) {
            if (logger.isInfoEnabled()) {
                logger.info("No matching proxy entry found for contextEngineID=" + proxyForwardRequest.getContextEngineID() + ", context=" + proxyForwardRequest.getContext() + " and request=" + proxyForwardRequest);
            }
            return null;
        }
        OctetString octetString = (OctetString) ((MOTableRow) matches.get(0)).getValue(4);
        Target target = this.targetMIB.getTarget(octetString, proxyForwardRequest.getContextEngineID(), proxyForwardRequest.getContext());
        if (target == null) {
            if (logger.isInfoEnabled()) {
                logger.info("No matching target with name '" + octetString + "'");
            }
            return null;
        }
        if (logger.isInfoEnabled()) {
            logger.info("Forwarding proxy request " + proxyForwardRequest + " to " + target);
        }
        PDU pdu = proxyForwardRequest.getCommandEvent().getPDU();
        PDU pduCreatePDU = DefaultPDUFactory.createPDU(target, pdu.getType());
        setScope(proxyForwardRequest, pduCreatePDU);
        try {
            proxyForwardTranslation(proxyForwardRequest, pdu, pduCreatePDU);
            do {
                responseEventSend = this.session.send(pduCreatePDU, target);
                if (logger.isInfoEnabled()) {
                    logger.info("Received proxy response from " + responseEventSend.getPeerAddress() + " is " + responseEventSend.getResponse());
                }
            } while (proxyBackwardTranslation(pdu, pduCreatePDU, responseEventSend));
            return responseEventSend;
        } catch (Exception e2) {
            if (logger.isDebugEnabled()) {
                e2.printStackTrace();
            }
            logger.error("Failed to send proxy request to " + target + " because: " + e2.getMessage());
            fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpProxyDrops));
            if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                throw new RuntimeException(e2);
            }
            return null;
        }
    }
}