package org.snmp4j.transport;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.nio.channels.CancelledKeyException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Map;
import java.util.TimerTask;
import org.snmp4j.SNMP4JSettings;
import org.snmp4j.TransportStateReference;
import org.snmp4j.asn1.BER;
import org.snmp4j.asn1.BERInputStream;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.security.SecurityLevel;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TcpAddress;
import org.snmp4j.util.CommonTimer;
import org.snmp4j.util.WorkerTask;

/* JADX INFO: loaded from: classes.dex */
public class DefaultTcpTransportMapping extends TcpTransportMapping {
    public static final int DEFAULT_MAX_BUSY_LOOPS = 100;
    private static final int MIN_SNMP_HEADER_LENGTH = 6;
    private static final LogAdapter logger = LogFactory.getLogger(DefaultTcpTransportMapping.class);
    private long connectionTimeout;
    private int maxBusyLoops;
    private MessageLengthDecoder messageLengthDecoder;
    private WorkerTask server;
    private boolean serverEnabled;
    private ServerThread serverThread;
    private CommonTimer socketCleaner;
    private Map<Address, SocketEntry> sockets;

    class ServerThread implements WorkerTask {
        private byte[] buf;
        private ServerSocketChannel ssc;
        private volatile boolean stop = false;
        private Throwable lastError = null;
        private LinkedList<SocketEntry> pending = new LinkedList<>();
        private Selector selector = Selector.open();

        public ServerThread() throws IOException {
            this.buf = new byte[DefaultTcpTransportMapping.this.getMaxInboundMessageSize()];
            if (DefaultTcpTransportMapping.this.serverEnabled) {
                ServerSocketChannel serverSocketChannelOpen = ServerSocketChannel.open();
                this.ssc = serverSocketChannelOpen;
                try {
                    serverSocketChannelOpen.configureBlocking(false);
                    InetSocketAddress inetSocketAddress = new InetSocketAddress(DefaultTcpTransportMapping.this.tcpAddress.getInetAddress(), DefaultTcpTransportMapping.this.tcpAddress.getPort());
                    DefaultTcpTransportMapping.this.setSocketOptions(this.ssc.socket());
                    this.ssc.socket().bind(inetSocketAddress);
                    this.ssc.register(this.selector, 16);
                } catch (IOException e2) {
                    DefaultTcpTransportMapping.logger.warn("Socket bind failed for " + DefaultTcpTransportMapping.this.tcpAddress + ": " + e2.getMessage());
                    try {
                        this.ssc.close();
                    } catch (IOException e3) {
                        DefaultTcpTransportMapping.logger.warn("Socket close failed after bind failure for " + DefaultTcpTransportMapping.this.tcpAddress + ": " + e3.getMessage());
                    }
                    throw e2;
                }
            }
        }

        private void closeChannel(SelectableChannel selectableChannel) {
            try {
                selectableChannel.close();
            } catch (IOException e2) {
                DefaultTcpTransportMapping.logger.warn(e2);
            }
        }

        private void connectChannel(SelectionKey selectionKey, TcpAddress tcpAddress) {
            SocketEntry socketEntry = (SocketEntry) selectionKey.attachment();
            try {
                SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                if (!socketChannel.isConnected()) {
                    if (socketChannel.finishConnect()) {
                        socketChannel.configureBlocking(false);
                        DefaultTcpTransportMapping.logger.debug("Connected to " + socketEntry.getPeerAddress());
                        DefaultTcpTransportMapping.this.timeoutSocket(socketEntry);
                        socketEntry.removeRegistration(this.selector, 8);
                        socketEntry.addRegistration(this.selector, 4);
                    } else {
                        socketEntry = null;
                    }
                }
                if (socketEntry != null) {
                    if (tcpAddress == null) {
                        tcpAddress = socketEntry.getPeerAddress();
                    }
                    DefaultTcpTransportMapping.logger.debug("Fire connected event for " + tcpAddress);
                    DefaultTcpTransportMapping.this.fireConnectionStateChanged(new TransportStateEvent(DefaultTcpTransportMapping.this, tcpAddress, 1, null));
                }
            } catch (IOException e2) {
                DefaultTcpTransportMapping.logger.warn(e2);
                selectionKey.cancel();
                closeChannel(selectionKey.channel());
                if (socketEntry != null) {
                    this.pending.remove(socketEntry);
                }
            }
        }

        private void dispatchMessage(TcpAddress tcpAddress, ByteBuffer byteBuffer, long j2, Object obj) {
            ByteBuffer byteBufferWrap;
            byteBuffer.flip();
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Received message from " + tcpAddress + " with length " + j2 + ": " + new OctetString(byteBuffer.array(), 0, (int) j2).toHexString());
            }
            if (DefaultTcpTransportMapping.this.isAsyncMsgProcessingSupported()) {
                int i2 = (int) j2;
                byte[] bArr = new byte[i2];
                System.arraycopy(byteBuffer.array(), 0, bArr, 0, i2);
                byteBufferWrap = ByteBuffer.wrap(bArr);
            } else {
                byteBufferWrap = ByteBuffer.wrap(byteBuffer.array(), 0, (int) j2);
            }
            DefaultTcpTransportMapping defaultTcpTransportMapping = DefaultTcpTransportMapping.this;
            SecurityLevel securityLevel = SecurityLevel.undefined;
            DefaultTcpTransportMapping.this.fireProcessMessage(tcpAddress, byteBufferWrap, new TransportStateReference(defaultTcpTransportMapping, tcpAddress, null, securityLevel, securityLevel, false, obj));
        }

        private void processPending() {
            synchronized (this.pending) {
                for (int i2 = 0; i2 < this.pending.size(); i2++) {
                    SocketEntry socketEntry = this.pending.get(i2);
                    try {
                        try {
                            if (socketEntry.getSocket().isConnected()) {
                                socketEntry.addRegistration(this.selector, 4);
                            } else {
                                socketEntry.addRegistration(this.selector, 8);
                            }
                        } catch (IOException e2) {
                            DefaultTcpTransportMapping.logger.error(e2);
                            this.pending.remove(socketEntry);
                            try {
                                socketEntry.getSocket().getChannel().close();
                                DefaultTcpTransportMapping.this.fireConnectionStateChanged(new TransportStateEvent(DefaultTcpTransportMapping.this, socketEntry.getPeerAddress(), 4, e2, socketEntry.message));
                            } catch (IOException e3) {
                                DefaultTcpTransportMapping.logger.error(e3);
                            }
                            this.lastError = e2;
                            if (SNMP4JSettings.isForwardRuntimeExceptions()) {
                                throw new RuntimeException(e2);
                            }
                        }
                    } catch (CancelledKeyException e4) {
                        DefaultTcpTransportMapping.logger.warn(e4);
                        this.pending.remove(socketEntry);
                        try {
                            socketEntry.getSocket().getChannel().close();
                            DefaultTcpTransportMapping.this.fireConnectionStateChanged(new TransportStateEvent(DefaultTcpTransportMapping.this, socketEntry.getPeerAddress(), 4, null, socketEntry.message));
                        } catch (IOException e5) {
                            DefaultTcpTransportMapping.logger.error(e5);
                        }
                    }
                }
            }
        }

        private boolean readMessage(SelectionKey selectionKey, SocketChannel socketChannel, TcpAddress tcpAddress) throws IOException {
            SocketEntry socketEntry = (SocketEntry) selectionKey.attachment();
            if (socketEntry == null) {
                socketEntry = (SocketEntry) DefaultTcpTransportMapping.this.sockets.get(tcpAddress);
            }
            if (socketEntry != null) {
                socketEntry.used();
                ByteBuffer readBuffer = socketEntry.getReadBuffer();
                if (readBuffer != null) {
                    int i2 = socketChannel.read(readBuffer);
                    if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                        DefaultTcpTransportMapping.logger.debug("Read " + i2 + " bytes from " + tcpAddress);
                    }
                    if (i2 >= 0 && (readBuffer.hasRemaining() || readBuffer.position() < DefaultTcpTransportMapping.this.messageLengthDecoder.getMinHeaderLength())) {
                        socketEntry.addRegistration(this.selector, 1);
                    } else if (i2 < 0) {
                        DefaultTcpTransportMapping.this.socketClosedRemotely(selectionKey, socketChannel, tcpAddress);
                    } else {
                        readSnmpMessagePayload(socketChannel, tcpAddress, socketEntry, readBuffer);
                    }
                    if (i2 == 0) {
                        return false;
                    }
                    socketEntry.resetBusyLoops();
                    return true;
                }
            }
            ByteBuffer byteBufferWrap = ByteBuffer.wrap(this.buf);
            byteBufferWrap.limit(DefaultTcpTransportMapping.this.messageLengthDecoder.getMinHeaderLength());
            if (!socketChannel.isOpen()) {
                selectionKey.cancel();
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Read channel not open, no bytes read from " + tcpAddress);
                }
                return false;
            }
            try {
                long j2 = socketChannel.read(byteBufferWrap);
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Reading header " + j2 + " bytes from " + tcpAddress);
                }
                if (byteBufferWrap.position() >= DefaultTcpTransportMapping.this.messageLengthDecoder.getMinHeaderLength()) {
                    readSnmpMessagePayload(socketChannel, tcpAddress, socketEntry, byteBufferWrap);
                } else if (j2 < 0) {
                    DefaultTcpTransportMapping.this.socketClosedRemotely(selectionKey, socketChannel, tcpAddress);
                } else if (socketEntry != null && j2 > 0) {
                    DefaultTcpTransportMapping.this.addBufferToReadBuffer(socketEntry, byteBufferWrap);
                    socketEntry.addRegistration(this.selector, 1);
                } else if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("No socket entry found for incoming address " + tcpAddress + " for incomplete message with length " + j2);
                }
                if (socketEntry == null || j2 == 0) {
                    return false;
                }
                socketEntry.resetBusyLoops();
                return true;
            } catch (ClosedChannelException unused) {
                selectionKey.cancel();
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Read channel not open, no bytes read from " + tcpAddress);
                }
                return false;
            }
        }

        private void readSnmpMessagePayload(SocketChannel socketChannel, TcpAddress tcpAddress, SocketEntry socketEntry, ByteBuffer byteBuffer) throws IOException {
            Socket socket;
            MessageLength messageLength = DefaultTcpTransportMapping.this.messageLengthDecoder.getMessageLength(ByteBuffer.wrap(byteBuffer.array()));
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Message length is " + messageLength);
            }
            if (messageLength.getMessageLength() > DefaultTcpTransportMapping.this.getMaxInboundMessageSize() || messageLength.getMessageLength() <= 0) {
                DefaultTcpTransportMapping.logger.error("Received message length " + messageLength + " is greater than inboundBufferSize " + DefaultTcpTransportMapping.this.getMaxInboundMessageSize());
                if (socketEntry == null || (socket = socketEntry.getSocket()) == null) {
                    return;
                }
                socket.close();
                DefaultTcpTransportMapping.logger.info("Socket to " + socketEntry.getPeerAddress() + " closed due to an error");
                return;
            }
            int messageLength2 = messageLength.getMessageLength();
            if (byteBuffer.position() < messageLength2) {
                if (byteBuffer.capacity() < messageLength2) {
                    if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                        DefaultTcpTransportMapping.logger.debug("Extending message buffer size according to message length to " + messageLength2);
                    }
                    byte[] bArr = new byte[messageLength2];
                    int iPosition = byteBuffer.position();
                    byteBuffer.flip();
                    byteBuffer.get(bArr, 0, iPosition);
                    byteBuffer = ByteBuffer.wrap(bArr);
                    byteBuffer.position(iPosition);
                    if (socketEntry != null) {
                        byteBuffer.limit(messageLength2);
                        socketEntry.setReadBuffer(byteBuffer);
                    }
                } else {
                    byteBuffer.limit(messageLength2);
                }
                socketChannel.read(byteBuffer);
            }
            ByteBuffer byteBuffer2 = byteBuffer;
            long jPosition = byteBuffer2.position();
            if (jPosition >= messageLength2) {
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Message completed with " + jPosition + " bytes and " + byteBuffer2.limit() + " buffer limit");
                }
                if (socketEntry != null) {
                    socketEntry.setReadBuffer(null);
                }
                dispatchMessage(tcpAddress, byteBuffer2, jPosition, socketEntry);
            } else if (socketEntry != null && byteBuffer2 != socketEntry.getReadBuffer()) {
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Adding buffer content to read buffer of entry " + socketEntry + ", buffer " + byteBuffer2);
                }
                DefaultTcpTransportMapping.this.addBufferToReadBuffer(socketEntry, byteBuffer2);
            }
            if (socketEntry != null) {
                socketEntry.addRegistration(this.selector, 1);
            }
        }

        private TcpAddress writeData(SelectionKey selectionKey, TcpAddress tcpAddress) {
            TcpAddress tcpAddress2;
            IOException e2;
            SocketEntry socketEntry = (SocketEntry) selectionKey.attachment();
            try {
                SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                tcpAddress2 = new TcpAddress(socketChannel.socket().getInetAddress(), socketChannel.socket().getPort());
                if (socketEntry != null) {
                    try {
                        if (!socketEntry.hasMessage()) {
                            synchronized (this.pending) {
                                this.pending.remove(socketEntry);
                                socketEntry.removeRegistration(this.selector, 4);
                            }
                        }
                    } catch (IOException e3) {
                        e2 = e3;
                        DefaultTcpTransportMapping.logger.warn(e2);
                        DefaultTcpTransportMapping.this.fireConnectionStateChanged(new TransportStateEvent(DefaultTcpTransportMapping.this, tcpAddress2, 2, e2));
                        closeChannel(selectionKey.channel());
                    }
                }
                if (socketEntry != null) {
                    writeMessage(socketEntry, socketChannel);
                }
            } catch (IOException e4) {
                tcpAddress2 = tcpAddress;
                e2 = e4;
            }
            return tcpAddress2;
        }

        private void writeMessage(SocketEntry socketEntry, SocketChannel socketChannel) throws IOException {
            byte[] bArrNextMessage = socketEntry.nextMessage();
            if (bArrNextMessage == null) {
                socketEntry.removeRegistration(this.selector, 4);
                if (!socketEntry.hasMessage() || socketEntry.isRegistered(4)) {
                    return;
                }
                socketEntry.addRegistration(this.selector, 4);
                DefaultTcpTransportMapping.logger.debug("Waking up selector");
                this.selector.wakeup();
                return;
            }
            socketChannel.write(ByteBuffer.wrap(bArrNextMessage));
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Sent message with length " + bArrNextMessage.length + " to " + socketEntry.getPeerAddress() + ": " + new OctetString(bArrNextMessage).toHexString());
            }
            socketEntry.addRegistration(this.selector, 1);
        }

        public void close() {
            this.stop = true;
            WorkerTask workerTask = DefaultTcpTransportMapping.this.server;
            if (workerTask != null) {
                workerTask.terminate();
            }
        }

        public Throwable getLastError() {
            return this.lastError;
        }

        @Override // org.snmp4j.util.WorkerTask
        public void interrupt() {
            this.stop = true;
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Interrupting worker task: " + ServerThread.class.getName());
            }
            this.selector.wakeup();
        }

        @Override // org.snmp4j.util.WorkerTask
        public void join() {
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Joining worker task: " + ServerThread.class.getName());
            }
        }

        /* JADX WARN: Removed duplicated region for block: B:100:0x001e A[SYNTHETIC] */
        /* JADX WARN: Removed duplicated region for block: B:91:0x00f8 A[SYNTHETIC] */
        @Override // java.lang.Runnable
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public void run() {
            /*
                Method dump skipped, instruction units count: 480
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.transport.DefaultTcpTransportMapping.ServerThread.run():void");
        }

        public void sendMessage(Address address, byte[] bArr, TransportStateReference transportStateReference) throws IOException {
            Socket socket;
            SocketChannel socketChannelOpen;
            SocketEntry socketEntry = (SocketEntry) DefaultTcpTransportMapping.this.sockets.get(address);
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Looking up connection for destination '" + address + "' returned: " + socketEntry);
                DefaultTcpTransportMapping.logger.debug(DefaultTcpTransportMapping.this.sockets.toString());
            }
            if (socketEntry != null) {
                synchronized (socketEntry) {
                    socketEntry.used();
                    socket = socketEntry.getSocket();
                }
            } else {
                socket = null;
            }
            if (socket != null && !socket.isClosed() && socket.isConnected()) {
                socketEntry.addMessage(bArr);
                synchronized (this.pending) {
                    this.pending.add(socketEntry);
                }
                DefaultTcpTransportMapping.logger.debug("Waking up selector for new message");
                this.selector.wakeup();
                return;
            }
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Socket for address '" + address + "' is closed, opening it...");
            }
            synchronized (this.pending) {
                this.pending.remove(socketEntry);
            }
            try {
                InetSocketAddress inetSocketAddress = new InetSocketAddress(((TcpAddress) address).getInetAddress(), ((TcpAddress) address).getPort());
                if (socket == null || socket.isClosed()) {
                    socketChannelOpen = SocketChannel.open();
                    socketChannelOpen.configureBlocking(false);
                    socketChannelOpen.connect(inetSocketAddress);
                } else {
                    socketChannelOpen = socket.getChannel();
                    socketChannelOpen.configureBlocking(false);
                    if (!socketChannelOpen.isConnectionPending()) {
                        socketChannelOpen.connect(inetSocketAddress);
                    }
                }
                SocketEntry socketEntry2 = DefaultTcpTransportMapping.this.new SocketEntry((TcpAddress) address, socketChannelOpen.socket());
                socketEntry2.addMessage(bArr);
                DefaultTcpTransportMapping.this.sockets.put(address, socketEntry2);
                synchronized (this.pending) {
                    this.pending.add(socketEntry2);
                }
                this.selector.wakeup();
                DefaultTcpTransportMapping.logger.debug("Trying to connect to " + address);
            } catch (IOException e2) {
                DefaultTcpTransportMapping.logger.error(e2);
                throw e2;
            }
        }

        @Override // org.snmp4j.util.WorkerTask
        public void terminate() {
            this.stop = true;
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Terminated worker task: " + ServerThread.class.getName());
            }
        }
    }

    public static class SnmpMesssageLengthDecoder implements MessageLengthDecoder {
        @Override // org.snmp4j.transport.MessageLengthDecoder
        public MessageLength getMessageLength(ByteBuffer byteBuffer) throws IOException {
            BER.MutableByte mutableByte = new BER.MutableByte();
            BERInputStream bERInputStream = new BERInputStream(byteBuffer);
            return new MessageLength((int) bERInputStream.getPosition(), BER.decodeHeader(bERInputStream, mutableByte, false));
        }

        @Override // org.snmp4j.transport.MessageLengthDecoder
        public int getMinHeaderLength() {
            return 6;
        }
    }

    class SocketEntry {
        private TcpAddress peerAddress;
        private Socket socket;
        private LinkedList<byte[]> message = new LinkedList<>();
        private ByteBuffer readBuffer = null;
        private volatile int registrations = 0;
        private volatile int busyLoops = 0;
        private long lastUse = System.nanoTime();

        public SocketEntry(TcpAddress tcpAddress, Socket socket) {
            this.peerAddress = tcpAddress;
            this.socket = socket;
        }

        public synchronized void addMessage(byte[] bArr) {
            this.message.add(bArr);
        }

        public synchronized void addRegistration(Selector selector, int i2) throws ClosedChannelException {
            if ((this.registrations & i2) == 0) {
                this.registrations |= i2;
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Adding operation " + i2 + " for: " + toString());
                }
                this.socket.getChannel().register(selector, this.registrations, this);
            } else if (!this.socket.getChannel().isRegistered()) {
                this.registrations = i2;
                if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                    DefaultTcpTransportMapping.logger.debug("Registering new operation " + i2 + " for: " + toString());
                }
                this.socket.getChannel().register(selector, i2, this);
            }
        }

        public long getLastUse() {
            return this.lastUse;
        }

        public TcpAddress getPeerAddress() {
            return this.peerAddress;
        }

        public ByteBuffer getReadBuffer() {
            return this.readBuffer;
        }

        public Socket getSocket() {
            return this.socket;
        }

        public synchronized boolean hasMessage() {
            return !this.message.isEmpty();
        }

        public synchronized boolean isRegistered(int i2) {
            return (this.registrations & i2) == i2;
        }

        public int nextBusyLoop() {
            int i2 = this.busyLoops + 1;
            this.busyLoops = i2;
            return i2;
        }

        public synchronized byte[] nextMessage() {
            if (this.message.size() <= 0) {
                return null;
            }
            return this.message.removeFirst();
        }

        public synchronized void removeRegistration(Selector selector, int i2) throws ClosedChannelException {
            if ((this.registrations & i2) == i2) {
                this.registrations = (i2 ^ (-1)) & this.registrations;
                this.socket.getChannel().register(selector, this.registrations, this);
            }
        }

        public void resetBusyLoops() {
            this.busyLoops = 0;
        }

        public void setReadBuffer(ByteBuffer byteBuffer) {
            this.readBuffer = byteBuffer;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("SocketEntry[peerAddress=");
            sb.append(this.peerAddress);
            sb.append(",socket=");
            sb.append(this.socket);
            sb.append(",lastUse=");
            sb.append(new Date(this.lastUse / 1000000));
            sb.append(",readBufferPosition=");
            ByteBuffer byteBuffer = this.readBuffer;
            sb.append(byteBuffer == null ? -1 : byteBuffer.position());
            sb.append("]");
            return sb.toString();
        }

        public void used() {
            this.lastUse = System.nanoTime();
        }
    }

    class SocketTimeout extends TimerTask {
        private SocketEntry entry;

        public SocketTimeout(SocketEntry socketEntry) {
            this.entry = socketEntry;
        }

        private void rescheduleCleanup(long j2, SocketEntry socketEntry) {
            long j3 = DefaultTcpTransportMapping.this.connectionTimeout - j2;
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Scheduling " + j3);
            }
            DefaultTcpTransportMapping.this.socketCleaner.schedule(DefaultTcpTransportMapping.this.new SocketTimeout(socketEntry), j3);
        }

        @Override // java.util.TimerTask
        public boolean cancel() {
            boolean zCancel = super.cancel();
            this.entry = null;
            return zCancel;
        }

        @Override // java.util.TimerTask, java.lang.Runnable
        public void run() {
            long jNanoTime = System.nanoTime();
            SocketEntry socketEntry = this.entry;
            if (socketEntry == null) {
                return;
            }
            long lastUse = (jNanoTime - socketEntry.getLastUse()) / 1000000;
            if (DefaultTcpTransportMapping.this.socketCleaner != null && lastUse < DefaultTcpTransportMapping.this.connectionTimeout) {
                rescheduleCleanup(lastUse, socketEntry);
                return;
            }
            if (DefaultTcpTransportMapping.logger.isDebugEnabled()) {
                DefaultTcpTransportMapping.logger.debug("Socket has not been used for " + lastUse + " milliseconds, closing it");
            }
            try {
                synchronized (socketEntry) {
                    if (lastUse >= DefaultTcpTransportMapping.this.connectionTimeout) {
                        DefaultTcpTransportMapping.this.sockets.remove(socketEntry.getPeerAddress());
                        socketEntry.getSocket().close();
                        if (DefaultTcpTransportMapping.logger.isInfoEnabled()) {
                            DefaultTcpTransportMapping.logger.info("Socket to " + socketEntry.getPeerAddress() + " closed due to timeout");
                        }
                    } else {
                        rescheduleCleanup(lastUse, socketEntry);
                    }
                }
            } catch (IOException e2) {
                DefaultTcpTransportMapping.logger.error(e2);
            }
        }
    }

    public DefaultTcpTransportMapping() throws IOException {
        super(new TcpAddress(InetAddress.getLocalHost(), 0));
        this.sockets = new Hashtable();
        this.connectionTimeout = 60000L;
        this.serverEnabled = false;
        this.messageLengthDecoder = new SnmpMesssageLengthDecoder();
        this.maxBusyLoops = 100;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void addBufferToReadBuffer(SocketEntry socketEntry, ByteBuffer byteBuffer) {
        if (logger.isDebugEnabled()) {
            logger.debug("Adding data " + byteBuffer + " to read buffer " + socketEntry.getReadBuffer());
        }
        int iPosition = byteBuffer.position();
        if (socketEntry.getReadBuffer() != null) {
            socketEntry.getReadBuffer().put(byteBuffer.array(), 0, iPosition);
            return;
        }
        byte[] bArr = new byte[byteBuffer.limit()];
        byteBuffer.flip();
        byteBuffer.get(bArr, 0, iPosition);
        ByteBuffer byteBufferWrap = ByteBuffer.wrap(bArr);
        byteBufferWrap.position(iPosition);
        socketEntry.setReadBuffer(byteBufferWrap);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void socketClosedRemotely(SelectionKey selectionKey, SocketChannel socketChannel, TcpAddress tcpAddress) throws IOException {
        logger.debug("Socket closed remotely");
        selectionKey.cancel();
        socketChannel.close();
        fireConnectionStateChanged(new TransportStateEvent(this, tcpAddress, 2, null));
        this.sockets.remove(tcpAddress);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public synchronized void timeoutSocket(SocketEntry socketEntry) {
        if (this.connectionTimeout > 0) {
            this.socketCleaner.schedule(new SocketTimeout(socketEntry), this.connectionTimeout);
        }
    }

    public long getConnectionTimeout() {
        return this.connectionTimeout;
    }

    protected int getMaxBusyLoops() {
        return this.maxBusyLoops;
    }

    @Override // org.snmp4j.transport.AbstractTransportMapping, org.snmp4j.TransportMapping
    public int getMaxInboundMessageSize() {
        return super.getMaxInboundMessageSize();
    }

    @Override // org.snmp4j.transport.TcpTransportMapping, org.snmp4j.transport.ConnectionOrientedTransportMapping
    public MessageLengthDecoder getMessageLengthDecoder() {
        return this.messageLengthDecoder;
    }

    public int getPriority() {
        Object obj = this.server;
        if (obj instanceof Thread) {
            return ((Thread) obj).getPriority();
        }
        return 5;
    }

    public String getThreadName() {
        Object obj = this.server;
        if (obj != null) {
            return ((Thread) obj).getName();
        }
        return null;
    }

    @Override // org.snmp4j.TransportMapping
    public boolean isListening() {
        return this.server != null;
    }

    public boolean isServerEnabled() {
        return this.serverEnabled;
    }

    @Override // org.snmp4j.transport.TcpTransportMapping, org.snmp4j.transport.AbstractTransportMapping, org.snmp4j.TransportMapping
    public synchronized void listen() throws IOException {
        if (this.server != null) {
            throw new SocketException("Port already listening");
        }
        this.serverThread = new ServerThread();
        this.server = SNMP4JSettings.getThreadFactory().createWorkerThread("DefaultTCPTransportMapping_" + getAddress(), this.serverThread, true);
        if (this.connectionTimeout > 0) {
            this.socketCleaner = SNMP4JSettings.getTimerFactory().createTimer();
        }
        this.server.run();
    }

    @Override // org.snmp4j.transport.TcpTransportMapping, org.snmp4j.transport.ConnectionOrientedTransportMapping
    public void setConnectionTimeout(long j2) {
        this.connectionTimeout = j2;
    }

    protected void setMaxBusyLoops(int i2) {
        this.maxBusyLoops = i2;
    }

    public void setMaxInboundMessageSize(int i2) {
        this.maxInboundMessageSize = i2;
    }

    @Override // org.snmp4j.transport.TcpTransportMapping, org.snmp4j.transport.ConnectionOrientedTransportMapping
    public void setMessageLengthDecoder(MessageLengthDecoder messageLengthDecoder) {
        if (messageLengthDecoder == null) {
            throw null;
        }
        this.messageLengthDecoder = messageLengthDecoder;
    }

    public void setPriority(int i2) {
        Object obj = this.server;
        if (obj instanceof Thread) {
            ((Thread) obj).setPriority(i2);
        }
    }

    public void setServerEnabled(boolean z) {
        this.serverEnabled = z;
    }

    protected void setSocketOptions(ServerSocket serverSocket) {
    }

    public void setThreadName(String str) {
        Object obj = this.server;
        if (obj instanceof Thread) {
            ((Thread) obj).setName(str);
        }
    }

    @Override // org.snmp4j.transport.TcpTransportMapping, org.snmp4j.transport.AbstractTransportMapping, org.snmp4j.TransportMapping
    public void close() {
        WorkerTask workerTask = this.server;
        if (workerTask != null) {
            workerTask.terminate();
            workerTask.interrupt();
            try {
                workerTask.join();
            } catch (InterruptedException e2) {
                logger.warn(e2);
            }
            this.server = null;
            for (SocketEntry socketEntry : this.sockets.values()) {
                Socket socket = socketEntry.getSocket();
                if (socket != null) {
                    try {
                        SocketChannel channel = socket.getChannel();
                        socket.close();
                        if (logger.isDebugEnabled()) {
                            logger.debug("Socket to " + socketEntry.getPeerAddress() + " closed");
                        }
                        if (channel != null) {
                            channel.close();
                            if (logger.isDebugEnabled()) {
                                logger.debug("Socket channel to " + socketEntry.getPeerAddress() + " closed");
                            }
                        }
                    } catch (IOException e3) {
                        logger.debug(e3);
                    }
                }
            }
            CommonTimer commonTimer = this.socketCleaner;
            if (commonTimer != null) {
                commonTimer.cancel();
            }
            this.socketCleaner = null;
        }
    }

    @Override // org.snmp4j.transport.TcpTransportMapping, org.snmp4j.transport.AbstractTransportMapping, org.snmp4j.TransportMapping
    public void sendMessage(TcpAddress tcpAddress, byte[] bArr, TransportStateReference transportStateReference) throws IOException {
        if (this.server == null) {
            listen();
        }
        this.serverThread.sendMessage(tcpAddress, bArr, transportStateReference);
    }

    public DefaultTcpTransportMapping(TcpAddress tcpAddress) throws IOException {
        super(tcpAddress);
        this.sockets = new Hashtable();
        this.connectionTimeout = 60000L;
        this.serverEnabled = false;
        this.messageLengthDecoder = new SnmpMesssageLengthDecoder();
        this.maxBusyLoops = 100;
        this.serverEnabled = true;
    }

    @Override // org.snmp4j.transport.ConnectionOrientedTransportMapping
    public synchronized boolean close(TcpAddress tcpAddress) throws IOException {
        if (logger.isDebugEnabled()) {
            logger.debug("Closing socket for peer address " + tcpAddress);
        }
        SocketEntry socketEntryRemove = this.sockets.remove(tcpAddress);
        if (socketEntryRemove == null) {
            return false;
        }
        if (socketEntryRemove.getSocket() != null) {
            SocketChannel channel = socketEntryRemove.getSocket().getChannel();
            socketEntryRemove.getSocket().close();
            if (logger.isInfoEnabled()) {
                logger.info("Socket to " + socketEntryRemove.getPeerAddress() + " closed");
            }
            if (channel != null) {
                channel.close();
                if (logger.isDebugEnabled()) {
                    logger.debug("Closed socket channel for peer address " + tcpAddress);
                }
            }
        }
        return true;
    }
}