050 IP Phone v2.3.0 - u.java 源代码

package i5;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.security.KeyStore;
import java.security.cert.X509Certificate;
import javax.net.ServerSocketFactory;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class u extends i5.a {
    private static p7.a k = s5.d.a(u.class);
    private ServerSocket f;
    private boolean g;
    private boolean h;
    private Thread i;
    private b j;

    class a implements X509TrustManager {
        a() {
        }

        @Override
        public void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    }

    private class b implements Runnable {
        private b() {
        }

        @Override
        public void run() {
            u.k.e("Accepting TLS connection [" + u.this.e() + ":" + u.this.c() + "]");
            while (!u.this.s()) {
                if (u.this.r()) {
                    try {
                        Socket accept = u.this.f.accept();
                        SocketAddress remoteSocketAddress = accept.getRemoteSocketAddress();
                        if (u.k.c()) {
                            u.k.a("accept TLS connection,address=[" + remoteSocketAddress + "]");
                        }
                        j i = u.this.i();
                        if (i != null) {
                            i.o(v.m(accept));
                        }
                    } catch (Throwable th) {
                        u.k.f("Connection interrupted", th);
                        if (!u.this.s()) {
                            u.this.close();
                        }
                    }
                } else {
                    u.this.j(1000L);
                }
            }
            u.k.e("TLS acceptor terminated,socket=[" + u.this + "]");
        }

        b(u uVar, a aVar) {
            this();
        }
    }

    protected u(ServerSocket serverSocket, InetAddress inetAddress, int i) {
        super(inetAddress, i, "tls");
        this.g = true;
        this.h = false;
        this.j = new b(this, null);
        this.f = serverSocket;
    }

    private static void n(ServerSocket serverSocket) {
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (Exception e) {
                if (k.c()) {
                    k.b("Failed to close server socket", e);
                }
            }
        }
    }

    private static ServerSocketFactory o(boolean z) {
        return z ? p() : SSLServerSocketFactory.getDefault();
    }

    private static ServerSocketFactory p() {
        try {
            return q(new TrustManager[]{new a()});
        } catch (Exception e) {
            if (k.c()) {
                k.b("Failed to initialize TLS socket for debugging", e);
            }
            if (e instanceof IOException) {
                throw ((IOException) e);
            }
            k.h("Failed to initialize TLS socket", e);
            throw new IOException("Failed to initialize TLS socket");
        }
    }

    private static ServerSocketFactory q(TrustManager[] trustManagerArr) {
        KeyManagerFactory keyManagerFactory;
        try {
            if ("BKS".equals(KeyStore.getDefaultType())) {
                KeyStore keyStore = KeyStore.getInstance("BKS");
                keyStore.load(f.a(), f.b());
                keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
                keyManagerFactory.init(keyStore, f.b());
            } else {
                KeyStore keyStore2 = KeyStore.getInstance("JKS");
                keyStore2.load(n.a(), n.b());
                keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
                keyManagerFactory.init(keyStore2, n.b());
            }
            SSLContext sSLContext = SSLContext.getInstance("TLS");
            sSLContext.init(keyManagerFactory.getKeyManagers(), trustManagerArr, null);
            return sSLContext.getServerSocketFactory();
        } catch (Exception e) {
            if (k.c()) {
                k.b("Failed to initialize TLS socket for debugging", e);
            }
            if (e instanceof IOException) {
                throw ((IOException) e);
            }
            k.h("Failed to initialize TLS socket", e);
            throw new IOException("Failed to initialize TLS socket");
        }
    }

    public synchronized boolean r() {
        return this.h;
    }

    public static u t(ServerSocketFactory serverSocketFactory, String str, int i) {
        k.e("opening server socket, IP address = \"" + str + "\", port = \"" + i + "\"");
        ServerSocket createServerSocket = str == null ? serverSocketFactory.createServerSocket(i, -1, null) : serverSocketFactory.createServerSocket(i, -1, InetAddress.getByName(str));
        InetAddress inetAddress = createServerSocket.getInetAddress();
        int localPort = createServerSocket.getLocalPort();
        k.e("server socket bound, IP address = \"" + inetAddress + "\", port = \"" + localPort + "\"");
        return new u(createServerSocket, inetAddress, localPort);
    }

    public static u u(boolean z, String str, int i) {
        return t(o(z), str, i);
    }

    private synchronized void v() {
        Thread thread = new Thread(this.j, "TLS Acceptor[" + toString() + "]");
        this.i = thread;
        thread.start();
    }

    @Override
    public String a() {
        return "tls";
    }

    @Override
    public int b() {
        return 2;
    }

    @Override
    public synchronized void close() {
        try {
            k.e("closing server socket, IP address = \"" + e() + "\", port = \"" + c() + "\"");
            if (this.g) {
                this.h = false;
                this.g = false;
                n(this.f);
            } else if (k.c()) {
                k.a("server socket already closed,address=[" + toString() + "]");
            }
        } catch (Throwable th) {
            throw th;
        }
    }

    public synchronized boolean s() {
        return !this.g;
    }

    @Override
    public synchronized void start() {
        try {
            if (this.i == null) {
                v();
                if (k.c()) {
                    k.a("acceptor started,socket=[" + toString() + "] ");
                }
                this.h = true;
            } else if (k.c()) {
                k.a("acceptor already started,address=[" + toString() + "]");
            }
        } catch (Throwable th) {
            throw th;
        }
    }
}