refactor keyserver class structure, use AutoValue for ParcelableHkpKeyserver

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/CloudSearch.java

@@ -37,20 +37,20 @@ public class CloudSearch {
 
     public static ArrayList<ImportKeysListEntry> search(
             @NonNull final String query, Preferences.CloudSearchPrefs cloudPrefs, @NonNull final ParcelableProxy proxy)
-            throws Keyserver.CloudSearchFailureException {
+            throws KeyserverClient.CloudSearchFailureException {
 
-        final ArrayList<Keyserver> servers = new ArrayList<>();
+        final ArrayList<KeyserverClient> servers = new ArrayList<>();
         // it's a Vector for sync, multiple threads might report problems
-        final Vector<Keyserver.CloudSearchFailureException> problems = new Vector<>();
+        final Vector<KeyserverClient.CloudSearchFailureException> problems = new Vector<>();
 
         if (cloudPrefs.searchKeyserver) {
-            servers.add(cloudPrefs.keyserver);
+            servers.add(HkpKeyserverClient.fromHkpKeyserverAddress(cloudPrefs.keyserver));
         }
         if (cloudPrefs.searchKeybase) {
-            servers.add(KeybaseKeyserver.getInstance());
+            servers.add(KeybaseKeyserverClient.getInstance());
         }
         if (cloudPrefs.searchFacebook) {
-            servers.add(FacebookKeyserver.getInstance());
+            servers.add(FacebookKeyserverClient.getInstance());
         }
 
         int numberOfServers = servers.size();
@@ -58,13 +58,13 @@ public class CloudSearch {
 
         if (numberOfServers > 0) {
             ArrayList<Thread> searchThreads = new ArrayList<>();
-            for (final Keyserver keyserver : servers) {
+            for (final KeyserverClient keyserverClient : servers) {
                 Runnable r = new Runnable() {
                     @Override
                     public void run() {
                         try {
-                            results.addAll(keyserver.search(query, proxy));
+                            results.addAll(keyserverClient.search(query, proxy));
-                        } catch (Keyserver.CloudSearchFailureException e) {
+                        } catch (KeyserverClient.CloudSearchFailureException e) {
                             problems.add(e);
                         }
                         results.finishedAdding(); // notifies if all searchers done
@@ -90,14 +90,14 @@ public class CloudSearch {
             if (results.outstandingSuppliers() > 0) {
                 String message = "Launched " + servers.size() + " cloud searchers, but " +
                         results.outstandingSuppliers() + "failed to complete.";
-                problems.add(new Keyserver.QueryFailedException(message));
+                problems.add(new KeyserverClient.QueryFailedException(message));
             }
         } else {
-            problems.add(new Keyserver.QueryNoEnabledSourceException());
+            problems.add(new KeyserverClient.QueryNoEnabledSourceException());
         }
 
         if (!problems.isEmpty()) {
-            for (Keyserver.CloudSearchFailureException e : problems) {
+            for (KeyserverClient.CloudSearchFailureException e : problems) {
                 Log.d(Constants.TAG, "Cloud search exception: " + e.getLocalizedMessage());
             }
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/FacebookKeyserverClient.java

@@ -44,18 +44,18 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ParcelableProxy;
 
-public class FacebookKeyserver extends Keyserver {
+public class FacebookKeyserverClient implements KeyserverClient {
     private static final String FB_KEY_URL_FORMAT
             = "https://www.facebook.com/%s/publickey/download";
     private static final String FB_HOST = "facebook.com";
     private static final String FB_HOST_WWW = "www." + FB_HOST;
 
 
-    public static FacebookKeyserver getInstance() {
+    public static FacebookKeyserverClient getInstance() {
-        return new FacebookKeyserver();
+        return new FacebookKeyserverClient();
     }
 
-    private FacebookKeyserver() { }
+    private FacebookKeyserverClient() { }
 
 
     @Override

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyserverAddress.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2016-2017 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2017 Vincent Breitmoser <look@my.amazin.horse>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.keyimport;
+
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import android.os.Parcelable;
+import android.support.annotation.NonNull;
+
+import com.google.auto.value.AutoValue;
+
+@AutoValue
+public abstract class HkpKeyserverAddress implements Parcelable {
+    private static final short PORT_DEFAULT = 11371;
+    private static final short PORT_DEFAULT_HKPS = 443;
+
+    public abstract String getUrl();
+    public abstract String getOnion();
+
+
+    public static HkpKeyserverAddress createWithOnionProxy(@NonNull String url, String onion) {
+        return new AutoValue_HkpKeyserverAddress(url, onion == null ? null : onion.trim());
+    }
+
+    public static HkpKeyserverAddress createFromUri(@NonNull String url) {
+        return new AutoValue_HkpKeyserverAddress(url, null);
+    }
+
+
+    public URI getUrlURI() throws URISyntaxException {
+        return getURI(getUrl());
+    }
+
+    public URI getOnionURI() throws URISyntaxException {
+        return getOnion() != null ? getURI(getOnion()) : null;
+    }
+
+    /**
+     * @param keyserverUrl "<code>hostname</code>" (eg. "<code>pool.sks-keyservers.net</code>"), then it will
+     *                     connect using {@link #PORT_DEFAULT}. However, port may be specified after colon
+     *                     ("<code>hostname:port</code>", eg. "<code>p80.pool.sks-keyservers.net:80</code>").
+     */
+    private URI getURI(String keyserverUrl) throws URISyntaxException {
+        URI originalURI = new URI(keyserverUrl);
+
+        String scheme = originalURI.getScheme();
+        if (scheme == null) {
+            throw new URISyntaxException("", "scheme null!");
+        }
+        if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)
+                && !"hkp".equalsIgnoreCase(scheme) && !"hkps".equalsIgnoreCase(scheme)) {
+            throw new URISyntaxException(scheme, "unsupported scheme!");
+        }
+
+        int port = originalURI.getPort();
+
+        if ("hkps".equalsIgnoreCase(scheme)) {
+            scheme = "https";
+            port = port == -1 ? PORT_DEFAULT_HKPS : port;
+        } else if ("hkp".equalsIgnoreCase(scheme)) {
+            scheme = "http";
+            port = port == -1 ? PORT_DEFAULT : port;
+        }
+
+        return new URI(scheme, originalURI.getUserInfo(), originalURI.getHost(), port,
+                originalURI.getPath(), originalURI.getQuery(), originalURI.getFragment());
+    }
+
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyserverClient.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2016-2017 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2017 Vincent Breitmoser <look@my.amazin.horse>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,22 +28,14 @@ import java.net.URLDecoder;
 import java.nio.charset.Charset;
 import java.nio.charset.UnsupportedCharsetException;
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
 import java.util.GregorianCalendar;
 import java.util.Locale;
 import java.util.TimeZone;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import android.os.Parcel;
-import android.os.Parcelable;
 import android.support.annotation.NonNull;
 
-import de.measite.minidns.Client;
-import de.measite.minidns.Question;
-import de.measite.minidns.Record;
-import de.measite.minidns.record.SRV;
 import okhttp3.FormBody;
 import okhttp3.HttpUrl;
 import okhttp3.OkHttpClient;
@@ -56,8 +49,8 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ParcelableProxy;
 
-public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
 
+public class HkpKeyserverClient implements KeyserverClient {
     /**
      * pub:%keyid%:%algo%:%keylen%:%creationdate%:%expirationdate%:%flags%
      * <ul>
@@ -123,132 +116,28 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
             .compile("uid:([^:]*):([0-9]+):([0-9]*):([rde]*)",
                     Pattern.CASE_INSENSITIVE);
 
-    private static final short PORT_DEFAULT = 11371;
-    private static final short PORT_DEFAULT_HKPS = 443;
     private static final Charset UTF_8 = Charset.forName("utf-8");
 
-    private String mUrl;
-    private String mOnion;
 
-    public ParcelableHkpKeyserver(@NonNull String url, String onion) {
+    private HkpKeyserverAddress hkpKeyserver;
-        mUrl = url.trim();
+
-        mOnion = onion == null ? null : onion.trim();
+
+    public static HkpKeyserverClient fromHkpKeyserverAddress(HkpKeyserverAddress hkpKeyserver) {
+        return new HkpKeyserverClient(hkpKeyserver);
     }
 
-    public ParcelableHkpKeyserver(@NonNull String url) {
+
-        this(url, null);
+    private HkpKeyserverClient(HkpKeyserverAddress hkpKeyserver) {
+        this.hkpKeyserver = hkpKeyserver;
     }
 
-    public String getUrl() {
-        return mUrl;
-    }
-
-    public String getOnion() {
-        return mOnion;
-    }
-
-    public URI getUrlURI() throws URISyntaxException {
-        return getURI(mUrl);
-    }
-
-    public URI getOnionURI() throws URISyntaxException {
-        return mOnion != null ? getURI(mOnion) : null;
-    }
-
-    /**
-     * @param keyserverUrl "<code>hostname</code>" (eg. "<code>pool.sks-keyservers.net</code>"), then it will
-     *                     connect using {@link #PORT_DEFAULT}. However, port may be specified after colon
-     *                     ("<code>hostname:port</code>", eg. "<code>p80.pool.sks-keyservers.net:80</code>").
-     */
-    private URI getURI(String keyserverUrl) throws URISyntaxException {
-        URI originalURI = new URI(keyserverUrl);
-
-        String scheme = originalURI.getScheme();
-        if (scheme == null) {
-            throw new URISyntaxException("", "scheme null!");
-        }
-        if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)
-                && !"hkp".equalsIgnoreCase(scheme) && !"hkps".equalsIgnoreCase(scheme)) {
-            throw new URISyntaxException(scheme, "unsupported scheme!");
-        }
-
-        int port = originalURI.getPort();
-
-        if ("hkps".equalsIgnoreCase(scheme)) {
-            scheme = "https";
-            port = port == -1 ? PORT_DEFAULT_HKPS : port;
-        } else if ("hkp".equalsIgnoreCase(scheme)) {
-            scheme = "http";
-            port = port == -1 ? PORT_DEFAULT : port;
-        }
-
-        return new URI(scheme, originalURI.getUserInfo(), originalURI.getHost(), port,
-                originalURI.getPath(), originalURI.getQuery(), originalURI.getFragment());
-    }
-
-    private HttpUrl getHttpUrl(ParcelableProxy proxy) throws URISyntaxException {
-        URI base = getUrlURI();
-        if (proxy.isTorEnabled() && getOnionURI() != null) {
-            base = getOnionURI();
-        }
-
-        return HttpUrl.get(base).newBuilder()
-                .addPathSegment("pks")
-                .build();
-    }
-
-    private String query(HttpUrl url, @NonNull ParcelableProxy proxy) throws Keyserver.QueryFailedException, HttpError {
-        try {
-            OkHttpClient client = OkHttpClientFactory.getClientPinnedIfAvailable(url.url(), proxy.getProxy());
-
-            Request request = new Request.Builder()
-                    .url(url)
-                    .build();
-
-            Response response = client
-                    .newCall(request)
-                    .execute();
-
-            // contains body both in case of success or failure
-            String responseBody = getResponseBodyAsUtf8(response);
-
-            if (response.isSuccessful()) {
-                return responseBody;
-            } else {
-                throw new HttpError(response.code(), responseBody);
-            }
-        } catch (IOException e) {
-            Log.e(Constants.TAG, "IOException at HkpKeyserver", e);
-            String proxyInfo = proxy.getProxy() == Proxy.NO_PROXY ? "" : " Using proxy " + proxy.getProxy();
-            String causeName = e.getCause().getClass().getSimpleName();
-            throw new Keyserver.QueryFailedException(String.format(
-                    "Network error (%s) for '%s'. Check your Internet connection! %s",
-                    causeName, mUrl, proxyInfo));
-        }
-    }
-
-    private String getResponseBodyAsUtf8(Response response) throws IOException {
-        String responseBody;
-        byte[] responseBytes = response.body().bytes();
-        try {
-            responseBody = new String(responseBytes, response.body().contentType().charset(UTF_8));
-        } catch (UnsupportedCharsetException e) {
-            responseBody = new String(responseBytes, UTF_8);
-        }
-
-        return responseBody;
-    }
-
-    /**
-     * Results are sorted by creation date of key!
-     */
     @Override
     public ArrayList<ImportKeysListEntry> search(String query, ParcelableProxy proxy)
-            throws Keyserver.QueryFailedException, Keyserver.QueryNeedsRepairException {
+            throws KeyserverClient.QueryFailedException, KeyserverClient.QueryNeedsRepairException {
         ArrayList<ImportKeysListEntry> results = new ArrayList<>();
 
         if (query.length() < 3) {
-            throw new Keyserver.QueryTooShortException();
+            throw new KeyserverClient.QueryTooShortException();
         }
 
         String data;
@@ -273,19 +162,19 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
                     // NOTE: This is also a 404 error for some keyservers!
                     return results;
                 } else if (e.getData().toLowerCase(Locale.ENGLISH).contains("too many")) {
-                    throw new Keyserver.TooManyResponsesException();
+                    throw new KeyserverClient.TooManyResponsesException();
                 } else if (e.getData().toLowerCase(Locale.ENGLISH).contains("insufficient")) {
-                    throw new Keyserver.QueryTooShortException();
+                    throw new KeyserverClient.QueryTooShortException();
                 } else if (e.getCode() == 404) {
                     // NOTE: handle this 404 at last, maybe it was a "no keys found" error
-                    throw new Keyserver.QueryFailedException("Keyserver '" + mUrl + "' not found. Error 404");
+                    throw new KeyserverClient.QueryFailedException("Keyserver '" + hkpKeyserver.getUrl() + "' not found. Error 404");
                 } else {
                     // NOTE: some keyserver do not provide a more detailed error response
-                    throw new Keyserver.QueryTooShortOrTooManyResponsesException();
+                    throw new KeyserverClient.QueryTooShortOrTooManyResponsesException();
                 }
             }
 
-            throw new Keyserver.QueryFailedException("Querying server(s) for '" + mUrl + "' failed.");
+            throw new KeyserverClient.QueryFailedException("Querying server(s) for '" + hkpKeyserver.getUrl() + "' failed.");
         }
 
         final Matcher matcher = PUB_KEY_LINE.matcher(data);
@@ -372,7 +261,7 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
             }
             entry.setUserIds(userIds);
             entry.setPrimaryUserId(userIds.get(0));
-            entry.setKeyserver(this);
+            entry.setKeyserver(hkpKeyserver);
 
             results.add(entry);
         }
@@ -380,7 +269,7 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
     }
 
     @Override
-    public String get(String keyIdHex, ParcelableProxy proxy) throws Keyserver.QueryFailedException {
+    public String get(String keyIdHex, ParcelableProxy proxy) throws KeyserverClient.QueryFailedException {
         String data;
         try {
             HttpUrl url = getHttpUrl(proxy).newBuilder()
@@ -398,23 +287,23 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
         } catch (HttpError httpError) {
             Log.d(Constants.TAG, "Failed to get key at HkpKeyserver", httpError);
             if (httpError.getCode() == 404) {
-                throw new Keyserver.QueryNotFoundException("not found");
+                throw new KeyserverClient.QueryNotFoundException("not found");
             }
-            throw new Keyserver.QueryFailedException("not found");
+            throw new KeyserverClient.QueryFailedException("not found");
         }
         if (data == null) {
-            throw new Keyserver.QueryFailedException("data is null");
+            throw new KeyserverClient.QueryFailedException("data is null");
         }
 
         Matcher matcher = PgpHelper.PGP_PUBLIC_KEY.matcher(data);
         if (matcher.find()) {
             return matcher.group(1);
         }
-        throw new Keyserver.QueryFailedException("data is null");
+        throw new KeyserverClient.QueryFailedException("data is null");
     }
 
     @Override
-    public void add(String armoredKey, ParcelableProxy proxy) throws Keyserver.AddKeyException {
+    public void add(String armoredKey, ParcelableProxy proxy) throws KeyserverClient.AddKeyException {
         try {
             HttpUrl url = getHttpUrl(proxy).newBuilder()
                     .addPathSegment("add")
@@ -441,127 +330,89 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
                     + ", body: " + responseBody);
 
             if (response.code() != 200) {
-                throw new Keyserver.AddKeyException();
+                throw new KeyserverClient.AddKeyException();
             }
 
         } catch (IOException e) {
             Log.e(Constants.TAG, "IOException", e);
-            throw new Keyserver.AddKeyException();
+            throw new KeyserverClient.AddKeyException();
         } catch (URISyntaxException e) {
             Log.e(Constants.TAG, "Unsupported keyserver URI", e);
-            throw new Keyserver.AddKeyException();
+            throw new KeyserverClient.AddKeyException();
         }
     }
 
-    private String getHostID() {
+    private HttpUrl getHttpUrl(ParcelableProxy proxy) throws URISyntaxException {
+        URI base = hkpKeyserver.getUrlURI();
+        if (proxy.isTorEnabled() && hkpKeyserver.getOnionURI() != null) {
+            base = hkpKeyserver.getOnionURI();
+        }
+
+        return HttpUrl.get(base).newBuilder()
+                .addPathSegment("pks")
+                .build();
+    }
+
+    private String query(HttpUrl url, @NonNull ParcelableProxy proxy) throws KeyserverClient.QueryFailedException, HttpError {
         try {
-            return (new URI(mUrl)).getHost();
+            OkHttpClient client = OkHttpClientFactory.getClientPinnedIfAvailable(url.url(), proxy.getProxy());
-        } catch (URISyntaxException e) {
-            return mUrl;
-        }
-    }
 
-    @Override
+            Request request = new Request.Builder()
-    public String toString() {
+                    .url(url)
-        return getHostID();
+                    .build();
-    }
 
-    @Override
+            Response response = client
-    public boolean equals(Object obj) {
+                    .newCall(request)
-        if (! (obj instanceof ParcelableHkpKeyserver)) {
+                    .execute();
-            return false;
-        }
 
-        ParcelableHkpKeyserver other = (ParcelableHkpKeyserver) obj;
+            // contains body both in case of success or failure
-        if (other.mUrl == null ^ mUrl == null) {
+            String responseBody = getResponseBodyAsUtf8(response);
-            return false;
-        }
-        if (other.mOnion == null ^ mOnion == null) {
-            return false;
-        }
-        if (mUrl != null && !mUrl.equals(other.mUrl)) {
-            return false;
-        }
-        if (mOnion != null && !mOnion.equals(other.mOnion)) {
-            return false;
-        }
 
-        return true;
+            if (response.isSuccessful()) {
-    }
+                return responseBody;
-
+            } else {
-    /**
+                throw new HttpError(response.code(), responseBody);
-     * Tries to find a server responsible for a given domain
-     *
-     * @return A responsible Keyserver or null if not found.
-     */
-    public static ParcelableHkpKeyserver resolve(String domain) {
-        try {
-            Record[] records = new Client().query(new Question("_hkp._tcp." + domain, Record.TYPE.SRV)).getAnswers();
-            if (records.length > 0) {
-                Arrays.sort(records, new Comparator<Record>() {
-                    @Override
-                    public int compare(Record lhs, Record rhs) {
-                        if (lhs.getPayload().getType() != Record.TYPE.SRV) return 1;
-                        if (rhs.getPayload().getType() != Record.TYPE.SRV) return -1;
-                        return ((SRV) lhs.getPayload()).getPriority() - ((SRV) rhs.getPayload()).getPriority();
-                    }
-                });
-                Record record = records[0]; // This is our best choice
-                if (record.getPayload().getType() == Record.TYPE.SRV) {
-                    SRV payload = (SRV) record.getPayload();
-                    return new ParcelableHkpKeyserver(payload.getName() + ":" + payload.getPort());
-                }
             }
-        } catch (Exception ignored) {
+        } catch (IOException e) {
+            Log.e(Constants.TAG, "IOException at HkpKeyserver", e);
+            String proxyInfo = proxy.getProxy() == Proxy.NO_PROXY ? "" : " Using proxy " + proxy.getProxy();
+            String causeName = e.getCause().getClass().getSimpleName();
+            throw new KeyserverClient.QueryFailedException(String.format(
+                    "Network error (%s) for '%s'. Check your Internet connection! %s",
+                    causeName, hkpKeyserver.getUrl(), proxyInfo));
         }
-        return null;
+    }
+
+    private String getResponseBodyAsUtf8(Response response) throws IOException {
+        String responseBody;
+        byte[] responseBytes = response.body().bytes();
+        try {
+            responseBody = new String(responseBytes, response.body().contentType().charset(UTF_8));
+        } catch (UnsupportedCharsetException e) {
+            responseBody = new String(responseBytes, UTF_8);
+        }
+
+        return responseBody;
     }
 
     private static class HttpError extends Exception {
         private static final long serialVersionUID = 1718783705229428893L;
-        private int mCode;
+        private int code;
-        private String mData;
+        private String data;
 
         HttpError(int code, String data) {
             super("" + code + ": " + data);
-            mCode = code;
+            this.code = code;
-            mData = data;
+            this.data = data;
         }
 
         public int getCode() {
-            return mCode;
+            return code;
         }
 
         public String getData() {
-            return mData;
+            return data;
         }
     }
 
-    protected ParcelableHkpKeyserver(Parcel in) {
-        mUrl = in.readString();
-        mOnion = in.readString();
-    }
-
-    @Override
-    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeString(mUrl);
-        dest.writeString(mOnion);
-    }
-
-    @Override
-    public int describeContents() {
-        return 0;
-    }
-
-    public static final Creator<ParcelableHkpKeyserver> CREATOR = new Creator<ParcelableHkpKeyserver>() {
-        @Override
-        public ParcelableHkpKeyserver createFromParcel(Parcel in) {
-            return new ParcelableHkpKeyserver(in);
-        }
-
-        @Override
-        public ParcelableHkpKeyserver[] newArray(int size) {
-            return new ParcelableHkpKeyserver[size];
-        }
-    };
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java

@@ -63,7 +63,7 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
     private String mAlgorithm;
 
     private UserId mPrimaryUserId;
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private String mKeybaseName;
     private String mFbUsername;
 
@@ -189,11 +189,11 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
         mPrimaryUserId = primaryUserId;
     }
 
-    public ParcelableHkpKeyserver getKeyserver() {
+    public HkpKeyserverAddress getKeyserver() {
         return mKeyserver;
     }
 
-    public void setKeyserver(ParcelableHkpKeyserver keyserver) {
+    public void setKeyserver(HkpKeyserverAddress keyserver) {
         mKeyserver = keyserver;
     }
 
@@ -399,7 +399,7 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
             vr.mBitStrength = source.readInt() != 0 ? source.readInt() : null;
             vr.mAlgorithm = source.readString();
             vr.mSecretKey = source.readByte() == 1;
-            vr.mKeyserver = source.readParcelable(ParcelableHkpKeyserver.class.getClassLoader());
+            vr.mKeyserver = source.readParcelable(HkpKeyserverAddress.class.getClassLoader());
             vr.mKeybaseName = source.readString();
             vr.mFbUsername = source.readString();
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyserverClient.java

@@ -31,13 +31,13 @@ import org.sufficientlysecure.keychain.util.ParcelableProxy;
 import java.util.ArrayList;
 import java.util.List;
 
-public class KeybaseKeyserver extends Keyserver {
+public class KeybaseKeyserverClient implements KeyserverClient {
 
-    public static KeybaseKeyserver getInstance() {
+    public static KeybaseKeyserverClient getInstance() {
-        return new KeybaseKeyserver();
+        return new KeybaseKeyserverClient();
     }
 
-    private KeybaseKeyserver() { }
+    private KeybaseKeyserverClient() { }
 
     @Override
     public ArrayList<ImportKeysListEntry> search(String query, ParcelableProxy proxy) throws QueryFailedException,

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeyserverClient.java

@@ -1,7 +1,5 @@
 /*
  * Copyright (C) 2012-2014 Dominik Schürmann <dominik@dominikschuermann.de>
- * Copyright (C) 2011-2014 Thialfihar <thi@thialfihar.org>
- * Copyright (C) 2011 Senecaso
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,9 +23,9 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;
 
-public abstract class Keyserver {
+public interface KeyserverClient {
 
-    public static class CloudSearchFailureException extends Exception {
+    class CloudSearchFailureException extends Exception {
         private static final long serialVersionUID = 2703768928624654515L;
 
         public CloudSearchFailureException(String message) {
@@ -39,7 +37,7 @@ public abstract class Keyserver {
         }
     }
 
-    public static class QueryFailedException extends CloudSearchFailureException {
+    class QueryFailedException extends CloudSearchFailureException {
         private static final long serialVersionUID = 2703768928624654512L;
 
         public QueryFailedException(String message) {
@@ -47,7 +45,7 @@ public abstract class Keyserver {
         }
     }
 
-    public static class QueryNotFoundException extends QueryFailedException {
+    class QueryNotFoundException extends QueryFailedException {
         private static final long serialVersionUID = 2693768928624654513L;
 
         public QueryNotFoundException(String message) {
@@ -55,52 +53,37 @@ public abstract class Keyserver {
         }
     }
 
-    public static class QueryNeedsRepairException extends CloudSearchFailureException {
+    class QueryNeedsRepairException extends CloudSearchFailureException {
         private static final long serialVersionUID = 2693768928624654512L;
     }
 
-    public static class TooManyResponsesException extends QueryNeedsRepairException {
+    class TooManyResponsesException extends QueryNeedsRepairException {
         private static final long serialVersionUID = 2703768928624654513L;
     }
 
-    public static class QueryTooShortException extends QueryNeedsRepairException {
+    class QueryTooShortException extends QueryNeedsRepairException {
         private static final long serialVersionUID = 2703768928624654514L;
     }
 
     /**
      * query too short _or_ too many responses
      */
-    public static class QueryTooShortOrTooManyResponsesException extends QueryNeedsRepairException {
+    class QueryTooShortOrTooManyResponsesException extends QueryNeedsRepairException {
         private static final long serialVersionUID = 2703768928624654518L;
     }
 
-    public static class QueryNoEnabledSourceException extends QueryNeedsRepairException {
+    class QueryNoEnabledSourceException extends QueryNeedsRepairException {
         private static final long serialVersionUID = 2703768928624654519L;
     }
 
-    public static class AddKeyException extends Exception {
+    class AddKeyException extends Exception {
         private static final long serialVersionUID = -507574859137295530L;
     }
 
-    public abstract List<ImportKeysListEntry> search(String query, ParcelableProxy proxy)
+    List<ImportKeysListEntry> search(String query, ParcelableProxy proxy)
             throws QueryFailedException, QueryNeedsRepairException;
 
-    public abstract String get(String keyIdHex, ParcelableProxy proxy) throws QueryFailedException;
+    String get(String keyIdHex, ParcelableProxy proxy) throws QueryFailedException;
 
-    public abstract void add(String armoredKey, ParcelableProxy proxy) throws AddKeyException;
+    void add(String armoredKey, ParcelableProxy proxy) throws AddKeyException;
-
-    public static String readAll(InputStream in, String encoding) throws IOException {
-        ByteArrayOutputStream raw = new ByteArrayOutputStream();
-
-        byte buffer[] = new byte[1 << 16];
-        int n = 0;
-        while ((n = in.read(buffer)) != -1) {
-            raw.write(buffer, 0, n);
-        }
-
-        if (encoding == null) {
-            encoding = "utf8";
-        }
-        return raw.toString(encoding);
-    }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/processing/ImportKeysListCloudLoader.java

@@ -24,7 +24,7 @@ import android.support.v4.content.AsyncTaskLoader;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.keyimport.CloudSearch;
 import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
-import org.sufficientlysecure.keychain.keyimport.Keyserver;
+import org.sufficientlysecure.keychain.keyimport.KeyserverClient;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.GetKeyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
@@ -167,23 +167,23 @@ public class ImportKeysListCloudLoader
             }
             GetKeyResult getKeyResult = new GetKeyResult(GetKeyResult.RESULT_OK, null);
             mEntryListWrapper = new AsyncTaskResultWrapper<>(mEntryList, getKeyResult);
-        } catch (Keyserver.CloudSearchFailureException e) {
+        } catch (KeyserverClient.CloudSearchFailureException e) {
             // convert exception to result parcel
             int error = GetKeyResult.RESULT_ERROR;
             OperationResult.LogType logType = null;
-            if (e instanceof Keyserver.QueryFailedException) {
+            if (e instanceof KeyserverClient.QueryFailedException) {
                 error = GetKeyResult.RESULT_ERROR_QUERY_FAILED;
                 logType = OperationResult.LogType.MSG_GET_QUERY_FAILED;
-            } else if (e instanceof Keyserver.TooManyResponsesException) {
+            } else if (e instanceof KeyserverClient.TooManyResponsesException) {
                 error = GetKeyResult.RESULT_ERROR_TOO_MANY_RESPONSES;
                 logType = OperationResult.LogType.MSG_GET_TOO_MANY_RESPONSES;
-            } else if (e instanceof Keyserver.QueryTooShortException) {
+            } else if (e instanceof KeyserverClient.QueryTooShortException) {
                 error = GetKeyResult.RESULT_ERROR_QUERY_TOO_SHORT;
                 logType = OperationResult.LogType.MSG_GET_QUERY_TOO_SHORT;
-            } else if (e instanceof Keyserver.QueryTooShortOrTooManyResponsesException) {
+            } else if (e instanceof KeyserverClient.QueryTooShortOrTooManyResponsesException) {
                 error = GetKeyResult.RESULT_ERROR_TOO_SHORT_OR_TOO_MANY_RESPONSES;
                 logType = OperationResult.LogType.MSG_GET_QUERY_TOO_SHORT_OR_TOO_MANY_RESPONSES;
-            } else if (e instanceof Keyserver.QueryNoEnabledSourceException) {
+            } else if (e instanceof KeyserverClient.QueryNoEnabledSourceException) {
                 error = GetKeyResult.RESULT_ERROR_NO_ENABLED_SOURCE;
                 logType = OperationResult.LogType.MSG_GET_NO_ENABLED_SOURCE;
             }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/ImportOperation.java

@@ -37,11 +37,12 @@ import android.support.annotation.Nullable;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.FacebookKeyserver;
+import org.sufficientlysecure.keychain.keyimport.FacebookKeyserverClient;
-import org.sufficientlysecure.keychain.keyimport.KeybaseKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverClient;
-import org.sufficientlysecure.keychain.keyimport.Keyserver;
+import org.sufficientlysecure.keychain.keyimport.KeybaseKeyserverClient;
-import org.sufficientlysecure.keychain.keyimport.Keyserver.QueryNotFoundException;
+import org.sufficientlysecure.keychain.keyimport.KeyserverClient;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.KeyserverClient.QueryNotFoundException;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.network.orbot.OrbotHelper;
 import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
@@ -87,8 +88,8 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
     private static final int MAX_THREADS = 10;
 
     public static final String CACHE_FILE_NAME = "key_import.pcl";
-    private FacebookKeyserver facebookServer;
+    private FacebookKeyserverClient facebookServer;
-    private KeybaseKeyserver keybaseServer;
+    private KeybaseKeyserverClient keybaseServer;
 
     public ImportOperation(Context context, KeyWritableRepository databaseInteractor, Progressable progressable) {
         super(context, databaseInteractor, progressable);
@@ -101,13 +102,13 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
 
     // Overloaded functions for using progressable supplied in constructor during import
     public ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int num,
-                                               ParcelableHkpKeyserver keyserver, ParcelableProxy proxy, boolean skipSave) {
+                                               HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave) {
         return serialKeyRingImport(entries, num, keyserver, mProgressable, proxy, skipSave);
     }
 
     @NonNull
     private ImportKeyResult serialKeyRingImport(ParcelableFileCache<ParcelableKeyRing> cache,
-                                                ParcelableHkpKeyserver keyserver, ParcelableProxy proxy, boolean skipSave) {
+                                                HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave) {
 
         // get entries from cached file
         try {
@@ -139,7 +140,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
      */
     @NonNull
     private ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int numTotalKeys,
-                                                ParcelableHkpKeyserver hkpKeyserver, Progressable progressable,
+                                                HkpKeyserverAddress hkpKeyserver, Progressable progressable,
                                                 @NonNull ParcelableProxy proxy, boolean skipSave) {
         if (progressable != null) {
             progressable.setProgress(R.string.progress_importing, 0, 100);
@@ -324,7 +325,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
         return result;
     }
 
-    private UncachedKeyRing fetchKeyFromInternet(ParcelableHkpKeyserver hkpKeyserver, @NonNull ParcelableProxy proxy,
+    private UncachedKeyRing fetchKeyFromInternet(HkpKeyserverAddress hkpKeyserver, @NonNull ParcelableProxy proxy,
             OperationLog log, ParcelableKeyRing entry, UncachedKeyRing key)
             throws PgpGeneralException, IOException, QueryNotFoundException {
         QueryNotFoundException queryNotFoundException = null;
@@ -368,21 +369,23 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
     }
 
     @Nullable
-    private UncachedKeyRing fetchKeyFromKeyserver(ParcelableHkpKeyserver hkpKeyserver, @NonNull ParcelableProxy proxy,
+    private UncachedKeyRing fetchKeyFromKeyserver(HkpKeyserverAddress hkpKeyserver, @NonNull ParcelableProxy proxy,
-            OperationLog log, ParcelableKeyRing entry) throws PgpGeneralException, IOException, Keyserver.QueryNotFoundException {
+            OperationLog log, ParcelableKeyRing entry) throws PgpGeneralException, IOException, KeyserverClient.QueryNotFoundException {
         try {
             byte[] data;
             log.add(LogType.MSG_IMPORT_KEYSERVER, 1, hkpKeyserver);
 
+            HkpKeyserverClient keyserverInteractor = HkpKeyserverClient.fromHkpKeyserverAddress(hkpKeyserver);
+
             // Download by fingerprint, or keyId - whichever is available
             if (entry.getExpectedFingerprint() != null) {
                 String fingerprintHex = KeyFormattingUtils.convertFingerprintToHex(entry.getExpectedFingerprint());
                 log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, "0x" +
                         fingerprintHex.substring(24));
-                data = hkpKeyserver.get("0x" + fingerprintHex, proxy).getBytes();
+                data = keyserverInteractor.get("0x" + fingerprintHex, proxy).getBytes();
             } else {
                 log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, entry.getKeyIdHex());
-                data = hkpKeyserver.get(entry.getKeyIdHex(), proxy).getBytes();
+                data = keyserverInteractor.get(entry.getKeyIdHex(), proxy).getBytes();
             }
             UncachedKeyRing keyserverKey = UncachedKeyRing.decodeFromData(data);
             if (keyserverKey != null) {
@@ -392,9 +395,9 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
             }
 
             return keyserverKey;
-        } catch (Keyserver.QueryNotFoundException e) {
+        } catch (KeyserverClient.QueryNotFoundException e) {
             throw e;
-        } catch (Keyserver.QueryFailedException e) {
+        } catch (KeyserverClient.QueryFailedException e) {
             Log.d(Constants.TAG, "query failed", e);
             log.add(LogType.MSG_IMPORT_FETCH_ERROR_KEYSERVER, 3, e.getMessage());
             return null;
@@ -404,7 +407,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
     private UncachedKeyRing fetchKeyFromKeybase(@NonNull ParcelableProxy proxy, OperationLog log, ParcelableKeyRing entry)
             throws PgpGeneralException, IOException {
         if (keybaseServer == null) {
-            keybaseServer = KeybaseKeyserver.getInstance();
+            keybaseServer = KeybaseKeyserverClient.getInstance();
         }
 
         try {
@@ -419,7 +422,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
             }
 
             return keybaseKey;
-        } catch (Keyserver.QueryFailedException e) {
+        } catch (KeyserverClient.QueryFailedException e) {
             // download failed, too bad. just proceed
             Log.e(Constants.TAG, "query failed", e);
             log.add(LogType.MSG_IMPORT_FETCH_ERROR_KEYSERVER, 3, e.getMessage());
@@ -430,7 +433,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
     private UncachedKeyRing fetchKeyFromFacebook(@NonNull ParcelableProxy proxy, OperationLog log, ParcelableKeyRing entry)
             throws PgpGeneralException, IOException {
         if (facebookServer == null) {
-            facebookServer = FacebookKeyserver.getInstance();
+            facebookServer = FacebookKeyserverClient.getInstance();
         }
 
         try {
@@ -445,7 +448,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
             }
 
             return facebookKey;
-        } catch (Keyserver.QueryFailedException e) {
+        } catch (KeyserverClient.QueryFailedException e) {
             // download failed, too bad. just proceed
             Log.e(Constants.TAG, "query failed", e);
             log.add(LogType.MSG_IMPORT_FETCH_ERROR_KEYSERVER, 3, e.getMessage());
@@ -475,7 +478,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
     @Override
     public ImportKeyResult execute(ImportKeyringParcel importInput, CryptoInputParcel cryptoInput) {
         ArrayList<ParcelableKeyRing> keyList = importInput.getKeyList();
-        ParcelableHkpKeyserver keyServer = importInput.getKeyserver();
+        HkpKeyserverAddress keyServer = importInput.getKeyserver();
         boolean skipSave = importInput.isSkipSave();
 
         ImportKeyResult result;
@@ -508,7 +511,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
 
     @NonNull
     private ImportKeyResult multiThreadedKeyImport(ArrayList<ParcelableKeyRing> keyList,
-                                                   final ParcelableHkpKeyserver keyServer, final ParcelableProxy proxy,
+                                                   final HkpKeyserverAddress keyServer, final ParcelableProxy proxy,
                                                    final boolean skipSave) {
         Log.d(Constants.TAG, "Multi-threaded key import starting");
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/UploadOperation.java

@@ -27,8 +27,9 @@ import android.support.annotation.Nullable;
 import org.bouncycastle.bcpg.ArmoredOutputStream;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.Keyserver.AddKeyException;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverClient;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.KeyserverClient.AddKeyException;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
 import org.sufficientlysecure.keychain.operations.results.UploadResult;
@@ -94,7 +95,7 @@ public class UploadOperation extends BaseOperation<UploadKeyringParcel> {
             log.add(LogType.MSG_UPLOAD_PROXY, 1, parcelableProxy.getProxy().toString());
         }
 
-        ParcelableHkpKeyserver hkpKeyserver;
+        HkpKeyserverAddress hkpKeyserver;
         {
             hkpKeyserver = uploadInput.getKeyserver();
             log.add(LogType.MSG_UPLOAD_SERVER, 1, hkpKeyserver.toString());
@@ -139,19 +140,21 @@ public class UploadOperation extends BaseOperation<UploadKeyringParcel> {
 
     @NonNull
     private UploadResult uploadKeyRingToServer(
-            OperationLog log, ParcelableHkpKeyserver server, CanonicalizedPublicKeyRing keyring,
+            OperationLog log, HkpKeyserverAddress hkpKeyserverAddress, CanonicalizedPublicKeyRing keyring,
             ParcelableProxy proxy) {
 
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ArmoredOutputStream aos = null;
 
+        HkpKeyserverClient keyserverInteractor = HkpKeyserverClient.fromHkpKeyserverAddress(hkpKeyserverAddress);
+
         try {
             aos = new ArmoredOutputStream(bos);
             keyring.encode(aos);
             aos.close();
 
             String armoredKey = bos.toString("UTF-8");
-            server.add(armoredKey, proxy);
+            keyserverInteractor.add(armoredKey, proxy);
 
             updateProgress(R.string.progress_uploading, 1, 1);
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/CertifyActionsParcel.java

@@ -28,7 +28,7 @@ import android.support.annotation.CheckResult;
 import android.support.annotation.Nullable;
 
 import com.google.auto.value.AutoValue;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
 
 
@@ -37,7 +37,7 @@ public abstract class CertifyActionsParcel implements Parcelable {
     public abstract long getMasterKeyId();
     public abstract ArrayList<CertifyAction> getCertifyActions();
     @Nullable
-    public abstract ParcelableHkpKeyserver getParcelableKeyServer();
+    public abstract HkpKeyserverAddress getParcelableKeyServer();
 
     public static Builder builder(long masterKeyId) {
         return new AutoValue_CertifyActionsParcel.Builder()
@@ -49,7 +49,7 @@ public abstract class CertifyActionsParcel implements Parcelable {
     public abstract static class Builder {
         abstract Builder setMasterKeyId(long masterKeyId);
         public abstract Builder setCertifyActions(ArrayList<CertifyAction> certifyActions);
-        public abstract Builder setParcelableKeyServer(ParcelableHkpKeyserver uri);
+        public abstract Builder setParcelableKeyServer(HkpKeyserverAddress uri);
 
         abstract ArrayList<CertifyAction> getCertifyActions();
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ImportKeyringParcel.java

@@ -25,7 +25,7 @@ import android.os.Parcelable;
 import android.support.annotation.Nullable;
 
 import com.google.auto.value.AutoValue;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 
 @AutoValue
@@ -33,16 +33,16 @@ public abstract class ImportKeyringParcel implements Parcelable {
     @Nullable // If null, keys are expected to be read from a cache file in ImportExportOperations
     public abstract ArrayList<ParcelableKeyRing> getKeyList();
     @Nullable // must be set if keys are to be imported from a keyserver
-    public abstract ParcelableHkpKeyserver getKeyserver();
+    public abstract HkpKeyserverAddress getKeyserver();
     public abstract boolean isSkipSave();
 
     public static ImportKeyringParcel createImportKeyringParcel(ArrayList<ParcelableKeyRing> keyList,
-            ParcelableHkpKeyserver keyserver) {
+            HkpKeyserverAddress keyserver) {
         return new AutoValue_ImportKeyringParcel(keyList, keyserver, false);
     }
 
     public static ImportKeyringParcel createWithSkipSave(ArrayList<ParcelableKeyRing> keyList,
-            ParcelableHkpKeyserver keyserver) {
+            HkpKeyserverAddress keyserver) {
         return new AutoValue_ImportKeyringParcel(keyList, keyserver, true);
     }
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/RevokeKeyringParcel.java

@@ -24,17 +24,18 @@ import android.os.Parcelable;
 import android.support.annotation.Nullable;
 
 import com.google.auto.value.AutoValue;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
+
 
 @AutoValue
 public abstract class RevokeKeyringParcel implements Parcelable {
     public abstract long getMasterKeyId();
     public abstract boolean isShouldUpload();
     @Nullable
-    public abstract ParcelableHkpKeyserver getKeyserver();
+    public abstract HkpKeyserverAddress getKeyserver();
 
     public static RevokeKeyringParcel createRevokeKeyringParcel(long masterKeyId, boolean upload,
-            ParcelableHkpKeyserver keyserver) {
+            HkpKeyserverAddress keyserver) {
         return new AutoValue_RevokeKeyringParcel(masterKeyId, upload, keyserver);
     }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/SaveKeyringParcel.java

@@ -28,7 +28,7 @@ import android.os.Parcelable;
 import android.support.annotation.Nullable;
 
 import com.google.auto.value.AutoValue;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
 import org.sufficientlysecure.keychain.util.Passphrase;
 
@@ -78,7 +78,7 @@ public abstract class SaveKeyringParcel implements Parcelable {
     public abstract boolean isShouldUpload();
     public abstract boolean isShouldUploadAtomic();
     @Nullable
-    public abstract ParcelableHkpKeyserver getUploadKeyserver();
+    public abstract HkpKeyserverAddress getUploadKeyserver();
 
     @Nullable
     public abstract ChangeUnlockParcel getNewUnlock();
@@ -151,9 +151,9 @@ public abstract class SaveKeyringParcel implements Parcelable {
         abstract Builder setRevokeSubKeys(List<Long> revokeSubKeys);
         abstract Builder setShouldUpload(boolean upload);
         abstract Builder setShouldUploadAtomic(boolean uploadAtomic);
-        abstract Builder setUploadKeyserver(ParcelableHkpKeyserver keyserver);
+        abstract Builder setUploadKeyserver(HkpKeyserverAddress keyserver);
 
-        public void setUpdateOptions(boolean upload, boolean uploadAtomic, ParcelableHkpKeyserver keyserver) {
+        public void setUpdateOptions(boolean upload, boolean uploadAtomic, HkpKeyserverAddress keyserver) {
             setShouldUpload(upload);
             setShouldUploadAtomic(uploadAtomic);
             setUploadKeyserver(keyserver);

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/UploadKeyringParcel.java

@@ -25,11 +25,12 @@ import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
 import com.google.auto.value.AutoValue;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
+
 
 @AutoValue
 public abstract class UploadKeyringParcel implements Parcelable {
-    public abstract ParcelableHkpKeyserver getKeyserver();
+    public abstract HkpKeyserverAddress getKeyserver();
     @Nullable
     public abstract Long getMasterKeyId();
     @Nullable
@@ -37,11 +38,11 @@ public abstract class UploadKeyringParcel implements Parcelable {
     public abstract byte[] getUncachedKeyringBytes();
 
 
-    public static UploadKeyringParcel createWithKeyId(ParcelableHkpKeyserver keyserver, long masterKeyId) {
+    public static UploadKeyringParcel createWithKeyId(HkpKeyserverAddress keyserver, long masterKeyId) {
         return new AutoValue_UploadKeyringParcel(keyserver, masterKeyId, null);
     }
 
-    public static UploadKeyringParcel createWithKeyringBytes(ParcelableHkpKeyserver keyserver,
+    public static UploadKeyringParcel createWithKeyringBytes(HkpKeyserverAddress keyserver,
             @NonNull byte[] uncachedKeyringBytes) {
         return new AutoValue_UploadKeyringParcel(keyserver, null, uncachedKeyringBytes);
     }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java

@@ -53,7 +53,7 @@ import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
 import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
 import org.sufficientlysecure.keychain.util.Log;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.util.Passphrase;
 import org.sufficientlysecure.keychain.util.Preferences;
 
@@ -519,7 +519,7 @@ public class CreateKeyFinalFragment extends Fragment {
         // set data uri as path to keyring
         final long masterKeyId = saveKeyResult.mMasterKeyId;
         // upload to favorite keyserver
-        final ParcelableHkpKeyserver keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
+        final HkpKeyserverAddress keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
 
         CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult> callback
                 = new CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult>() {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateSecurityTokenImportResetFragment.java

@@ -43,7 +43,7 @@ import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
 import org.sufficientlysecure.keychain.ui.CreateKeyActivity.SecurityTokenListenerFragment;
 import org.sufficientlysecure.keychain.ui.base.QueueingCryptoOperationFragment;
 import org.sufficientlysecure.keychain.ui.keyview.ViewKeyActivity;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.io.IOException;
@@ -77,7 +77,7 @@ public class CreateSecurityTokenImportResetFragment
     private View mResetWarning;
 
     // for CryptoOperationFragment key import
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private ArrayList<ParcelableKeyRing> mKeyList;
 
     public static Fragment newInstance(byte[] scannedFingerprints, byte[] nfcAid, String userId) {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java

@@ -43,7 +43,7 @@ import org.openintents.openpgp.OpenPgpSignatureResult;
 import org.openintents.openpgp.util.OpenPgpUtils;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
@@ -140,7 +140,7 @@ public abstract class DecryptFragment extends Fragment implements LoaderManager.
     private void lookupUnknownKey(long unknownKeyId) {
 
         final ArrayList<ParcelableKeyRing> keyList;
-        final ParcelableHkpKeyserver keyserver;
+        final HkpKeyserverAddress keyserver;
 
         // search config
         keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptListFragment.java

@@ -74,6 +74,7 @@ import org.openintents.openpgp.OpenPgpSignatureResult;
 import org.sufficientlysecure.keychain.BuildConfig;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
 import org.sufficientlysecure.keychain.operations.results.InputDataResult;
@@ -96,7 +97,6 @@ import org.sufficientlysecure.keychain.ui.util.Notify.Style;
 import org.sufficientlysecure.keychain.util.FileHelper;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ParcelableHashMap;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
 import org.sufficientlysecure.keychain.util.Preferences;
 
 
@@ -760,7 +760,7 @@ public class DecryptListFragment
     private void lookupUnknownKey(final Uri inputUri, long unknownKeyId) {
 
         final ArrayList<ParcelableKeyRing> keyList;
-        final ParcelableHkpKeyserver keyserver;
+        final HkpKeyserverAddress keyserver;
 
         // search config
         keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DeleteKeyDialogActivity.java

@@ -37,7 +37,7 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.operations.results.DeleteResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.operations.results.RevokeResult;
@@ -152,7 +152,7 @@ public class DeleteKeyDialogActivity extends FragmentActivity {
             @Override
             public RevokeKeyringParcel createOperationInput() {
                 return RevokeKeyringParcel.createRevokeKeyringParcel(mMasterKeyIds[0], true,
-                        (ParcelableHkpKeyserver) getIntent().getParcelableExtra(EXTRA_KEYSERVER));
+                        (HkpKeyserverAddress) getIntent().getParcelableExtra(EXTRA_KEYSERVER));
             }
 
             @Override

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditIdentitiesFragment.java

@@ -41,7 +41,7 @@ import android.widget.ListView;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.compatibility.DialogFragmentWorkaround;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
@@ -388,7 +388,7 @@ public class EditIdentitiesFragment extends Fragment
 
         final long masterKeyId = editKeyResult.mMasterKeyId;
         // upload to favorite keyserver
-        final ParcelableHkpKeyserver keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
+        final HkpKeyserverAddress keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
 
         CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult> callback
                 = new CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult>() {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ImportKeysActivity.java

@@ -28,7 +28,8 @@ import android.view.ViewGroup;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.FacebookKeyserver;
+import org.sufficientlysecure.keychain.keyimport.FacebookKeyserverClient;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.keyimport.processing.ImportKeysListener;
@@ -43,7 +44,6 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ParcelableFileCache;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
 import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.io.IOException;
@@ -119,7 +119,7 @@ public class ImportKeysActivity extends BaseActivity implements ImportKeysListen
         }
 
         if (Intent.ACTION_VIEW.equals(action)) {
-            if (FacebookKeyserver.isFacebookHost(dataUri)) {
+            if (FacebookKeyserverClient.isFacebookHost(dataUri)) {
                 action = ACTION_IMPORT_KEY_FROM_FACEBOOK;
             } else if ("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme)) {
                 action = ACTION_SEARCH_KEYSERVER_FROM_URL;
@@ -202,7 +202,7 @@ public class ImportKeysActivity extends BaseActivity implements ImportKeysListen
                 break;
             }
             case ACTION_IMPORT_KEY_FROM_FACEBOOK: {
-                String fbUsername = FacebookKeyserver.getUsernameFromUri(dataUri);
+                String fbUsername = FacebookKeyserverClient.getUsernameFromUri(dataUri);
 
                 Preferences.CloudSearchPrefs cloudSearchPrefs =
                         new Preferences.CloudSearchPrefs(false, true, true, null);
@@ -212,7 +212,7 @@ public class ImportKeysActivity extends BaseActivity implements ImportKeysListen
             }
             case ACTION_SEARCH_KEYSERVER_FROM_URL: {
                 // get keyserver from URL
-                ParcelableHkpKeyserver keyserver = new ParcelableHkpKeyserver(
+                HkpKeyserverAddress keyserver = HkpKeyserverAddress.createFromUri(
                         dataUri.getScheme() + "://" + dataUri.getAuthority());
                 Preferences.CloudSearchPrefs cloudSearchPrefs = new Preferences.CloudSearchPrefs(
                         true, false, false, keyserver);

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ImportKeysProxyActivity.java

@@ -43,7 +43,7 @@ import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.IntentIntegratorSupportV4;
 import org.sufficientlysecure.keychain.util.Log;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.util.ArrayList;
@@ -63,7 +63,7 @@ public class ImportKeysProxyActivity extends FragmentActivity
     public static final String EXTRA_FINGERPRINT = "fingerprint";
 
     // for CryptoOperationHelper
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private ArrayList<ParcelableKeyRing> mKeyList;
     private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java

@@ -50,7 +50,7 @@ import com.tonicartos.superslim.LayoutManager;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.BenchmarkResult;
 import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
@@ -94,7 +94,7 @@ public class KeyListFragment extends RecyclerFragment<KeySectionedListAdapter>
 
     // for CryptoOperationHelper import
     private ArrayList<ParcelableKeyRing> mKeyList;
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;
 
     // for ConsolidateOperation

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SafeSlingerActivity.java

@@ -35,7 +35,7 @@ import edu.cmu.cylab.starslinger.exchange.ExchangeActivity;
 import edu.cmu.cylab.starslinger.exchange.ExchangeConfig;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.ImportOperation;
 import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
@@ -64,7 +64,7 @@ public class SafeSlingerActivity extends BaseActivity
 
     // for CryptoOperationHelper
     private ArrayList<ParcelableKeyRing> mKeyList;
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mOperationHelper;
 
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsActivity.java

@@ -53,7 +53,7 @@ import org.sufficientlysecure.keychain.service.ContactSyncAdapterService;
 import org.sufficientlysecure.keychain.ui.base.BaseActivity;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.ui.util.ThemeChanger;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.network.orbot.OrbotHelper;
@@ -185,7 +185,7 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
         }
 
         public static String keyserverSummary(Context context) {
-            ArrayList<ParcelableHkpKeyserver> servers = sPreferences.getKeyServers();
+            ArrayList<HkpKeyserverAddress> servers = sPreferences.getKeyServers();
             String serverSummary = context.getResources().getQuantityString(
                     R.plurals.n_keyservers, servers.size(), servers.size());
             return serverSummary + "; " + context.getString(R.string.label_preferred) + ": " + sPreferences

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsKeyServerActivity.java

@@ -22,7 +22,7 @@ import android.os.Bundle;
 import android.view.MenuItem;
 
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.ui.base.BaseActivity;
 
 import java.util.ArrayList;
@@ -36,7 +36,7 @@ public class SettingsKeyServerActivity extends BaseActivity {
         super.onCreate(savedInstanceState);
 
         Intent intent = getIntent();
-        ArrayList<ParcelableHkpKeyserver> servers = intent.getParcelableArrayListExtra(EXTRA_KEY_SERVERS);
+        ArrayList<HkpKeyserverAddress> servers = intent.getParcelableArrayListExtra(EXTRA_KEY_SERVERS);
         loadFragment(savedInstanceState, servers);
 
         getSupportActionBar().setDisplayHomeAsUpEnabled(true);
@@ -58,7 +58,7 @@ public class SettingsKeyServerActivity extends BaseActivity {
         setContentView(R.layout.key_server_preference);
     }
 
-    private void loadFragment(Bundle savedInstanceState, ArrayList<ParcelableHkpKeyserver> keyservers) {
+    private void loadFragment(Bundle savedInstanceState, ArrayList<HkpKeyserverAddress> keyservers) {
         // However, if we're being restored from a previous state,
         // then we don't need to do anything and should return or else
         // we could end up with overlapping fragments.

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsKeyserverFragment.java

@@ -43,7 +43,7 @@ import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.provider.KeyWritableRepository;
 import org.sufficientlysecure.keychain.ui.dialog.AddEditKeyserverDialogFragment;
 import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
@@ -60,13 +60,13 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
     private static final String ARG_KEYSERVER_ARRAY = "arg_keyserver_array";
     private ItemTouchHelper mItemTouchHelper;
 
-    private ArrayList<ParcelableHkpKeyserver> mKeyserversMutable;
+    private ArrayList<HkpKeyserverAddress> mKeyserversMutable;
-    private List<ParcelableHkpKeyserver> mKeyservers;
+    private List<HkpKeyserverAddress> mKeyservers;
     private KeyserverListAdapter mAdapter;
 
     private KeyWritableRepository databaseReadWriteInteractor;
 
-    public static SettingsKeyserverFragment newInstance(ArrayList<ParcelableHkpKeyserver> keyservers) {
+    public static SettingsKeyserverFragment newInstance(ArrayList<HkpKeyserverAddress> keyservers) {
         Bundle args = new Bundle();
         args.putParcelableArrayList(ARG_KEYSERVER_ARRAY, keyservers);
 
@@ -139,7 +139,7 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
     }
 
     private void startEditKeyserverDialog(AddEditKeyserverDialogFragment.DialogAction action,
-                                          ParcelableHkpKeyserver keyserver, final int position) {
+                                          HkpKeyserverAddress keyserver, final int position) {
         Handler returnHandler = new Handler() {
             @Override
             public void handleMessage(Message message) {
@@ -168,7 +168,7 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
                                     R.string.add_keyserver_without_verification,
                                     Notify.Style.WARN).show();
                         }
-                        ParcelableHkpKeyserver keyserver = data.getParcelable(
+                        HkpKeyserverAddress keyserver = data.getParcelable(
                                 AddEditKeyserverDialogFragment.MESSAGE_KEYSERVER);
 
                         AddEditKeyserverDialogFragment.DialogAction dialogAction
@@ -195,13 +195,13 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
         dialogFragment.show(getFragmentManager(), "addKeyserverDialog");
     }
 
-    private void addKeyserver(ParcelableHkpKeyserver keyserver) {
+    private void addKeyserver(HkpKeyserverAddress keyserver) {
         mKeyserversMutable.add(keyserver);
         mAdapter.notifyItemInserted(mKeyserversMutable.size() - 1);
         saveKeyserverList();
     }
 
-    private void editKeyserver(ParcelableHkpKeyserver newKeyserver, int position) {
+    private void editKeyserver(HkpKeyserverAddress newKeyserver, int position) {
         mKeyserversMutable.set(position, newKeyserver);
         mAdapter.notifyItemChanged(position);
         saveKeyserverList();
@@ -243,9 +243,9 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
     public class KeyserverListAdapter extends RecyclerView.Adapter<KeyserverListAdapter.ViewHolder>
             implements ItemTouchHelperAdapter {
 
-        private final ArrayList<ParcelableHkpKeyserver> mKeyservers;
+        private final ArrayList<HkpKeyserverAddress> mKeyservers;
 
-        public KeyserverListAdapter(ArrayList<ParcelableHkpKeyserver> keyservers) {
+        public KeyserverListAdapter(ArrayList<HkpKeyserverAddress> keyservers) {
             mKeyservers = keyservers;
         }
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/UploadKeyActivity.java

@@ -35,7 +35,7 @@ import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.service.UploadKeyringParcel;
 import org.sufficientlysecure.keychain.ui.base.BaseActivity;
 import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Preferences;
 
@@ -52,7 +52,7 @@ public class UploadKeyActivity extends BaseActivity
     private Uri mDataUri;
 
     // CryptoOperationHelper.Callback vars
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private CryptoOperationHelper<UploadKeyringParcel, UploadResult> mUploadOpHelper;
 
     @Override
@@ -94,11 +94,11 @@ public class UploadKeyActivity extends BaseActivity
     }
 
     private String[] getKeyserversArray() {
-        ArrayList<ParcelableHkpKeyserver> keyservers = Preferences.getPreferences(this)
+        ArrayList<HkpKeyserverAddress> keyservers = Preferences.getPreferences(this)
                 .getKeyServers();
         String[] keyserversArray = new String[keyservers.size()];
         int i = 0;
-        for (ParcelableHkpKeyserver k : keyservers) {
+        for (HkpKeyserverAddress k : keyservers) {
             keyserversArray[i] = k.getUrl();
             i++;
         }
@@ -121,7 +121,7 @@ public class UploadKeyActivity extends BaseActivity
     private void uploadKey() {
         String keyserverUrl = (String) mKeyServerSpinner.getSelectedItem();
         // TODO: Currently, not using onion addresses here!
-        mKeyserver = new ParcelableHkpKeyserver(keyserverUrl);
+        mKeyserver = HkpKeyserverAddress.createFromUri(keyserverUrl);
 
         mUploadOpHelper = new CryptoOperationHelper<>(1, this, this, R.string.progress_uploading);
         mUploadOpHelper.cryptoOperation();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysAdapter.java

@@ -35,8 +35,8 @@ import android.view.ViewGroup;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.databinding.ImportKeysListItemBinding;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.keyimport.processing.ImportKeysListener;
 import org.sufficientlysecure.keychain.keyimport.processing.ImportKeysOperationCallback;
@@ -243,7 +243,7 @@ public class ImportKeysAdapter extends RecyclerView.Adapter<ImportKeysAdapter.Vi
             ArrayList<ParcelableKeyRing> keysList = new ArrayList<>();
             keysList.add(keyRing);
 
-            ParcelableHkpKeyserver keyserver = entry.getKeyserver();
+            HkpKeyserverAddress keyserver = entry.getKeyserver();
 
             if (skipSave) {
                 return ImportKeyringParcel.createWithSkipSave(keysList, keyserver);

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/AddEditKeyserverDialogFragment.java

@@ -53,7 +53,7 @@ import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.network.OkHttpClientFactory;
 import org.sufficientlysecure.keychain.network.TlsCertificatePinning;
 import org.sufficientlysecure.keychain.network.orbot.OrbotHelper;
@@ -100,7 +100,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
 
     public static AddEditKeyserverDialogFragment newInstance(Messenger messenger,
                                                              DialogAction action,
-                                                             ParcelableHkpKeyserver keyserver,
+                                                             HkpKeyserverAddress keyserver,
                                                              int position) {
         AddEditKeyserverDialogFragment frag = new AddEditKeyserverDialogFragment();
         Bundle args = new Bundle();
@@ -149,7 +149,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
             }
             case EDIT: {
                 alert.setTitle(R.string.edit_keyserver_dialog_title);
-                ParcelableHkpKeyserver keyserver = getArguments().getParcelable(ARG_KEYSERVER);
+                HkpKeyserverAddress keyserver = getArguments().getParcelable(ARG_KEYSERVER);
                 mKeyserverEditText.setText(keyserver.getUrl());
                 mKeyserverEditOnionText.setText(keyserver.getOnion());
                 break;
@@ -235,7 +235,8 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
                     String keyserverUrl = mKeyserverEditText.getText().toString();
                     String keyserverOnion = mKeyserverEditOnionText.getText() == null ? null
                             : mKeyserverEditOnionText.getText().toString();
-                    final ParcelableHkpKeyserver keyserver = new ParcelableHkpKeyserver(keyserverUrl, keyserverOnion);
+                    final HkpKeyserverAddress keyserver =
+                            HkpKeyserverAddress.createWithOnionProxy(keyserverUrl, keyserverOnion);
                     if (mVerifyKeyserverCheckBox.isChecked()) {
                         final ParcelableProxy proxy = Preferences.getPreferences(getActivity())
                                 .getParcelableProxy();
@@ -281,7 +282,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
         }
     }
 
-    public void keyserverEdited(ParcelableHkpKeyserver keyserver, boolean verified) {
+    public void keyserverEdited(HkpKeyserverAddress keyserver, boolean verified) {
         dismiss();
         Bundle data = new Bundle();
         data.putSerializable(MESSAGE_DIALOG_ACTION, mDialogAction);
@@ -326,11 +327,11 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
 
     }
 
-    public void verifyConnection(ParcelableHkpKeyserver keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
+    public void verifyConnection(HkpKeyserverAddress keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
 
-        new AsyncTask<ParcelableHkpKeyserver, Void, VerifyReturn>() {
+        new AsyncTask<HkpKeyserverAddress, Void, VerifyReturn>() {
             ProgressDialog mProgressDialog;
-            ParcelableHkpKeyserver mKeyserver;
+            HkpKeyserverAddress mKeyserver;
 
             @Override
             protected void onPreExecute() {
@@ -341,7 +342,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
             }
 
             @Override
-            protected VerifyReturn doInBackground(ParcelableHkpKeyserver... keyservers) {
+            protected VerifyReturn doInBackground(HkpKeyserverAddress... keyservers) {
                 mKeyserver = keyservers[0];
 
                 return verifyKeyserver(mKeyserver, proxy, onlyTrustedKeyserver);
@@ -359,7 +360,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
         }.execute(keyserver);
     }
 
-    private VerifyReturn verifyKeyserver(ParcelableHkpKeyserver keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
+    private VerifyReturn verifyKeyserver(HkpKeyserverAddress keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
         VerifyReturn reason = VerifyReturn.GOOD;
         try {
             URI keyserverUriHttp = keyserver.getUrlURI();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/keyview/ViewKeyActivity.java

@@ -69,7 +69,7 @@ import android.widget.Toast;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
 import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
@@ -144,7 +144,7 @@ public class ViewKeyActivity extends BaseSecurityTokenActivity implements
     protected Uri mDataUri;
 
     // For CryptoOperationHelper.Callback
-    private ParcelableHkpKeyserver mKeyserver;
+    private HkpKeyserverAddress mKeyserver;
     private ArrayList<ParcelableKeyRing> mKeyList;
     private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;
     private CryptoOperationHelper<ChangeUnlockParcel, EditKeyResult> mEditOpHelper;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/EmailKeyHelper.java

@@ -17,22 +17,30 @@
 
 package org.sufficientlysecure.keychain.util;
 
-import android.content.Context;
-
-import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
-import org.sufficientlysecure.keychain.keyimport.Keyserver;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
-import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
-import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
-import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
-import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Set;
 
+import android.content.Context;
+
+import de.measite.minidns.Client;
+import de.measite.minidns.Question;
+import de.measite.minidns.Record;
+import de.measite.minidns.record.SRV;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverClient;
+import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
+import org.sufficientlysecure.keychain.keyimport.KeyserverClient;
+import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
+import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
+import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
+import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
+
 public class EmailKeyHelper {
     // TODO: Make this not require a proxy in it's constructor, redesign when it is to be used
     // to import keys, simply use CryptoOperationHelper with this callback
@@ -40,15 +48,15 @@ public class EmailKeyHelper {
             implements CryptoOperationHelper.Callback<ImportKeyringParcel, ImportKeyResult> {
 
         private ArrayList<ParcelableKeyRing> mKeyList;
-        private ParcelableHkpKeyserver mKeyserver;
+        private HkpKeyserverAddress mKeyserver;
 
-        public ImportContactKeysCallback(Context context, ParcelableHkpKeyserver keyserver,
+        public ImportContactKeysCallback(Context context, HkpKeyserverAddress keyserver,
                                          ParcelableProxy proxy) {
             this(context, new ContactHelper(context).getContactMails(), keyserver, proxy);
         }
 
         public ImportContactKeysCallback(Context context, List<String> mails,
-                                         ParcelableHkpKeyserver keyserver, ParcelableProxy proxy) {
+                                         HkpKeyserverAddress keyserver, ParcelableProxy proxy) {
             Set<ImportKeysListEntry> entries = new HashSet<>();
             for (String mail : mails) {
                 entries.addAll(getEmailKeys(context, mail, proxy));
@@ -76,7 +84,7 @@ public class EmailKeyHelper {
         // Try _hkp._tcp SRV record first
         String[] mailparts = mail.split("@");
         if (mailparts.length == 2) {
-            ParcelableHkpKeyserver hkp = ParcelableHkpKeyserver.resolve(mailparts[1]);
+            HkpKeyserverAddress hkp = findKeyserverFromDns(mailparts[1]);
             if (hkp != null) {
                 keys.addAll(getEmailKeys(mail, hkp, proxy));
             }
@@ -84,7 +92,7 @@ public class EmailKeyHelper {
 
         if (keys.isEmpty()) {
             // Most users don't have the SRV record, so ask a default server as well
-            ParcelableHkpKeyserver server = Preferences.getPreferences(context).getPreferredKeyserver();
+            HkpKeyserverAddress server = Preferences.getPreferences(context).getPreferredKeyserver();
             if (server != null) {
                 keys.addAll(getEmailKeys(mail, server, proxy));
             }
@@ -92,11 +100,12 @@ public class EmailKeyHelper {
         return keys;
     }
 
-    public static List<ImportKeysListEntry> getEmailKeys(String mail, Keyserver keyServer,
+    public static List<ImportKeysListEntry> getEmailKeys(String mail, HkpKeyserverAddress keyServer,
                                                          ParcelableProxy proxy) {
         Set<ImportKeysListEntry> keys = new HashSet<>();
         try {
-            for (ImportKeysListEntry key : keyServer.search(mail, proxy)) {
+            for (ImportKeysListEntry key : HkpKeyserverClient
+                    .fromHkpKeyserverAddress(keyServer).search(mail, proxy)) {
                 if (key.isRevokedOrExpiredOrInsecure()) continue;
                 for (String userId : key.getUserIds()) {
                     if (userId.toLowerCase().contains(mail.toLowerCase(Locale.ENGLISH))) {
@@ -104,8 +113,31 @@ public class EmailKeyHelper {
                     }
                 }
             }
-        } catch (Keyserver.CloudSearchFailureException ignored) {
+        } catch (KeyserverClient.CloudSearchFailureException ignored) {
         }
         return new ArrayList<>(keys);
     }
+
+    public static HkpKeyserverAddress findKeyserverFromDns(String domain) {
+        try {
+            Record[] records = new Client().query(new Question("_hkp._tcp." + domain, Record.TYPE.SRV)).getAnswers();
+            if (records.length > 0) {
+                Arrays.sort(records, new Comparator<Record>() {
+                    @Override
+                    public int compare(Record lhs, Record rhs) {
+                        if (lhs.getPayload().getType() != Record.TYPE.SRV) return 1;
+                        if (rhs.getPayload().getType() != Record.TYPE.SRV) return -1;
+                        return ((SRV) lhs.getPayload()).getPriority() - ((SRV) rhs.getPayload()).getPriority();
+                    }
+                });
+                Record record = records[0]; // This is our best choice
+                if (record.getPayload().getType() == Record.TYPE.SRV) {
+                    SRV payload = (SRV) record.getPayload();
+                    return HkpKeyserverAddress.createFromUri(payload.getName() + ":" + payload.getPort());
+                }
+            }
+        } catch (Exception ignored) {
+        }
+        return null;
+    }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/Preferences.java

@@ -32,7 +32,7 @@ import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.Constants.Pref;
 import org.sufficientlysecure.keychain.KeychainApplication;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
 import org.sufficientlysecure.keychain.service.KeyserverSyncAdapterService;
 
 import java.io.Serializable;
@@ -128,13 +128,13 @@ public class Preferences {
         editor.commit();
     }
 
-    public ArrayList<ParcelableHkpKeyserver> getKeyServers() {
+    public ArrayList<HkpKeyserverAddress> getKeyServers() {
         String rawData = mSharedPreferences.getString(Constants.Pref.KEY_SERVERS,
                 Constants.Defaults.KEY_SERVERS);
         if ("".equals(rawData)) {
             return new ArrayList<>();
         }
-        ArrayList<ParcelableHkpKeyserver> servers = new ArrayList<>();
+        ArrayList<HkpKeyserverAddress> servers = new ArrayList<>();
         String[] entries = rawData.split(",");
         for (String entry : entries) {
             String[] addresses = entry.trim().split(";");
@@ -145,20 +145,20 @@ public class Preferences {
                 continue;
             }
 
-            servers.add(new ParcelableHkpKeyserver(url, onion));
+            servers.add(HkpKeyserverAddress.createWithOnionProxy(url, onion));
         }
         return servers;
     }
 
-    public ParcelableHkpKeyserver getPreferredKeyserver() {
+    public HkpKeyserverAddress getPreferredKeyserver() {
-        ArrayList<ParcelableHkpKeyserver> keyservers = getKeyServers();
+        ArrayList<HkpKeyserverAddress> keyservers = getKeyServers();
         return keyservers.size() == 0 ? null : keyservers.get(0);
     }
 
-    public void setKeyServers(ArrayList<ParcelableHkpKeyserver> keyservers) {
+    public void setKeyServers(ArrayList<HkpKeyserverAddress> keyservers) {
         SharedPreferences.Editor editor = mSharedPreferences.edit();
         String rawData = "";
-        for (ParcelableHkpKeyserver server : keyservers) {
+        for (HkpKeyserverAddress server : keyservers) {
             if (server.getUrl().isEmpty()) {
                 continue;
             }
@@ -381,7 +381,7 @@ public class Preferences {
         public final boolean searchKeyserver;
         public final boolean searchKeybase;
         public final boolean searchFacebook;
-        public final ParcelableHkpKeyserver keyserver;
+        public final HkpKeyserverAddress keyserver;
 
         /**
          * @param searchKeyserver should passed keyserver be searched
@@ -389,7 +389,7 @@ public class Preferences {
          * @param keyserver       the keyserver url authority to search on
          */
         public CloudSearchPrefs(boolean searchKeyserver, boolean searchKeybase,
-                                boolean searchFacebook, ParcelableHkpKeyserver keyserver) {
+                                boolean searchFacebook, HkpKeyserverAddress keyserver) {
             this.searchKeyserver = searchKeyserver;
             this.searchKeybase = searchKeybase;
             this.searchFacebook = searchFacebook;
@@ -400,7 +400,7 @@ public class Preferences {
             searchKeyserver = in.readByte() != 0x00;
             searchKeybase = in.readByte() != 0x00;
             searchFacebook = in.readByte() != 0x00;
-            keyserver = in.readParcelable(ParcelableHkpKeyserver.class.getClassLoader());
+            keyserver = in.readParcelable(HkpKeyserverAddress.class.getClassLoader());
         }
 
         @Override
@@ -467,22 +467,22 @@ public class Preferences {
                     // fall through
                 case 3: {
                     // migrate keyserver to hkps
-                    ArrayList<ParcelableHkpKeyserver> servers = getKeyServers();
+                    ArrayList<HkpKeyserverAddress> servers = getKeyServers();
-                    ListIterator<ParcelableHkpKeyserver> it = servers.listIterator();
+                    ListIterator<HkpKeyserverAddress> it = servers.listIterator();
                     while (it.hasNext()) {
-                        ParcelableHkpKeyserver server = it.next();
+                        HkpKeyserverAddress server = it.next();
                         if (server == null) {
                             continue;
                         }
                         switch (server.getUrl()) {
                             case "pool.sks-keyservers.net": {
                                 // use HKPS!
-                                it.set(new ParcelableHkpKeyserver("hkps://hkps.pool.sks-keyservers.net", null));
+                                it.set(HkpKeyserverAddress.createFromUri("hkps://hkps.pool.sks-keyservers.net"));
                                 break;
                             }
                             case "pgp.mit.edu": {
                                 // use HKPS!
-                                it.set(new ParcelableHkpKeyserver("hkps://pgp.mit.edu", null));
+                                it.set(HkpKeyserverAddress.createFromUri("hkps://pgp.mit.edu"));
                                 break;
                             }
                             case "subkeys.pgp.net": {
@@ -509,15 +509,15 @@ public class Preferences {
                 // fall through
                 case 7: {
                     // add onion address to sks-keyservers.net
-                    ArrayList<ParcelableHkpKeyserver> servers = getKeyServers();
+                    ArrayList<HkpKeyserverAddress> servers = getKeyServers();
-                    ListIterator<ParcelableHkpKeyserver> it = servers.listIterator();
+                    ListIterator<HkpKeyserverAddress> it = servers.listIterator();
                     while (it.hasNext()) {
-                        ParcelableHkpKeyserver server = it.next();
+                        HkpKeyserverAddress server = it.next();
                         if (server == null) {
                             continue;
                         }
                         if ("hkps://hkps.pool.sks-keyservers.net".equals(server.getUrl())) {
-                            it.set(new ParcelableHkpKeyserver(
+                            it.set(HkpKeyserverAddress.createWithOnionProxy(
                                     "hkps://hkps.pool.sks-keyservers.net",
                                     "hkp://jirk5u4osbsr34t5.onion"));
                         }