package org.snmp4j.agent.example;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.apache.log4j.BasicConfigurator;
import org.snmp4j.MessageDispatcher;
import org.snmp4j.MessageDispatcherImpl;
import org.snmp4j.TransportMapping;
import org.snmp4j.agent.AgentConfigManager;
import org.snmp4j.agent.DefaultMOContextScope;
import org.snmp4j.agent.DefaultMOServer;
import org.snmp4j.agent.DuplicateRegistrationException;
import org.snmp4j.agent.MOQuery;
import org.snmp4j.agent.MOQueryWithSource;
import org.snmp4j.agent.MOScope;
import org.snmp4j.agent.MOServer;
import org.snmp4j.agent.ManagedObject;
import org.snmp4j.agent.cfg.EngineBootsCounterFile;
import org.snmp4j.agent.example.Snmp4jDemoMib;
import org.snmp4j.agent.io.DefaultMOPersistenceProvider;
import org.snmp4j.agent.io.MOInput;
import org.snmp4j.agent.io.MOInputFactory;
import org.snmp4j.agent.io.prop.PropertyMOInput;
import org.snmp4j.agent.mo.DefaultMOFactory;
import org.snmp4j.agent.mo.MOFactory;
import org.snmp4j.agent.mo.MOMutableTableRow;
import org.snmp4j.agent.mo.MOTableRowEvent;
import org.snmp4j.agent.mo.MOTableRowListener;
import org.snmp4j.agent.mo.snmp.TimeStamp;
import org.snmp4j.agent.mo.util.VariableProvider;
import org.snmp4j.agent.request.Request;
import org.snmp4j.agent.request.RequestStatus;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.agent.request.SubRequestIterator;
import org.snmp4j.log.Log4jLogFactory;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.log.LogLevel;
import org.snmp4j.mp.MPv3;
import org.snmp4j.security.SecurityProtocols;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.Counter32;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.TransportMappings;
import org.snmp4j.util.ArgumentParser;
import org.snmp4j.util.SnmpConfigurator;
import org.snmp4j.util.ThreadPool;

/* JADX INFO: loaded from: classes.dex */
public class SampleAgent implements VariableProvider {
    protected AgentConfigManager agent;
    private File bootCounterFile;
    private String configFile;
    private LogAdapter logger = LogFactory.getLogger(SampleAgent.class);
    protected Modules modules;
    protected MOServer server;
    protected Properties tableSizeLimits;

    class DemoTableRowListener implements MOTableRowListener<Snmp4jDemoMib.Snmp4jDemoEntryRow> {
        DemoTableRowListener() {
        }

        @Override // org.snmp4j.agent.mo.MOTableRowListener
        public void rowChanged(MOTableRowEvent mOTableRowEvent) {
            if (mOTableRowEvent.getType() == 1 || mOTableRowEvent.getType() == 4) {
                return;
            }
            Counter32 counter32 = (Counter32) mOTableRowEvent.getRow().getValue(2);
            if (counter32 == null) {
                counter32 = new Counter32(0L);
                ((MOMutableTableRow) mOTableRowEvent.getRow()).setValue(2, counter32);
            }
            counter32.increment();
            ((TimeStamp) mOTableRowEvent.getTable().getColumn(3)).update((MOMutableTableRow) mOTableRowEvent.getRow(), 3);
            Integer32 integer32 = new Integer32(2);
            int type = mOTableRowEvent.getType();
            if (type == 2) {
                integer32.setValue(1);
            } else if (type == 3) {
                integer32.setValue(3);
            }
            OID oid = mOTableRowEvent.getTable().getOID();
            OID oid2 = new OID(oid);
            oid2.append(5);
            oid2.append(mOTableRowEvent.getRow().getIndex());
            OID oid3 = new OID(oid);
            oid3.append(9);
            oid3.append(mOTableRowEvent.getRow().getIndex());
            SampleAgent.this.modules.getSnmp4jDemoMib().snmp4jDemoEvent(SampleAgent.this.agent.getNotificationOriginator(), new OctetString(), new VariableBinding[]{new VariableBinding(oid2, counter32), new VariableBinding(oid3, integer32)});
        }
    }

    static {
        LogFactory.setLogFactory(new Log4jLogFactory());
        BasicConfigurator.configure();
        LogFactory.getLogFactory().getRootLogger().setLogLevel(LogLevel.ALL);
    }

    public SampleAgent(Map<String, List<?>> map) {
        this.configFile = (String) map.get(SnmpConfigurator.O_COMMUNITY).get(0);
        this.bootCounterFile = new File((String) map.get(SnmpConfigurator.O_BOOT_COUNTER).get(0));
        String str = (String) map.get(SnmpConfigurator.O_TLS_VERSION).get(0);
        if (str != null) {
            System.setProperty(SnmpConfigurator.P_TLS_VERSION, str);
        }
        DefaultMOServer defaultMOServer = new DefaultMOServer();
        this.server = defaultMOServer;
        MOServer[] mOServerArr = {defaultMOServer};
        InputStream resourceAsStream = SampleAgent.class.getResourceAsStream("SampleAgentConfig.properties");
        if (map.containsKey("cfg")) {
            String str2 = (String) ArgumentParser.getValue(map, "cfg", 0);
            try {
                resourceAsStream = new FileInputStream(str2);
            } catch (FileNotFoundException e2) {
                this.logger.error("Config file '" + str2 + "' not found: " + e2.getMessage(), e2);
                throw new RuntimeException(e2);
            }
        }
        final Properties properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e3) {
            e3.printStackTrace();
        }
        MOInputFactory mOInputFactory = new MOInputFactory() { // from class: org.snmp4j.agent.example.SampleAgent.1
            @Override // org.snmp4j.agent.io.MOInputFactory
            public MOInput createMOInput() {
                return new PropertyMOInput(properties, SampleAgent.this);
            }
        };
        InputStream resourceAsStream2 = SampleAgent.class.getResourceAsStream("SampleAgentTableSizeLimits.properties");
        if (map.containsKey("ts")) {
            try {
                resourceAsStream2 = new FileInputStream((String) ArgumentParser.getValue(map, "ts", 0));
            } catch (FileNotFoundException e4) {
                e4.printStackTrace();
            }
        }
        Properties properties2 = new Properties();
        this.tableSizeLimits = properties2;
        try {
            properties2.load(resourceAsStream2);
        } catch (IOException e5) {
            e5.printStackTrace();
        }
        MessageDispatcherImpl messageDispatcherImpl = new MessageDispatcherImpl();
        addListenAddresses(messageDispatcherImpl, map.get(SnmpConfigurator.O_ADDRESS));
        this.agent = new AgentConfigManager(new OctetString(MPv3.createLocalEngineID()), messageDispatcherImpl, null, mOServerArr, ThreadPool.create("SampleAgent", 3), mOInputFactory, new DefaultMOPersistenceProvider(mOServerArr, this.configFile), new EngineBootsCounterFile(this.bootCounterFile));
    }

    public static void main(String[] strArr) {
        try {
            SampleAgent sampleAgent = new SampleAgent(new ArgumentParser("-c[s{=SampleAgent.cfg}] -bc[s{=SampleAgent.bc}] +ts[s] +cfg[s] +tls-version[s{=TLSv1}<TLSv1[\\.1|\\.2]?[,TLSv1[\\.1|\\.2]?]*>] ", "#address[s<(udp|tcp|tls):.*[/[0-9]+]?>] ..").parse(strArr));
            SecurityProtocols.getInstance().addDefaultProtocols();
            sampleAgent.run();
        } catch (ParseException e2) {
            System.err.println(e2.getMessage());
        }
    }

    protected void addListenAddresses(MessageDispatcher messageDispatcher, List<String> list) {
        for (String str : list) {
            Address address = GenericAddress.parse(str);
            if (address == null) {
                this.logger.fatal("Could not parse address string '" + str + "'");
                return;
            }
            TransportMapping<? extends Address> transportMappingCreateTransportMapping = TransportMappings.getInstance().createTransportMapping(address);
            if (transportMappingCreateTransportMapping != null) {
                messageDispatcher.addTransportMapping(transportMappingCreateTransportMapping);
            } else {
                this.logger.warn("No transport mapping available for address '" + address + "'.");
            }
        }
    }

    protected MOFactory getFactory() {
        return DefaultMOFactory.getInstance();
    }

    @Override // org.snmp4j.agent.mo.util.VariableProvider
    public Variable getVariable(String str) {
        OID oid;
        OctetString octetString;
        int iIndexOf = str.indexOf(58);
        if (iIndexOf >= 0) {
            OctetString octetString2 = new OctetString(str.substring(0, iIndexOf));
            oid = new OID(str.substring(iIndexOf + 1, str.length()));
            octetString = octetString2;
        } else {
            oid = new OID(str);
            octetString = null;
        }
        final DefaultMOContextScope defaultMOContextScope = new DefaultMOContextScope(octetString, oid, true, oid, true);
        ManagedObject managedObjectLookup = this.server.lookup(new MOQueryWithSource(defaultMOContextScope, false, this));
        if (managedObjectLookup == null) {
            return null;
        }
        final VariableBinding variableBinding = new VariableBinding(oid);
        final RequestStatus requestStatus = new RequestStatus();
        managedObjectLookup.get(new SubRequest() { // from class: org.snmp4j.agent.example.SampleAgent.2
            private boolean completed;
            private MOQuery query;

            @Override // org.snmp4j.agent.request.SubRequest
            public void completed() {
                this.completed = true;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public int getErrorStatus() {
                return requestStatus.getErrorStatus();
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public int getIndex() {
                return 0;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public MOQuery getQuery() {
                return this.query;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public Request getRequest() {
                return null;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public MOScope getScope() {
                return defaultMOContextScope;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public RequestStatus getStatus() {
                return requestStatus;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public ManagedObject getTargetMO() {
                return null;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public Object getUndoValue() {
                return null;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public Object getUserObject() {
                return null;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public VariableBinding getVariableBinding() {
                return variableBinding;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public boolean hasError() {
                return false;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public boolean isComplete() {
                return this.completed;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public SubRequestIterator<SubRequest> repetitions() {
                return null;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public void setErrorStatus(int i2) {
                requestStatus.setErrorStatus(i2);
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public void setQuery(MOQuery mOQuery) {
                this.query = mOQuery;
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public void setTargetMO(ManagedObject managedObject) {
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public void setUndoValue(Object obj) {
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public void setUserObject(Object obj) {
            }

            @Override // org.snmp4j.agent.request.SubRequest
            public void updateNextRepetition() {
            }
        });
        return variableBinding.getVariable();
    }

    protected void registerMIBs() {
        if (this.modules == null) {
            Modules modules = new Modules(getFactory());
            this.modules = modules;
            modules.getSnmp4jDemoMib().getSnmp4jDemoEntry().addMOTableRowListener(new DemoTableRowListener());
            ((TimeStamp) this.modules.getSnmp4jDemoMib().getSnmp4jDemoEntry().getColumn(3)).setSysUpTime(this.agent.getSysUpTime());
        }
        try {
            this.modules.registerMOs(this.server, null);
        } catch (DuplicateRegistrationException e2) {
            this.logger.error("Duplicate registration: " + e2.getMessage() + ". MIB object registration may be incomplete!", e2);
        }
    }

    public void run() {
        this.agent.initialize();
        registerMIBs();
        this.agent.setupProxyForwarder();
        this.agent.setTableSizeLimits(this.tableSizeLimits);
        this.agent.run();
    }
}