Issue 4813 - UTFDataFormatException while serializing filter

src/org/adblockplus/sbrowser/contentblocker/engine/Subscription.java

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 10 matching lines @@
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.StringReader;
 import java.net.URL;
-import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
 
+import android.text.TextUtils;
 import android.util.Log;
 
 /**
  * Simple subscription representation.
  */
 final class Subscription
 {
   private static final String TAG = Subscription.class.getSimpleName();
   public static final String KEY_TITLE = "title";
   public static final String KEY_VERSION = "version";
@@ skipping 21 matching lines @@
    * subscription.
    */
   private static final String[] ALLOWED_META_KEYS_ARRAY =
   {
       "checksum", KEY_VERSION, KEY_TITLE, "last modified", "expires", "homepage", "licence"
   };
 
   private final URL url;
   private final Type type;
   private final HashMap<String, String> meta = new HashMap<String, String>();
-  private HashSet<String> filters = null;
+  private final HashSet<String> filters = new HashSet<String>();
 
   private boolean metaDataValid = true;
   private boolean filtersValid = true;
 
   static
   {
     for (final String s : ALLOWED_META_KEYS_ARRAY)
     {
       ALLOWED_META_KEYS.add(s);
     }
@@ skipping 216 matching lines @@
   public boolean isEnabled()
   {
     return "true".equals(this.getMeta(KEY_ENABLED));
   }
 
   public void setEnabled(boolean enable)
   {
     this.putMeta(KEY_ENABLED, Boolean.toString(enable));
   }
 
-  public void getFilters(Collection<String> filters)
-  {
-    if (this.filters != null)
+  public void copyFilters(Collection<String> filters)
+  {
+    if (filters != null)
     {
       filters.addAll(this.filters);
     }
   }
 
   public void clearFilters()
   {
-    this.filters = null;
+    this.filters.clear();
   }
 
   /**
    * @return an internal management ID
    */
   public String getId()
   {
     return getId(this);
   }
 
@@ skipping 38 matching lines @@
   }
 
   private static String createFilterHash(List<String> filters) throws IOException
   {
     try
     {
       final MessageDigest md5 = MessageDigest.getInstance("MD5");
       Collections.sort(filters);
       for (final String filter : filters)
       {
-        md5.update(filter.getBytes("UTF-8"));
+        md5.update(filter.getBytes(Engine.CHARSET_UTF_8));
       }
       return byteArrayToHexString(md5.digest());
     }
     catch (final NoSuchAlgorithmException e)
     {
       throw new IOException("MD5 is unavailable: " + e.getMessage(), e);
     }
   }
 
   public void serializeMetaData(final File metaFile) throws IOException
@@ skipping 16 matching lines @@
       metaOut.close();
     }
   }
 
   public void serializeFilters(final File filtersFile) throws IOException
   {
     final DataOutputStream filtersOut = new DataOutputStream(new GZIPOutputStream(
         new BufferedOutputStream(new FileOutputStream(filtersFile))));
     try
     {
-      if (this.filters == null)
-      {
-        filtersOut.writeInt(0);
-      }
-      else
-      {
-        filtersOut.writeInt(this.filters.size());
-        filtersOut.writeUTF(createFilterHash(new ArrayList<String>(this.filters)));
-        for (final String s : this.filters)
-        {
-          final byte[] b = s.getBytes(StandardCharsets.UTF_8);

[anton, 2017/01/23 06:49:40]

StandardCharsets is available starting Java 7. If it's not a problem and
somewhere in README it's noted that JDK 7 is required then we can use it. For
JDK 6 we can use `Charset.forName("UTF-8")` instead

[diegocarloslima, 2017/01/30 17:14:30]

For instance, I'll use Charset.forName("UTF-8"). Then, I'll create a follow up
issue to add Java 7 features which I'll change this back to
StandardCharsets.UTF_8

-          filtersOut.writeInt(b.length);
-          filtersOut.write(b);
-        }
+      filtersOut.writeInt(this.filters.size());
+      filtersOut.writeUTF(createFilterHash(new ArrayList<String>(this.filters)));
+      for (final String s : this.filters)
+      {
+        final byte[] b = s.getBytes(Engine.CHARSET_UTF_8);
+        filtersOut.writeInt(b.length);
+        filtersOut.write(b);
       }
     }
     finally
     {
       filtersOut.close();
     }
   }
 
   public void serializeSubscription(final File metaFile, final File filtersFile) throws IOException
   {
     this.serializeMetaData(metaFile);
     this.serializeFilters(filtersFile);
   }
 
-  public static Subscription deserializeSubscription(final File metaFile) throws IOException
-  {
-    final DataInputStream in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
-        new FileInputStream(metaFile))));
-    try
-    {
+  public static Subscription deserializeSubscription(final File metaFile)
+  {
+    Subscription sub = null;
+    DataInputStream in = null;
+    try
+    {
+      in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
+          new FileInputStream(metaFile))));
       final String urlString = in.readUTF();
-      final Subscription sub = new Subscription(urlString.length() > 0 ? new URL(urlString) : null);
+      sub = new Subscription(!TextUtils.isEmpty(urlString) ? new URL(urlString) : null);
+      sub.metaDataValid = false;
       final int numMetaEntries = in.readInt();
       for (int i = 0; i < numMetaEntries; i++)
       {
         final String key = in.readUTF();
         final String value = in.readUTF();
         sub.meta.put(key, value);
       }
       sub.metaDataValid = createMetaDataHash(sub.meta).equals(sub.getMeta(KEY_META_HASH));
-      return sub;
+    }
+    catch (Throwable t)
+    {
+      // We catch Throwable here in order to return whatever we could retrieve from the meta file
     }
     finally
     {
-      in.close();
-    }
-  }
-
-  public void deserializeFilters(final File filtersFile) throws IOException
-  {
-    final DataInputStream in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
-        new FileInputStream(filtersFile))));
-    try
-    {
+      if (in != null)
+      {
+        try
+        {
+          in.close();
+        }
+        catch (IOException e)
+        {
+          // Ignored
+        }
+      }
+    }
+    return sub;
+  }
+
+  public void deserializeFilters(final File filtersFile)
+  {
+    this.clearFilters();
+    this.filtersValid = false;
+    DataInputStream in = null;
+    try
+    {
+      in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
+          new FileInputStream(filtersFile))));
       final int numFilters = in.readInt();
-      if (numFilters == 0)
-      {
-        this.filters = null;
-      }
-      else
-      {
-        this.filters = new HashSet<String>();
-        final String filtersHash = in.readUTF();
-        for (int i = 0; i < numFilters; i++)
+      final String filtersHash = in.readUTF();
+      for (int i = 0; i < numFilters; i++)
+      {
+        final int length = in.readInt();
+        final byte[] b = new byte[length];
+        in.readFully(b);
+        this.filters.add(new String(b, Engine.CHARSET_UTF_8));
+      }
+      this.filtersValid = createFilterHash(new ArrayList<String>(this.filters)).equals(
+          filtersHash);
+      Log.d(TAG, "Filters valid: " + this.filtersValid);
+    }
+    catch (Throwable t)
+    {
+      // We catch Throwable here in order to load whatever we could retrieve from the filters file
+    }
+    finally
+    {
+      if (in != null)
+      {
+        try
         {
-          final int length = in.readInt();
-          final byte[] b = new byte[length];
-          in.readFully(b);
-          this.filters.add(new String(b, StandardCharsets.UTF_8));
+          in.close();
         }
-        this.filtersValid = createFilterHash(new ArrayList<String>(this.filters)).equals(
-            filtersHash);
-        Log.d(TAG, "Filters valid: " + this.filtersValid);
-      }
-    }
-    finally
-    {
-      in.close();
+        catch (IOException e)
+        {
+          // Ignored
+        }
+      }
     }
   }
 
   /**
    * Adds the given string, which should be a single filter to this
    * subscription.
    *
    * @param input
    */
   public Subscription parseLine(String input)
   {
-    if (this.filters == null)
-    {
-      this.filters = new HashSet<String>();
-    }
-
     final String line = input.trim();
     if (!line.isEmpty())
     {
       if (line.startsWith("!"))
       {
         // Meta data
         final int colon = line.indexOf(':');
         if (colon > 2)
         {
           final String key = line.substring(1, colon).trim().toLowerCase(LOCALE_EN);
@@ skipping 82 matching lines @@
           if (lastModified != null)
           {
             this.meta.put(KEY_HTTP_LAST_MODIFIED, lastModified);
           }
           else
           {
             this.meta.remove(KEY_HTTP_LAST_MODIFIED);
           }
           this.meta.put(KEY_DOWNLOAD_COUNT, Long.toString(this.getDownloadCount() + 1));
 
-          this.filters = new HashSet<String>();
+          this.clearFilters();
           this.parseText(text);
         }
       }
     }
 
     this.serializeMetaData(metaFile);
     if (filtersChanged)
     {
       this.serializeFilters(filtersFile);
       this.clearFilters();
     }
 
     return filtersChanged;
   }
 }