package org.snmp4j;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Vector;
import org.snmp4j.asn1.BER;
import org.snmp4j.asn1.BERInputStream;
import org.snmp4j.asn1.BEROutputStream;
import org.snmp4j.event.AuthenticationFailureEvent;
import org.snmp4j.event.AuthenticationFailureListener;
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.MessageProcessingModel;
import org.snmp4j.mp.PduHandle;
import org.snmp4j.mp.PduHandleCallback;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.mp.StateReference;
import org.snmp4j.mp.StatusInformation;
import org.snmp4j.security.SecurityLevel;
import org.snmp4j.security.TsmSecurityStateReference;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OctetString;
import org.snmp4j.transport.UnsupportedAddressClassException;

/* JADX INFO: loaded from: classes.dex */
public class MessageDispatcherImpl implements MessageDispatcher {
    private static final LogAdapter logger = LogFactory.getLogger(MessageDispatcherImpl.class);
    private transient List<AuthenticationFailureListener> authenticationFailureListeners;
    private transient List<CommandResponder> commandResponderListeners;
    private transient List<CounterListener> counterListeners;
    private List<MessageProcessingModel> mpm = new ArrayList(3);
    private Map<Class<? extends Address>, List<TransportMapping>> transportMappings = new Hashtable(5);
    private int nextTransactionID = new Random().nextInt(2147483645) + 1;
    private boolean checkOutgoingMsg = true;

    private static void checkListening4ConfirmedPDU(PDU pdu, Address address, TransportMapping transportMapping) {
        if (transportMapping == null || transportMapping.isListening()) {
            return;
        }
        logger.warn("Sending confirmed PDU " + pdu + " to target " + address + " although transport mapping " + transportMapping + " is not listening for a response");
    }

    public synchronized void addAuthenticationFailureListener(AuthenticationFailureListener authenticationFailureListener) {
        if (this.authenticationFailureListeners == null) {
            this.authenticationFailureListeners = new Vector(2);
        }
        if (!this.authenticationFailureListeners.contains(authenticationFailureListener)) {
            this.authenticationFailureListeners.add(authenticationFailureListener);
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public synchronized void addCommandResponder(CommandResponder commandResponder) {
        if (this.commandResponderListeners == null) {
            this.commandResponderListeners = new Vector(2);
        }
        if (!this.commandResponderListeners.contains(commandResponder)) {
            this.commandResponderListeners.add(commandResponder);
        }
    }

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

    @Override // org.snmp4j.MessageDispatcher
    public synchronized void addMessageProcessingModel(MessageProcessingModel messageProcessingModel) {
        while (this.mpm.size() <= messageProcessingModel.getID()) {
            this.mpm.add(null);
        }
        if (this.mpm.get(messageProcessingModel.getID()) == null) {
            this.mpm.set(messageProcessingModel.getID(), messageProcessingModel);
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public synchronized void addTransportMapping(TransportMapping transportMapping) {
        List<TransportMapping> linkedList = this.transportMappings.get(transportMapping.getSupportedAddressClass());
        if (linkedList == null) {
            linkedList = new LinkedList<>();
            this.transportMappings.put(transportMapping.getSupportedAddressClass(), linkedList);
        }
        linkedList.add(transportMapping);
    }

    protected void checkOutgoingMsg(Address address, int i2, PDU pdu) throws MessageException {
        if (this.checkOutgoingMsg) {
            if ((i2 == 0 || SNMP4JSettings.isNoGetBulk()) && pdu.getType() == -91) {
                if (i2 == 0) {
                    logger.warn("Converting GETBULK PDU to GETNEXT for SNMPv1 target: " + address);
                } else {
                    logger.info("Converting GETBULK PDU to GETNEXT for target: " + address);
                }
                pdu.setType(-95);
                if (pdu instanceof PDUv1) {
                    return;
                }
                pdu.setMaxRepetitions(0);
                pdu.setNonRepeaters(0);
            }
        }
    }

    protected void configureAuthoritativeEngineID(Target target, MessageProcessingModel messageProcessingModel) {
        if ((target instanceof UserTarget) && (messageProcessingModel instanceof MPv3)) {
            UserTarget userTarget = (UserTarget) target;
            if (userTarget.getAuthoritativeEngineID() == null || userTarget.getAuthoritativeEngineID().length <= 0) {
                return;
            }
            ((MPv3) messageProcessingModel).addEngineID(target.getAddress(), new OctetString(userTarget.getAuthoritativeEngineID()));
        }
    }

    protected PduHandle createPduHandle() {
        return new PduHandle(getNextRequestID());
    }

    /* JADX WARN: Removed duplicated region for block: B:30:0x00f6  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    protected void dispatchMessage(org.snmp4j.TransportMapping r25, org.snmp4j.mp.MessageProcessingModel r26, org.snmp4j.smi.Address r27, org.snmp4j.asn1.BERInputStream r28, org.snmp4j.TransportStateReference r29) throws java.io.IOException {
        /*
            Method dump skipped, instruction units count: 308
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.MessageDispatcherImpl.dispatchMessage(org.snmp4j.TransportMapping, org.snmp4j.mp.MessageProcessingModel, org.snmp4j.smi.Address, org.snmp4j.asn1.BERInputStream, org.snmp4j.TransportStateReference):void");
    }

    protected void fireAuthenticationFailure(AuthenticationFailureEvent authenticationFailureEvent) {
        List<AuthenticationFailureListener> list = this.authenticationFailureListeners;
        if (list != null) {
            Iterator<AuthenticationFailureListener> it = list.iterator();
            while (it.hasNext()) {
                it.next().authenticationFailure(authenticationFailureEvent);
            }
        }
    }

    protected void fireIncrementCounter(CounterEvent counterEvent) {
        List<CounterListener> list = this.counterListeners;
        if (list != null) {
            Iterator<CounterListener> it = list.iterator();
            while (it.hasNext()) {
                it.next().incrementCounter(counterEvent);
            }
        }
    }

    protected void fireProcessPdu(CommandResponderEvent commandResponderEvent) {
        List<CommandResponder> list = this.commandResponderListeners;
        if (list != null) {
            Iterator<CommandResponder> it = list.iterator();
            while (it.hasNext()) {
                it.next().processPdu(commandResponderEvent);
                if (commandResponderEvent.isProcessed()) {
                    return;
                }
            }
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public MessageProcessingModel getMessageProcessingModel(int i2) {
        try {
            return this.mpm.get(i2);
        } catch (IndexOutOfBoundsException unused) {
            return null;
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public synchronized int getNextRequestID() {
        int i2;
        i2 = this.nextTransactionID;
        this.nextTransactionID = i2 + 1;
        if (i2 <= 0) {
            this.nextTransactionID = 2;
            i2 = 1;
        }
        return i2;
    }

    @Override // org.snmp4j.MessageDispatcher
    public TransportMapping getTransport(Address address) {
        Class<?> superclass = address.getClass();
        do {
            List<TransportMapping> list = this.transportMappings.get(superclass);
            if (list != null && list.size() > 0) {
                return list.get(0);
            }
            superclass = superclass.getSuperclass();
        } while (superclass != null);
        return null;
    }

    @Override // org.snmp4j.MessageDispatcher
    public Collection<TransportMapping> getTransportMappings() {
        ArrayList arrayList = new ArrayList(this.transportMappings.size());
        synchronized (this.transportMappings) {
            Iterator<List<TransportMapping>> it = this.transportMappings.values().iterator();
            while (it.hasNext()) {
                arrayList.addAll(it.next());
            }
        }
        return arrayList;
    }

    public boolean isCheckOutgoingMsg() {
        return this.checkOutgoingMsg;
    }

    @Override // org.snmp4j.MessageDispatcher, org.snmp4j.transport.TransportListener
    public void processMessage(TransportMapping transportMapping, Address address, ByteBuffer byteBuffer, TransportStateReference transportStateReference) {
        processMessage(transportMapping, address, new BERInputStream(byteBuffer), transportStateReference);
    }

    @Override // org.snmp4j.MessageDispatcher
    public void releaseStateReference(int i2, PduHandle pduHandle) {
        MessageProcessingModel messageProcessingModel = getMessageProcessingModel(i2);
        if (messageProcessingModel != null) {
            messageProcessingModel.releaseStateReference(pduHandle);
            return;
        }
        throw new IllegalArgumentException("Unsupported message processing model: " + i2);
    }

    public synchronized void removeAuthenticationFailureListener(AuthenticationFailureListener authenticationFailureListener) {
        if (this.authenticationFailureListeners != null && this.authenticationFailureListeners.contains(authenticationFailureListener)) {
            this.authenticationFailureListeners.remove(authenticationFailureListener);
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public synchronized void removeCommandResponder(CommandResponder commandResponder) {
        if (this.commandResponderListeners != null && this.commandResponderListeners.contains(commandResponder)) {
            this.commandResponderListeners.remove(commandResponder);
        }
    }

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

    @Override // org.snmp4j.MessageDispatcher
    public synchronized void removeMessageProcessingModel(MessageProcessingModel messageProcessingModel) {
        this.mpm.set(messageProcessingModel.getID(), null);
    }

    @Override // org.snmp4j.MessageDispatcher
    public TransportMapping removeTransportMapping(TransportMapping transportMapping) {
        List<TransportMapping> listRemove = this.transportMappings.remove(transportMapping.getSupportedAddressClass());
        if (listRemove == null || !listRemove.remove(transportMapping)) {
            return null;
        }
        return transportMapping;
    }

    @Override // org.snmp4j.MessageDispatcher
    public int returnResponsePdu(int i2, int i3, byte[] bArr, int i4, PDU pdu, int i5, StateReference stateReference, StatusInformation statusInformation) throws MessageException {
        try {
            MessageProcessingModel messageProcessingModel = getMessageProcessingModel(i2);
            if (messageProcessingModel == null) {
                throw new MessageException("Unsupported message processing model: " + i2, SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL);
            }
            TransportMapping transportMapping = stateReference.getTransportMapping();
            if (transportMapping == null) {
                transportMapping = getTransport(stateReference.getAddress());
            }
            if (transportMapping == null) {
                throw new MessageException("Unsupported address class (transport mapping): " + stateReference.getAddress().getClass().getName(), SnmpConstants.SNMP_MD_UNSUPPORTED_ADDRESS_CLASS);
            }
            BEROutputStream bEROutputStream = new BEROutputStream();
            int iPrepareResponseMessage = messageProcessingModel.prepareResponseMessage(i2, transportMapping.getMaxInboundMessageSize(), i3, bArr, i4, pdu, i5, stateReference, statusInformation, bEROutputStream);
            if (iPrepareResponseMessage == 0) {
                sendMessage(transportMapping, stateReference.getAddress(), bEROutputStream.getBuffer().array(), stateReference.getSecurityStateReference() instanceof TsmSecurityStateReference ? ((TsmSecurityStateReference) stateReference.getSecurityStateReference()).getTmStateReference() : null);
            }
            return iPrepareResponseMessage;
        } catch (IOException e2) {
            throw new MessageException(e2.getMessage(), SnmpConstants.SNMP_MD_ERROR, e2);
        } catch (ArrayIndexOutOfBoundsException e3) {
            throw new MessageException("Unsupported message processing model: " + i2, SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL, e3);
        }
    }

    protected void sendMessage(TransportMapping transportMapping, Address address, byte[] bArr, TransportStateReference transportStateReference) throws IOException {
        if (transportMapping != null) {
            if (address instanceof GenericAddress) {
                transportMapping.sendMessage(((GenericAddress) address).getAddress(), bArr, transportStateReference);
                return;
            } else {
                transportMapping.sendMessage(address, bArr, transportStateReference);
                return;
            }
        }
        String str = "No transport mapping for address class: " + address.getClass().getName() + "=" + address;
        logger.error(str);
        throw new IOException(str);
    }

    @Override // org.snmp4j.MessageDispatcher
    public PduHandle sendPdu(Target target, PDU pdu, boolean z) throws MessageException {
        return sendPdu(null, target, pdu, z);
    }

    public void setCheckOutgoingMsg(boolean z) {
        this.checkOutgoingMsg = z;
    }

    public void processMessage(TransportMapping transportMapping, Address address, BERInputStream bERInputStream, TransportStateReference transportStateReference) {
        fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpInPkts));
        if (!bERInputStream.markSupported()) {
            logger.error("Message stream must support marks");
            throw new IllegalArgumentException("Message stream must support marks");
        }
        try {
            bERInputStream.mark(16);
            BER.MutableByte mutableByte = new BER.MutableByte();
            BER.decodeHeader(bERInputStream, mutableByte, false);
            if (mutableByte.getValue() != 48) {
                logger.error("ASN.1 parse error (message is not a sequence)");
                fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpInASNParseErrs));
            }
            Integer32 integer32 = new Integer32();
            integer32.decodeBER(bERInputStream);
            MessageProcessingModel messageProcessingModel = getMessageProcessingModel(integer32.getValue());
            if (messageProcessingModel != null) {
                bERInputStream.reset();
                dispatchMessage(transportMapping, messageProcessingModel, address, bERInputStream, transportStateReference);
                return;
            }
            logger.warn("SNMP version " + integer32 + " is not supported");
            fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpInBadVersions));
        } catch (IOException e2) {
            e2.printStackTrace();
            logger.warn(e2);
            fireIncrementCounter(new CounterEvent(this, SnmpConstants.snmpInvalidMsgs));
        } catch (Exception e3) {
            logger.error(e3);
            if (logger.isDebugEnabled()) {
                e3.printStackTrace();
            }
            if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                throw new RuntimeException(e3);
            }
        } catch (OutOfMemoryError e4) {
            logger.error(e4);
            if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                throw e4;
            }
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public PduHandle sendPdu(TransportMapping transportMapping, Target target, PDU pdu, boolean z, PduHandleCallback<PDU> pduHandleCallback) throws MessageException {
        int i2;
        String str;
        int i3;
        PduHandle pduHandle;
        int version = target.getVersion();
        Address address = target.getAddress();
        int securityModel = target.getSecurityModel();
        int securityLevel = target.getSecurityLevel();
        try {
            try {
                byte[] value = target.getSecurityName().getValue();
                MessageProcessingModel messageProcessingModel = getMessageProcessingModel(version);
                try {
                    if (messageProcessingModel != null) {
                        try {
                            if (!messageProcessingModel.isProtocolVersionSupported(version)) {
                                StringBuilder sb = new StringBuilder();
                                sb.append("SNMP version ");
                                sb.append(version);
                                sb.append(" is not supported by message processing model ");
                                sb.append(version);
                                throw new MessageException(sb.toString(), SnmpConstants.SNMP_MD_UNSUPPORTED_SNMP_VERSION);
                            }
                            TransportMapping transport = transportMapping == null ? getTransport(address) : transportMapping;
                            if (transport == null) {
                                throw new UnsupportedAddressClassException("Unsupported address class (transport mapping): " + address.getClass().getName(), address.getClass());
                            }
                            if (pdu.isConfirmedPdu()) {
                                checkListening4ConfirmedPDU(pdu, target.getAddress(), transport);
                            }
                            checkOutgoingMsg(address, version, pdu);
                            Integer32 requestID = pdu.getRequestID();
                            PduHandle pduHandleCreatePduHandle = ((requestID == null || requestID.getValue() == 0) && pdu.getType() != -94) ? createPduHandle() : new PduHandle(pdu.getRequestID().getValue());
                            if (pdu.getType() != -92) {
                                pdu.setRequestID(new Integer32(pduHandleCreatePduHandle.getTransactionID()));
                            }
                            GenericAddress genericAddress = new GenericAddress();
                            TransportMapping transportMapping2 = transport;
                            TransportStateReference transportStateReference = new TransportStateReference(transport, address, new OctetString(value), SecurityLevel.get(securityLevel), SecurityLevel.undefined, false, null, target instanceof CertifiedIdentity ? (CertifiedIdentity) target : null);
                            if (pdu.isConfirmedPdu()) {
                                configureAuthoritativeEngineID(target, messageProcessingModel);
                            }
                            BEROutputStream bEROutputStream = new BEROutputStream();
                            try {
                                int iPrepareOutgoingMessage = messageProcessingModel.prepareOutgoingMessage(address, transportMapping2.getMaxInboundMessageSize(), version, securityModel, value, securityLevel, pdu, z, pduHandleCreatePduHandle, genericAddress, bEROutputStream, transportStateReference);
                                if (iPrepareOutgoingMessage == 0) {
                                    if (pduHandleCallback != null) {
                                        pduHandle = pduHandleCreatePduHandle;
                                        pduHandleCallback.pduHandleAssigned(pduHandle, pdu);
                                    } else {
                                        pduHandle = pduHandleCreatePduHandle;
                                    }
                                    sendMessage(transportMapping2, address, bEROutputStream.getBuffer().array(), transportStateReference);
                                    return pduHandle;
                                }
                                throw new MessageException("Message processing model " + messageProcessingModel.getID() + " returned error: " + SnmpConstants.mpErrorMessage(iPrepareOutgoingMessage), iPrepareOutgoingMessage);
                            } catch (IOException e2) {
                                e = e2;
                                if (logger.isDebugEnabled()) {
                                    e.printStackTrace();
                                }
                                throw new MessageException(e.getMessage(), SnmpConstants.SNMP_MD_ERROR, e);
                            } catch (IndexOutOfBoundsException e3) {
                                e = e3;
                                i2 = version;
                                str = "Unsupported message processing model: ";
                                i3 = SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL;
                                throw new MessageException(str + i2, i3, e);
                            } catch (MessageException e4) {
                                e = e4;
                                if (logger.isDebugEnabled()) {
                                    e.printStackTrace();
                                }
                                throw e;
                            }
                        } catch (IndexOutOfBoundsException e5) {
                            e = e5;
                        }
                    } else {
                        i2 = version;
                        StringBuilder sb2 = new StringBuilder();
                        str = "Unsupported message processing model: ";
                        try {
                            sb2.append(str);
                            sb2.append(i2);
                            String string = sb2.toString();
                            i3 = SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL;
                            try {
                                throw new MessageException(string, SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL);
                            } catch (IndexOutOfBoundsException e6) {
                                e = e6;
                            }
                        } catch (IndexOutOfBoundsException e7) {
                            e = e7;
                            i3 = SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL;
                        }
                    }
                } catch (IndexOutOfBoundsException e8) {
                    e = e8;
                }
            } catch (IndexOutOfBoundsException e9) {
                e = e9;
                i2 = version;
                str = "Unsupported message processing model: ";
            }
            i3 = SnmpConstants.SNMP_MD_UNSUPPORTED_MP_MODEL;
            throw new MessageException(str + i2, i3, e);
        } catch (MessageException e10) {
            e = e10;
        } catch (IOException e11) {
            e = e11;
        }
    }

    @Override // org.snmp4j.MessageDispatcher
    public PduHandle sendPdu(TransportMapping transportMapping, Target target, PDU pdu, boolean z) throws MessageException {
        return sendPdu(transportMapping, target, pdu, z, null);
    }
}