xDrip+ v04633772025.07.16 - XdripWebService.java 源代码

package com.eveningoutpost.dexdrip.webservices;

import android.os.Build;
import android.util.Log;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.xdrip;
import com.google.common.base.Charsets;
import com.google.common.hash.Hashing;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.concurrent.atomic.AtomicInteger;
import javax.net.ssl.SSLServerSocketFactory;

public class XdripWebService implements Runnable {
    private static volatile XdripWebService instance;
    private static volatile XdripWebService ssl_instance;
    private boolean isRunning;
    private final int listenPort;
    private ServerSocket mServerSocket;
    private DateTimeFormatter rfc7231formatter;
    private final AtomicInteger thread_count = new AtomicInteger();
    private final boolean useSSL;

    private XdripWebService(int i, boolean z) {
        DateTimeFormatter ofPattern;
        if (Build.VERSION.SDK_INT >= 26) {
            ofPattern = DateTimeFormatter.ofPattern("EEE, dd MMM yyyy HH:mm:ss O", Locale.ENGLISH);
            this.rfc7231formatter = ofPattern;
        }
        this.listenPort = i;
        this.useSSL = z;
    }

    public static void immortality() {
        if (Pref.getBooleanDefaultFalse("xdrip_webservice")) {
            easyStart();
        } else if (instance != null) {
            easyStop();
        }
    }

    public static void settingsChanged() {
        easyStop();
        immortality();
    }

    private static synchronized void easyStop() {
        synchronized (XdripWebService.class) {
            try {
                UserError.Log.d("xDripWebService", "running easyStop()");
                instance.stop();
                instance = null;
                ssl_instance.stop();
                ssl_instance = null;
            } catch (NullPointerException unused) {
            }
        }
    }

    private static synchronized void easyStart() {
        synchronized (XdripWebService.class) {
            if (instance == null) {
                UserError.Log.d("xDripWebService", "easyStart() Starting new instance");
                instance = new XdripWebService(17580, false);
                ssl_instance = new XdripWebService(17581, true);
            }
            instance.startIfNotRunning();
            ssl_instance.startIfNotRunning();
        }
    }

    private void startIfNotRunning() {
        if (this.isRunning) {
            return;
        }
        UserError.Log.d("xDripWebService", "Not running so starting");
        start();
    }

    public void start() {
        this.isRunning = true;
        new Thread(this).start();
    }

    public synchronized void stop() {
        try {
            this.isRunning = false;
            ServerSocket serverSocket = this.mServerSocket;
            if (serverSocket != null) {
                serverSocket.close();
                this.mServerSocket = null;
            }
        } catch (IOException e) {
            Log.e("xDripWebService", "Error closing the server socket.", e);
        }
    }

    @Override
    public void run() {
        try {
            boolean booleanDefaultFalse = Pref.getBooleanDefaultFalse("xdrip_webservice_open");
            InetAddress inetAddress = null;
            if (this.useSSL) {
                UserError.Log.d("xDripWebService", "Attempting to initialize SSL");
                SSLServerSocketFactory makeSSLSocketFactory = SSLServerSocketHelper.makeSSLSocketFactory(new BufferedInputStream(xdrip.getAppContext().getResources().openRawResource(2131689967)), "password".toCharArray());
                int i = this.listenPort;
                if (!booleanDefaultFalse) {
                    inetAddress = InetAddress.getByName("127.0.0.1");
                }
                this.mServerSocket = makeSSLSocketFactory.createServerSocket(i, 1, inetAddress);
            } else {
                int i2 = this.listenPort;
                if (!booleanDefaultFalse) {
                    inetAddress = InetAddress.getByName("127.0.0.1");
                }
                this.mServerSocket = new ServerSocket(i2, 1, inetAddress);
            }
            while (this.isRunning) {
                final Socket accept = this.mServerSocket.accept();
                int i3 = this.thread_count.get();
                if (i3 < 15) {
                    Log.d("xDripWebService", "Running threads: " + i3);
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            XdripWebService.this.thread_count.incrementAndGet();
                            try {
                                try {
                                    XdripWebService.this.handle(accept);
                                    accept.close();
                                } catch (SocketException unused) {
                                } catch (IOException e) {
                                    Log.e("xDripWebService", "Web server thread error.", e);
                                }
                            } finally {
                                XdripWebService.this.thread_count.decrementAndGet();
                            }
                        }
                    }).start();
                } else {
                    if (JoH.ratelimit("webservice-thread-overheat", 60)) {
                        UserError.Log.wtf("xDripWebService", "Web service jammed with too many connections > " + i3);
                    }
                    accept.close();
                }
            }
        } catch (SocketException unused) {
        } catch (IOException e) {
            Log.e("xDripWebService", "Web server error.", e);
        }
    }

    static class CRLFPrintStream extends PrintStream {
        public CRLFPrintStream(OutputStream outputStream) {
            super(outputStream);
        }

        @Override
        public void println(String str) {
            super.println(str + "\r");
        }

        @Override
        public void println() {
            println("");
        }
    }

    public void handle(java.net.Socket r18) throws java.io.IOException {
        throw new UnsupportedOperationException("Method not decompiled: com.eveningoutpost.dexdrip.webservices.XdripWebService.handle(java.net.Socket):void");
    }

    private void writeServerError(PrintStream printStream) {
        printStream.println("HTTP/1.0 500 Internal Server Error");
        printStream.flush();
        UserError.Log.e("xDripWebService", "Internal server error reply");
    }

    public static String hashPassword(String str) {
        if (str.isEmpty()) {
            return null;
        }
        return Hashing.sha1().hashBytes(str.getBytes(Charsets.UTF_8)).toString();
    }
}