Validate complete JassDoc downloads

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/JassDocService.java

@@ -29,6 +29,7 @@
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
@@ -809,6 +810,9 @@ void restoreBackup(Path backup, Path target, IOException installFailure) {
 
     private void validateDownloadedDatabase(Path downloaded) throws IOException {
         try (Connection conn = open(downloaded)) {
+            if (!passesIntegrityCheck(conn)) {
+                throw new IOException("Downloaded JassDoc database failed SQLite integrity check");
+            }
             if (discoverSchemas(conn).isEmpty() && !hasCompatibleLegacyJassdocSchema(conn)) {
                 throw new IOException("Downloaded file is not a compatible JassDoc database");
             }
@@ -817,6 +821,15 @@ private void validateDownloadedDatabase(Path downloaded) throws IOException {
         }
     }
 
+    private boolean passesIntegrityCheck(Connection conn) throws SQLException {
+        try (Statement statement = conn.createStatement();
+             ResultSet result = statement.executeQuery("PRAGMA integrity_check")) {
+            return result.next()
+                && "ok".equalsIgnoreCase(result.getString(1))
+                && !result.next();
+        }
+    }
+
     private void replaceAtomically(Path source, Path target) throws IOException {
         try {
             Files.move(source, target, StandardCopyOption.REPLACE_EXISTING,
@@ -827,14 +840,7 @@ private void replaceAtomically(Path source, Path target) throws IOException {
     }
 
     private HttpURLConnection openHttpConnection(URL url) throws IOException {
-        Optional<String> proxySetting = Utils.getEnvOrConfig("WURST_JASSDOC_DB_PROXY");
-        if (proxySetting.isEmpty()) {
-            Optional<String> noProxy = firstConfigured("NO_PROXY", "no_proxy");
-            if (noProxy.isPresent() && shouldBypassProxy(url.getHost(), noProxy.get())) {
-                return (HttpURLConnection) url.openConnection();
-            }
-            proxySetting = firstConfigured("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy");
-        }
+        Optional<String> proxySetting = selectProxySetting(url, Utils::getEnvOrConfig);
         if (proxySetting.isEmpty()) {
             return (HttpURLConnection) url.openConnection();
         }
@@ -851,6 +857,25 @@ private HttpURLConnection openHttpConnection(URL url) throws IOException {
         return connection;
     }
 
+    static Optional<String> selectProxySetting(URL url,
+                                                Function<String, Optional<String>> lookup) {
+        Optional<String> proxySetting = lookup.apply("WURST_JASSDOC_DB_PROXY");
+        if (proxySetting.isPresent()) {
+            return proxySetting;
+        }
+        Optional<String> noProxy = firstConfigured(lookup, "NO_PROXY", "no_proxy");
+        if (noProxy.isPresent() && shouldBypassProxy(url.getHost(), noProxy.get())) {
+            return Optional.empty();
+        }
+        if ("https".equalsIgnoreCase(url.getProtocol())) {
+            return firstConfigured(lookup, "HTTPS_PROXY", "https_proxy");
+        }
+        if ("http".equalsIgnoreCase(url.getProtocol())) {
+            return firstConfigured(lookup, "HTTP_PROXY", "http_proxy");
+        }
+        return Optional.empty();
+    }
+
     static URI parseHttpProxyUri(String value) throws IOException {
         URI proxyUri;
         try {
@@ -895,9 +920,10 @@ static boolean shouldBypassProxy(String host, String noProxySetting) {
         return false;
     }
 
-    private Optional<String> firstConfigured(String... names) {
+    private static Optional<String> firstConfigured(
+        Function<String, Optional<String>> lookup, String... names) {
         return Stream.of(names)
-            .map(Utils::getEnvOrConfig)
+            .map(lookup)
             .flatMap(Optional::stream)
             .findFirst();
     }

de.peeeq.wurstscript/src/test/java/de/peeeq/wurstio/languageserver/JassDocServiceTests.java

@@ -3,13 +3,17 @@
 import org.testng.annotations.Test;
 
 import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.ResultSet;
 import java.sql.Statement;
+import java.util.Map;
+import java.util.Optional;
 
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertFalse;
@@ -74,6 +78,42 @@ public void incompleteLegacySchemaDoesNotReplaceExistingDatabase() throws Except
         assertEquals(Files.readString(target, StandardCharsets.UTF_8), "working database");
     }
 
+    @Test
+    public void corruptDatabaseWithValidSchemaDoesNotReplaceExistingDatabase() throws Exception {
+        Path dir = Files.createTempDirectory("jassdoc-corrupt-download-");
+        Path target = dir.resolve("jassdoc-latest.db");
+        Path downloaded = dir.resolve("download.tmp");
+        Files.writeString(target, "working database", StandardCharsets.UTF_8);
+        int pageSize;
+        int indexRootPage;
+        try (Connection conn = DriverManager.getConnection("jdbc:sqlite:" + downloaded.toAbsolutePath());
+             Statement statement = conn.createStatement()) {
+            statement.execute("CREATE TABLE docs(name TEXT, documentation TEXT)");
+            for (int i = 0; i < 1_000; i++) {
+                statement.execute("INSERT INTO docs VALUES ('name" + i + "', '"
+                    + "documentation".repeat(40) + "')");
+            }
+            statement.execute("CREATE INDEX docs_name_idx ON docs(name)");
+            try (ResultSet result = statement.executeQuery("PRAGMA page_size")) {
+                assertTrue(result.next());
+                pageSize = result.getInt(1);
+            }
+            try (ResultSet result = statement.executeQuery(
+                "SELECT rootpage FROM sqlite_master WHERE name = 'docs_name_idx'")) {
+                assertTrue(result.next());
+                indexRootPage = result.getInt(1);
+            }
+        }
+        try (RandomAccessFile file = new RandomAccessFile(downloaded.toFile(), "rw")) {
+            file.seek((long) (indexRootPage - 1) * pageSize);
+            file.write(new byte[32]);
+        }
+
+        assertThrows(IOException.class,
+            () -> new JassDocService().installDownloadedDatabase(downloaded, target));
+        assertEquals(Files.readString(target, StandardCharsets.UTF_8), "working database");
+    }
+
     @Test
     public void restoreOverwritesAResidualPartialTarget() throws IOException {
         Path dir = Files.createTempDirectory("jassdoc-restore-");
@@ -116,6 +156,22 @@ public void proxyBypassSupportsStandardHostForms() {
             "github.com", "localhost, example.com"));
     }
 
+    @Test
+    public void standardProxyMatchesRequestProtocol() throws Exception {
+        Map<String, String> settings = Map.of(
+            "HTTPS_PROXY", "http://secure-proxy.example:8443",
+            "HTTP_PROXY", "http://plain-proxy.example:8080");
+
+        assertEquals(JassDocService.selectProxySetting(
+            URI.create("https://github.com/example").toURL(),
+            name -> Optional.ofNullable(settings.get(name))).orElseThrow(),
+            "http://secure-proxy.example:8443");
+        assertEquals(JassDocService.selectProxySetting(
+            URI.create("http://mirror.example/jass.db").toURL(),
+            name -> Optional.ofNullable(settings.get(name))).orElseThrow(),
+            "http://plain-proxy.example:8080");
+    }
+
     @Test
     public void unsupportedTlsProxyIsRejectedExplicitly() {
         IOException error = expectThrows(IOException.class,