X-Git-Url: https://gitweb.stoutner.com/?p=PrivacyBrowserAndroid.git;a=blobdiff_plain;f=app%2Fsrc%2Fmain%2Fjava%2Fcom%2Fstoutner%2Fprivacybrowser%2Fhelpers%2FBlocklistHelper.kt;fp=app%2Fsrc%2Fmain%2Fjava%2Fcom%2Fstoutner%2Fprivacybrowser%2Fhelpers%2FBlocklistHelper.kt;h=0000000000000000000000000000000000000000;hp=bded48c44947a2cc75e5731d9ff195e8b6934818;hb=5dc78bb8db242a068ec38565ef2a9e635224487a;hpb=97ff4463a390d0b789f19d1c45bf9fc47428c86c diff --git a/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.kt b/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.kt deleted file mode 100644 index bded48c4..00000000 --- a/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.kt +++ /dev/null @@ -1,2066 +0,0 @@ -/* - * Copyright 2018-2019,2021-2022 Soren Stoutner . - * - * This file is part of Privacy Browser Android . - * - * Privacy Browser Android is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * Privacy Browser Android is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Privacy Browser Android. If not, see . - */ - -package com.stoutner.privacybrowser.helpers - -import android.content.res.AssetManager - -import java.io.BufferedReader -import java.io.IOException -import java.io.InputStreamReader -import java.util.ArrayList -import java.util.regex.Pattern - -class BlocklistHelper { - companion object { - // Describe the schema of the string array in each entry of the resource requests array list. - const val REQUEST_DISPOSITION = 0 - const val REQUEST_URL = 1 - const val REQUEST_BLOCKLIST = 2 - const val REQUEST_SUBLIST = 3 - const val REQUEST_BLOCKLIST_ENTRIES = 4 - const val REQUEST_BLOCKLIST_ORIGINAL_ENTRY = 5 - - // The request disposition options. - const val REQUEST_DEFAULT = "0" - const val REQUEST_ALLOWED = "1" - const val REQUEST_THIRD_PARTY = "2" - const val REQUEST_BLOCKED = "3" - - // The whitelists. - const val MAIN_WHITELIST = "1" - const val FINAL_WHITELIST = "2" - const val DOMAIN_WHITELIST = "3" - const val DOMAIN_INITIAL_WHITELIST = "4" - const val DOMAIN_FINAL_WHITELIST = "5" - const val THIRD_PARTY_WHITELIST = "6" - const val THIRD_PARTY_DOMAIN_WHITELIST = "7" - const val THIRD_PARTY_DOMAIN_INITIAL_WHITELIST = "8" - - // The blacklists. - const val MAIN_BLACKLIST = "9" - const val INITIAL_BLACKLIST = "10" - const val FINAL_BLACKLIST = "11" - const val DOMAIN_BLACKLIST = "12" - const val DOMAIN_INITIAL_BLACKLIST = "13" - const val DOMAIN_FINAL_BLACKLIST = "14" - const val DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "15" - const val THIRD_PARTY_BLACKLIST = "16" - const val THIRD_PARTY_INITIAL_BLACKLIST = "17" - const val THIRD_PARTY_DOMAIN_BLACKLIST = "18" - const val THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST = "19" - const val THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST = "20" - const val THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "21" - const val REGULAR_EXPRESSION_BLACKLIST = "22" - } - - fun parseBlocklist(assetManager: AssetManager, blocklistName: String): ArrayList>> { - // Initialize the header list. - val headers: MutableList> = ArrayList() // 0. - - // Initialize the whitelists. - val mainWhitelist: MutableList> = ArrayList() // 1. - val finalWhitelist: MutableList> = ArrayList() // 2. - val domainWhitelist: MutableList> = ArrayList() // 3. - val domainInitialWhitelist: MutableList> = ArrayList() // 4. - val domainFinalWhitelist: MutableList> = ArrayList() // 5. - val thirdPartyWhitelist: MutableList> = ArrayList() // 6. - val thirdPartyDomainWhitelist: MutableList> = ArrayList() // 7. - val thirdPartyDomainInitialWhitelist: MutableList> = ArrayList() // 8. - - // Initialize the blacklists. - val mainBlacklist: MutableList> = ArrayList() // 9. - val initialBlacklist: MutableList> = ArrayList() // 10. - val finalBlacklist: MutableList> = ArrayList() // 11. - val domainBlacklist: MutableList> = ArrayList() // 12. - val domainInitialBlacklist: MutableList> = ArrayList() // 13. - val domainFinalBlacklist: MutableList> = ArrayList() // 14. - val domainRegularExpressionBlacklist: MutableList> = ArrayList() // 15. - val thirdPartyBlacklist: MutableList> = ArrayList() // 16. - val thirdPartyInitialBlacklist: MutableList> = ArrayList() // 17. - val thirdPartyDomainBlacklist: MutableList> = ArrayList() // 18. - val thirdPartyDomainInitialBlacklist: MutableList> = ArrayList() // 19. - val regularExpressionBlacklist: MutableList> = ArrayList() // 20. - val thirdPartyRegularExpressionBlacklist: MutableList> = ArrayList() // 21. - val thirdPartyDomainRegularExpressionBlacklist: MutableList> = ArrayList() // 22. - - // Populate the blocklists. The `try` is required by input stream reader. - try { - // Load the blocklist into a buffered reader. - val bufferedReader = BufferedReader(InputStreamReader(assetManager.open(blocklistName))) - - // Create strings for storing the block list entries. - var blocklistEntry: String - var originalBlocklistEntry: String - - // Parse the block list. - bufferedReader.forEachLine { - // Store the original block list entry. - originalBlocklistEntry = it - - // Remove any `^` from the block list entry. Privacy Browser does not process them in the interest of efficiency. - blocklistEntry = it.replace("^", "") - - // Parse the entry. - if (blocklistEntry.contains("##") || blocklistEntry.contains("#?#") || blocklistEntry.contains("#@#") || blocklistEntry.startsWith("[")) { - // Entries that contain `##`, `#?#`, and `#@#` are for hiding elements in the main page's HTML. Entries that start with `[` describe the AdBlock compatibility level. - // Do nothing. Privacy Browser does not currently use these entries. - - //Log.i("Blocklists", "Not added: " + blocklistEntry); - } else if (blocklistEntry.contains("\$csp=script-src")) { // Ignore entries that contain `$csp=script-src`. - // Do nothing. It is uncertain what this directive is even supposed to mean, and it is blocking entire websites like androidcentral.com. https://redmine.stoutner.com/issues/306. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else if (blocklistEntry.contains("\$websocket") || blocklistEntry.contains("\$third-party,websocket") || blocklistEntry.contains("\$script,websocket")) { - // Ignore entries with `websocket`. - // Do nothing. Privacy Browser does not differentiate between websocket requests and other requests and these entries cause a lot of false positives. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else if (blocklistEntry.startsWith("!")) { // Comment entries. - if (blocklistEntry.startsWith("! Version:")) { - // Get the list version number. - val listVersion = arrayOf(blocklistEntry.substring(11)) - - // Store the list version in the headers list. - headers.add(listVersion) - } - - if (blocklistEntry.startsWith("! Title:")) { - // Get the list title. - val listTitle = arrayOf(blocklistEntry.substring(9)) - - // Store the list title in the headers list. - headers.add(listTitle) - } - - //Log.i("Blocklists", "Not added: " + blocklistEntry); - } else if (blocklistEntry.startsWith("@@")) { // Entries that begin with `@@` are whitelists. - // Remove the `@@` - blocklistEntry = blocklistEntry.substring(2) - - // Strip out any initial `||`. Privacy Browser doesn't differentiate items that only match against the end of the domain name. - if (blocklistEntry.startsWith("||")) { - blocklistEntry = blocklistEntry.substring(2) - } - - if (blocklistEntry.contains("$")) { // Filter entries. - if (blocklistEntry.contains("~third-party")) { // Ignore entries that contain `~third-party`. - // Do nothing. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else if (blocklistEntry.contains("third-party")) { // Third-party whitelist entries. - if (blocklistEntry.contains("domain=")) { // Third-party domain whitelist entries. - // Parse the entry. - var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - if (domains.contains("~")) { // It is uncertain what a `~` domain means inside an `@@` entry. - // Do Nothing - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else if (blocklistEntry.startsWith("|")) { // Third-party domain initial whitelist entries. - // Strip out the initial `|`. - entry = entry.substring(1) - - if (entry == "http://" || entry == "https://") { // Ignore generic entries. - // Do nothing. These entries are designed for filter options that Privacy Browser does not use. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else { // Process third-party domain initial whitelist entries. - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - if (entry.contains("*")) { // Process a third-party domain initial whitelist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyDomainInitialWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + - // " - " + originalBlocklistEntry); - } else { // Process a third-party domain initial whitelist single entry. - // Create a domain entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the third party domain initial whitelist. - thirdPartyDomainInitialWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } - } else { // Third-party domain entries. - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // three is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - // Remove any trailing `*` from the entry. - if (entry.endsWith("*")) { - entry = entry.substring(0, entry.length - 1) - } - - if (entry.contains("*")) { // Process a third-party domain double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyDomainWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } else { // Process a third-party domain single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyDomainWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } - } else { // Process third-party whitelist entries. - // Parse the entry - val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - - if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // There are three or more entries. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - if (thirdEntry.contains("*")) { // There are four or more entries. - // Get the index of the wildcard. - val thirdWildcardIndex = thirdEntry.indexOf("*") - - // Split the entry into components. - val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) - val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) - - if (fourthEntry.contains("*")) { // Process a third-party whitelist quintuple entry. - // Get the index of the wildcard. - val fourthWildcardIndex = fourthEntry.indexOf("*") - - // Split the entry into components. - val realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex) - val fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1) - - // Create an entry string array. - val quintupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyWhitelist.add(quintupleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + - // realFourthEntry + " , " + fifthEntry + " - " + originalBlocklistEntry); - } else { // Process a third-party whitelist quadruple entry. - // Create an entry string array. - val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyWhitelist.add(quadrupleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + - // fourthEntry + " - " + originalBlocklistEntry); - } - } else { // Process a third-party whitelist triple entry. - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyWhitelist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + - // originalBlocklistEntry); - } - } else { // Process a third-party whitelist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyWhitelist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a third-party whitelist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyWhitelist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + entry + " - " + originalBlocklistEntry); - } - } - } else if (blocklistEntry.contains("domain=")) { // Process domain whitelist entries. - // Parse the entry - var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - if (entry.startsWith("|")) { // Initial domain whitelist entries. - // Strip the initial `|`. - entry = entry.substring(1) - - if (entry == "http://" || entry == "https://") { // Ignore generic entries. - // Do nothing. These entries are designed for filter options that Privacy Browser does not use. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else { // Initial domain whitelist entry. - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a domain initial triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainInitialWhitelist.add(domainTripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + - // thirdEntry + " - " + originalBlocklistEntry); - } else { // Process a domain initial double entry. - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainInitialWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } - } else { // Process a domain initial single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainInitialWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } - } else if (entry.endsWith("|")) { // Final domain whitelist entries. - // Strip the `|` from the end of the entry. - entry = entry.substring(0, entry.length - 1) - - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - if (entry.contains("*")) { // Process a domain final whitelist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainFinalWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain final whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } else { // Process a domain final whitelist single entry. - // create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainFinalWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain final whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } else { // Standard domain whitelist entries with filters. - if (domains.contains("~")) { // It is uncertain what a `~` domain means inside an `@@` entry. - // Do Nothing - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else { - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // There are three or more entries. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - if (thirdEntry.contains("*")) { // Process a domain whitelist quadruple entry. - // Get the index of the wildcard. - val thirdWildcardIndex = thirdEntry.indexOf("*") - - // Split the entry into components. - val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) - val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) - - // Create an entry string array. - val domainQuadrupleEntry = arrayOf(domain, firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainQuadrupleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + - // realThirdEntry + " , " + fourthEntry + " - " + originalBlocklistEntry); - } else { // Process a domain whitelist triple entry. - // Create an entry string array. - val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainTripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + - // thirdEntry + " - " + originalBlocklistEntry); - } - } else { // Process a domain whitelist double entry. - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } - } else { // Process a domain whitelist single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } - } - } // Ignore all other filter entries. - } else if (blocklistEntry.endsWith("|")) { // Final whitelist entries. - // Remove the final `|` from the entry. - val entry = blocklistEntry.substring(0, blocklistEntry.length - 1) - - if (entry.contains("*")) { // Process a final whitelist double entry - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - finalWhitelist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process a final whitelist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - finalWhitelist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final whitelist added: " + entry + " - " + originalBlocklistEntry); - } - } else { // Main whitelist entries. - if (blocklistEntry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = blocklistEntry.indexOf("*") - - // Split the entry into components. - val firstEntry = blocklistEntry.substring(0, wildcardIndex) - val secondEntry = blocklistEntry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a main whitelist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - mainWhitelist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); - } else { // Process a main whitelist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - mainWhitelist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a main whitelist single entry. - // Create an entry string array. - val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - mainWhitelist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + blocklistEntry + " - " + originalBlocklistEntry); - } - } - } else if (blocklistEntry.endsWith("|")) { // Final blacklist entries. - // Strip out the final "|" - var entry = blocklistEntry.substring(0, blocklistEntry.length - 1) - - // Strip out any initial `||`. They are redundant in this case because the blocklist entry is being matched against the end of the URL. - if (entry.startsWith("||")) { - entry = entry.substring(2) - } - - if (entry.contains("*")) { // Process a final blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process a final blacklist single entry. - // create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } else if (blocklistEntry.contains("$")) { // Entries with filter options. - // Strip out any initial `||`. These will be treated like any other entry. - if (blocklistEntry.startsWith("||")) { - blocklistEntry = blocklistEntry.substring(2) - } - - if (blocklistEntry.contains("third-party")) { // Third-party entries. - if (blocklistEntry.contains("~third-party")) { // Third-party filter whitelist entries. - // Do not process these whitelist entries. They are designed to combine with block filters that Privacy Browser doesn't use, like `subdocument` and `xmlhttprequest`. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else if (blocklistEntry.contains("domain=")) { // Third-party domain entries. - if (blocklistEntry.startsWith("|")) { // Third-party domain initial entries. - // Strip the initial `|`. - blocklistEntry = blocklistEntry.substring(1) - - // Parse the entry - val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - if (entry == "http:" || entry == "https:" || entry == "http://" || entry == "https://") { // Ignore generic entries. - // Do nothing. These entries will almost entirely disable the website. - // Often the original entry blocks filter options like `$script`, which Privacy Browser does not differentiate. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else { // Third-party domain initial entries. - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - if (entry.contains("*")) { // Three are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a third-party domain initial blacklist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val tripleDomainEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyDomainInitialBlacklist.add(tripleDomainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + - // " , " + thirdEntry + " - " + originalBlocklistEntry); - } else { // Process a third-party domain initial blacklist double entry. - // Create an entry string array. - val doubleDomainEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyDomainInitialBlacklist.add(doubleDomainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + - // " - " + originalBlocklistEntry); - } - } else { // Process a third-party domain initial blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyDomainInitialBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } - } else if (blocklistEntry.contains("\\")) { // Process a third-party domain blacklist regular expression. - // Parse the entry. At least one regular expression in this entry contains `$`, so the parser uses `/$`. - val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("/$") + 1) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("/$") + 2) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyDomainRegularExpressionBlacklist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain regular expression blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } while (domains.contains("|")) - } else { // Third-party domain entries. - // Parse the entry - var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - // Strip any trailing "*" from the entry. - if (entry.endsWith("*")) { - entry = entry.substring(0, entry.length - 1) - } - - // Track if any third-party whitelist filters are applied. - var whitelistDomain = false - - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // The is only one domain in the list. - domain = domains - } - - // Differentiate between blocklist domains and whitelist domains. - if (domain.startsWith("~")) { // Whitelist third-party domain entry. - // Strip the initial `~`. - domain = domain.substring(1) - - // Set the whitelist domain flag. - whitelistDomain = true - - if (entry.contains("*")) { // Process a third-party domain whitelist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyDomainWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } else { // Process a third-party domain whitelist single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - thirdPartyDomainWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } else { // Third-party domain blacklist entries. - if (entry.contains("*")) { // Process a third-party domain blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist - thirdPartyDomainBlacklist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } else { // Process a third-party domain blacklist single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyDomainBlacklist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party domain blocklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } - } while (domains.contains("|")) - - // Add a third-party blacklist entry if a whitelist domain was processed. - if (whitelistDomain) { - if (entry.contains("*")) { // Process a third-party blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process a third-party blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add an entry to the blacklist. - thirdPartyBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } - } - } else if (blocklistEntry.startsWith("|")) { // Third-party initial blacklist entries. - // Strip the initial `|`. - blocklistEntry = blocklistEntry.substring(1) - - // Get the entry. - val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - if (entry.contains("*")) { // Process a third-party initial blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val thirdPartyDoubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyInitialBlacklist.add(thirdPartyDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party initial blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process a third-party initial blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyInitialBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party initial blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } else if (blocklistEntry.contains("\\")) { // Process a regular expression blacklist entry. - // Prepare a string to hold the entry. - - // Get the entry. - val entry: String = if (blocklistEntry.contains("$/$")) { // The first `$` is part of the regular expression. - blocklistEntry.substring(0, blocklistEntry.indexOf("$/$") + 2) - } else { // The only `$` indicates the filter options. - blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - } - - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyRegularExpressionBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party regular expression blacklist added: " + entry + " - " + originalBlocklistEntry); - } else if (blocklistEntry.contains("*")) { // Third-party and regular expression blacklist entries. - // Get the entry. - var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - - if (entry.endsWith("*")) { // Process a third-party blacklist single entry. - // Strip the final `*`. - entry = entry.substring(0, entry.length - 1) - - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third party blacklist added: " + entry + " - " + originalBlocklistEntry); - } else { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // There are three or more entries. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - if (thirdEntry.contains("*")) { // Process a third-party blacklist quadruple entry. - // Get the index of the wildcard. - val thirdWildcardIndex = thirdEntry.indexOf("*") - - // Split the entry into components. - val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) - val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) - - // Create an entry string array. - val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyBlacklist.add(quadrupleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + - // fourthEntry + " - " + originalBlocklistEntry); - } else { // Process a third-party blacklist triple entry. - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyBlacklist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + - // originalBlocklistEntry); - } - } else { // Process a third-party blacklist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } - } else { // Process a third party blacklist single entry. - // Get the entry. - val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - thirdPartyBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " third party blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } else if (blocklistEntry.substring(blocklistEntry.indexOf("$")).contains("domain=")) { // Domain entries. - if (blocklistEntry.contains("~")) { // Domain whitelist entries. - // Separate the filters. - var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - // Strip any final `*` from the entry. They are redundant. - if (entry.endsWith("*")) { - entry = entry.substring(0, entry.length - 1) - } - - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - // Strip the initial `~`. - domain = domain.substring(1) - if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a domain whitelist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainTripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + - // " - " + originalBlocklistEntry); - } else { // Process a domain whitelist double entry. - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a domain whitelist single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the whitelist. - domainWhitelist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } else { // Domain blacklist entries. - // Separate the filters. - val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) - var domains = filters.substring(filters.indexOf("domain=") + 7) - - // Only process the item if the entry is not null. For example, some lines begin with `$websocket`, which create a null entry. - if (entry != "") { - // Process each domain. - do { - // Create a string to keep track of the current domain. - var domain: String - - if (domains.contains("|")) { // There is more than one domain in the list. - // Get the first domain from the list. - domain = domains.substring(0, domains.indexOf("|")) - - // Remove the first domain from the list. - domains = domains.substring(domains.indexOf("|") + 1) - } else { // There is only one domain in the list. - domain = domains - } - - if (entry.startsWith("|")) { // Domain initial blacklist entries. - // Remove the initial `|`; - val entryBase = entry.substring(1) - - if (entryBase == "http://" || entryBase == "https://") { - // Do nothing. These entries will entirely block the website. - // Often the original entry blocks `$script` but Privacy Browser does not currently differentiate between scripts and other entries. - - //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); - } else { // Process a domain initial blacklist entry - // Create an entry string array. - val domainEntry = arrayOf(domain, entryBase, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainInitialBlacklist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain initial blacklist added: " + domain + " , " + entryBase + " - " + originalBlocklistEntry); - } - } else if (entry.endsWith("|")) { // Domain final blacklist entries. - // Remove the final `|`. - val entryBase = entry.substring(0, entry.length - 1) - - if (entryBase.contains("*")) { // Process a domain final blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entryBase.substring(0, wildcardIndex) - val secondEntry = entryBase.substring(wildcardIndex + 1) - - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainFinalBlacklist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain final blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } else { // Process a domain final blacklist single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entryBase, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainFinalBlacklist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain final blacklist added: " + domain + " , " + entryBase + " - " + originalBlocklistEntry); - } - } else if (entry.contains("\\")) { // Process a domain regular expression blacklist entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainRegularExpressionBlacklist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain regular expression blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } else if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a domain blacklist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainBlacklist.add(domainTripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + - // " - " + originalBlocklistEntry); - } else { // Process a domain blacklist double entry. - // Create an entry string array. - val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainBlacklist.add(domainDoubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + - // originalBlocklistEntry); - } - } else { // Process a domain blacklist single entry. - // Create an entry string array. - val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - domainBlacklist.add(domainEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); - } - } while (domains.contains("|")) - } - } - } else if (blocklistEntry.contains("~")) { // Whitelist entries. Privacy Browser does not differentiate against these filter options, so they are just generally whitelisted. - // Remove the filter options. - blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - - // Strip any trailing `*`. - if (blocklistEntry.endsWith("*")) { - blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1) - } - - if (blocklistEntry.contains("*")) { // Process a whitelist double entry. - // Get the index of the wildcard. - val wildcardIndex = blocklistEntry.indexOf("*") - - // Split the entry into components. - val firstEntry = blocklistEntry.substring(0, wildcardIndex) - val secondEntry = blocklistEntry.substring(wildcardIndex + 1) - - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - mainWhitelist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process a whitelist single entry. - // Create an entry string array. - val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) - - // Add the entry to the whitelist. - mainWhitelist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + blocklistEntry + " - + " + originalBlocklistEntry); - } - } else if (blocklistEntry.contains("\\")) { // Process a regular expression blacklist entry. - // Remove the filter options. - blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - - // Create an entry string array. - val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - regularExpressionBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " regular expression blacklist added: " + blocklistEntry + " - " + originalBlocklistEntry); - } else { // Blacklist entries. - // Remove the filter options. - if (!blocklistEntry.contains("\$file")) { // EasyPrivacy contains an entry with `$file` that does not have filter options. - blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) - } - - // Strip any trailing `*`. These are redundant. - if (blocklistEntry.endsWith("*")) { - blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1) - } - - if (blocklistEntry.startsWith("|")) { // Initial blacklist entries. - // Strip the initial `|`. - val entry = blocklistEntry.substring(1) - - if (entry.contains("*")) { // Process an initial blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - initialBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process an initial blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - initialBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } else if (blocklistEntry.endsWith("|")) { // Final blacklist entries. - // Ignore entries with `object` filters. They can block entire websites and don't have any meaning in the context of Privacy Browser. - if (!originalBlocklistEntry.contains("\$object")) { - // Strip the final `|`. - val entry = blocklistEntry.substring(0, blocklistEntry.length - 1) - - if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a final blacklist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + - // originalBlocklistEntry); - } else { // Process a final blacklist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a final blacklist single entry. - // Create an entry sting array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } - } else if (blocklistEntry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = blocklistEntry.indexOf("*") - - // Split the entry into components. - val firstEntry = blocklistEntry.substring(0, wildcardIndex) - val secondEntry = blocklistEntry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a main blacklist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); - } else { // Process a main blacklist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a main blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + blocklistEntry + " - " + originalBlocklistEntry); - } - } - } else { // Main blacklist entries - // Strip out any initial `||`. These will be treated like any other entry. - if (blocklistEntry.startsWith("||")) { - blocklistEntry = blocklistEntry.substring(2) - } - - // Strip out any initial `*`. - if (blocklistEntry.startsWith("*")) { - blocklistEntry = blocklistEntry.substring(1) - } - - // Strip out any trailing `*`. - if (blocklistEntry.endsWith("*")) { - blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1) - } - - if (blocklistEntry.startsWith("|")) { // Initial blacklist entries. - // Strip the initial `|`. - val entry = blocklistEntry.substring(1) - - if (entry.contains("*")) { // Process an initial blacklist double entry. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - initialBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } else { // Process an initial blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - initialBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } else if (blocklistEntry.endsWith("|")) { // Final blacklist entries. - // Strip the final `|`. - val entry = blocklistEntry.substring(0, blocklistEntry.length - 1) - - if (entry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = entry.indexOf("*") - - // Split the entry into components. - val firstEntry = entry.substring(0, wildcardIndex) - val secondEntry = entry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // Process a final blacklist triple entry. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); - } else { // Process a final blacklist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a final blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(entry, originalBlocklistEntry) - - // Add the entry to the blacklist. - finalBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + " - " + originalBlocklistEntry); - } - } else { // Main blacklist entries. - if (blocklistEntry.contains("*")) { // There are two or more entries. - // Get the index of the wildcard. - val wildcardIndex = blocklistEntry.indexOf("*") - - // Split the entry into components. - val firstEntry = blocklistEntry.substring(0, wildcardIndex) - val secondEntry = blocklistEntry.substring(wildcardIndex + 1) - - if (secondEntry.contains("*")) { // There are three or more entries. - // Get the index of the wildcard. - val secondWildcardIndex = secondEntry.indexOf("*") - - // Split the entry into components. - val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) - val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) - - if (thirdEntry.contains("*")) { // There are four or more entries. - // Get the index of the wildcard. - val thirdWildcardIndex = thirdEntry.indexOf("*") - - // Split the entry into components. - val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) - val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) - - if (fourthEntry.contains("*")) { // Process a main blacklist quintuple entry. - // Get the index of the wildcard. - val fourthWildcardIndex = fourthEntry.indexOf("*") - - // Split the entry into components. - val realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex) - val fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1) - - // Create an entry string array. - val quintupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(quintupleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + realFourthEntry + " , " + - // fifthEntry + " - " + originalBlocklistEntry); - } else { // Process a main blacklist quadruple entry. - // Create an entry string array. - val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(quadrupleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + fourthEntry + " - " + - // originalBlocklistEntry); - } - } else { // Process a main blacklist triple entry. - // Create an entry string array. - val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(tripleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); - } - } else { // Process a main blacklist double entry. - // Create an entry string array. - val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(doubleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); - } - } else { // Process a main blacklist single entry. - // Create an entry string array. - val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) - - // Add the entry to the blacklist. - mainBlacklist.add(singleEntry) - - //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + blocklistEntry + " - " + originalBlocklistEntry); - } - } - } - } - // Close `bufferedReader`. - bufferedReader.close() - } catch (e: IOException) { - // The asset exists, so the `IOException` will never be thrown. - } - - // Initialize the combined list. - val combinedLists = ArrayList>>() - - // Add the headers (0). - combinedLists.add(headers) // 0. - - // Add the whitelists (1-8). - combinedLists.add(mainWhitelist) // 1. - combinedLists.add(finalWhitelist) // 2. - combinedLists.add(domainWhitelist) // 3. - combinedLists.add(domainInitialWhitelist) // 4. - combinedLists.add(domainFinalWhitelist) // 5. - combinedLists.add(thirdPartyWhitelist) // 6. - combinedLists.add(thirdPartyDomainWhitelist) // 7. - combinedLists.add(thirdPartyDomainInitialWhitelist) // 8. - - // Add the blacklists (9-22). - combinedLists.add(mainBlacklist) // 9. - combinedLists.add(initialBlacklist) // 10. - combinedLists.add(finalBlacklist) // 11. - combinedLists.add(domainBlacklist) // 12. - combinedLists.add(domainInitialBlacklist) // 13. - combinedLists.add(domainFinalBlacklist) // 14. - combinedLists.add(domainRegularExpressionBlacklist) // 15. - combinedLists.add(thirdPartyBlacklist) // 16. - combinedLists.add(thirdPartyInitialBlacklist) // 17. - combinedLists.add(thirdPartyDomainBlacklist) // 18. - combinedLists.add(thirdPartyDomainInitialBlacklist) // 19. - combinedLists.add(thirdPartyRegularExpressionBlacklist) // 20. - combinedLists.add(thirdPartyDomainRegularExpressionBlacklist) // 21. - combinedLists.add(regularExpressionBlacklist) // 22. - - // Return the combined lists. - return combinedLists - } - - fun checkBlocklist(currentDomain: String?, resourceUrl: String, isThirdPartyRequest: Boolean, blocklist: ArrayList>>): Array { - // Get the blocklist name. - val blocklistName = blocklist[0][1][0] - - // Process the whitelists. - // Main whitelist. - for (whitelistEntry in blocklist[MAIN_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.contains(whitelistEntry[0])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, whitelistEntry[0], whitelistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2] - ) - } - - // There are three entries. - 4 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - } - } - - // Final whitelist. - for (whitelistEntry in blocklist[FINAL_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.contains(whitelistEntry[0])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, FINAL_WHITELIST, whitelistEntry[0], whitelistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) - } - } - } - - // Only check the domain lists if the current domain is not null (like `about:blank`). - if (currentDomain != null) { - // Domain whitelist. - for (whitelistEntry in blocklist[DOMAIN_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - - // There are three entries. - 5 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", whitelistEntry[4]) - } - - // There are four entries. - 6 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) && - resourceUrl.contains(whitelistEntry[4])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, - "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}\n${whitelistEntry[4]}", whitelistEntry[5]) - } - } - } - - // Domain initial whitelist. - for (whitelistEntry in blocklist[DOMAIN_INITIAL_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}".trimIndent(), whitelistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - - // There are three entries. - 5 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.startsWith(whitelistEntry[3])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", - whitelistEntry[4]) - } - } - } - - // Domain final whitelist. - for (whitelistEntry in blocklist[DOMAIN_FINAL_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.endsWith(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.endsWith(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - } - } - } - - // Only check the third-party whitelists if this is a third-party request. - if (isThirdPartyRequest) { - // Third-party whitelist. - for (whitelistEntry in blocklist[THIRD_PARTY_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.contains(whitelistEntry[0])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, whitelistEntry[0], whitelistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) - } - - // There are three entries. - 4 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - - // There are four entries. - 5 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", - whitelistEntry[4]) - } - - // There are five entries. - 6 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) && - resourceUrl.contains(whitelistEntry[4])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, - "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}\n${whitelistEntry[4]}", whitelistEntry[5]) - } - } - } - - // Third-party domain whitelist. - for (whitelistEntry in blocklist[THIRD_PARTY_DOMAIN_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 3 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n", whitelistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - } - } - - // Third-party domain initial whitelist. - for (whitelistEntry in blocklist[THIRD_PARTY_DOMAIN_INITIAL_WHITELIST.toInt()]) { - when (whitelistEntry.size) { - // There is one entry. - 3 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n", whitelistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { - // Return a whitelist match request allowed. - return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) - } - } - } - } - - // Process the blacklists. - // Main blacklist. - for (blacklistEntry in blocklist[MAIN_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.contains(blacklistEntry[0])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - - // There are three entries. - 4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - - // There are four entries. - 5 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) - } - - // There are five entries. - 6 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3]) && - resourceUrl.contains(blacklistEntry[4])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}\n${blacklistEntry[4]}", - blacklistEntry[5]) - } - } - } - - // Initial blacklist. - for (blacklistEntry in blocklist[INITIAL_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.startsWith(blacklistEntry[0])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - - // There are two entries - 3 -> if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - } - } - - // Final blacklist. - for (blacklistEntry in blocklist[FINAL_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.endsWith(blacklistEntry[0])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - - // There are three entries. - 4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - } - } - - // Only check the domain lists if the current domain is not null (like `about:blank`). - if (currentDomain != null) { - // Domain blacklist. - for (blacklistEntry in blocklist[DOMAIN_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 3 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - - // There are three entries. - 5 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) - } - } - } - - // Domain initial blacklist. - for (blacklistEntry in blocklist[DOMAIN_INITIAL_BLACKLIST.toInt()]) { - // Store the entry in the resource request log. - if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - } - - // Domain final blacklist. - for (blacklistEntry in blocklist[DOMAIN_FINAL_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 3 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - } - } - - // Domain regular expression blacklist. - for (blacklistEntry in blocklist[DOMAIN_REGULAR_EXPRESSION_BLACKLIST.toInt()]) { - if (currentDomain.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_REGULAR_EXPRESSION_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - } - } - - // Only check the third-party blacklists if this is a third-party request. - if (isThirdPartyRequest) { - // Third-party blacklist. - for (blacklistEntry in blocklist[THIRD_PARTY_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.contains(blacklistEntry[0])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf( - REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n", blacklistEntry[2]) - } - - // There are three entries. - 4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - - // There are four entries. - 5 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", - blacklistEntry[4]) - } - } - } - - // Third-party initial blacklist. - for (blacklistEntry in blocklist[THIRD_PARTY_INITIAL_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 2 -> if (resourceUrl.startsWith(blacklistEntry[0])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - - // There are two entries. - 3 -> if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - } - } - - // Third-party domain blacklist. - for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 3 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - } - } - - // Third-party domain initial blacklist. - for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST.toInt()]) { - when (blacklistEntry.size) { - // There is one entry. - 3 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n", blacklistEntry[2]) - } - - // There are two entries. - 4 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) - } - - // There are three entries. - 5 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, - "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) - } - } - } - - // Third-party regular expression blacklist. - for (blacklistEntry in blocklist[THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST.toInt()]) { - if (Pattern.matches(blacklistEntry[0], resourceUrl)) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - } - - // Third-party domain regular expression blacklist. - for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST.toInt()]) { - if (currentDomain!!.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) - } - } - } - - // Regular expression blacklist. - for (blacklistEntry in blocklist[REGULAR_EXPRESSION_BLACKLIST.toInt()]) { - if (Pattern.matches(blacklistEntry[0], resourceUrl)) { - // Return a blacklist match request blocked. - return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) - } - } - - // Return a no match request default. - return arrayOf(REQUEST_DEFAULT) - } -}