More javafication

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

app/src/main/java/com/wireguard/config/Attribute.java

@@ -3,6 +3,7 @@ package com.wireguard.config;
 import android.text.TextUtils;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -45,19 +46,23 @@ enum Attribute {
         return KEY_MAP.get(SEPARATOR_PATTERN.split(line)[0]);
     }
 
-    public static String listToString(final String[] list) {
+    public static <T> String listToString(final List<T> list) {
         return TextUtils.join(", ", list);
     }
 
     public static String[] stringToList(final String string) {
-        return string.trim().split("\\s*,\\s*");
+        return string.trim().split("\\s*,\\s*", -1);
     }
 
     public String composeWith(final Object value) {
         return String.format("%s = %s%n", token, value);
     }
 
-    public String composeWith(final String[] value) {
+    public String composeWith(final int value) {
+        return String.format("%s = %d%n", token, value);
+    }
+
+    public <T> String composeWith(final List<T> value) {
         return String.format("%s = %s%n", token, listToString(value));
     }
 

app/src/main/java/com/wireguard/config/IPCidr.java

@@ -0,0 +1,79 @@
+package com.wireguard.config;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class IPCidr implements Parcelable {
+    InetAddress address;
+    int cidr;
+
+
+    public static final Parcelable.Creator<IPCidr> CREATOR = new Parcelable.Creator<IPCidr>() {
+        @Override
+        public IPCidr createFromParcel(final Parcel in) {
+            return new IPCidr(in);
+        }
+
+        @Override
+        public IPCidr[] newArray(final int size) {
+            return new IPCidr[size];
+        }
+    };
+
+    public IPCidr(String in) throws UnknownHostException {
+        parse(in);
+    }
+
+    private void parse(String in) throws UnknownHostException {
+        cidr = -1;
+        int slash = in.lastIndexOf('/');
+        if (slash != -1 && slash < in.length() - 1) {
+            try {
+                cidr = Integer.parseInt(in.substring(slash + 1), 10);
+                in = in.substring(0, slash);
+            } catch (Exception e) {
+            }
+        }
+        address = InetAddress.getByName(in);
+        if ((address instanceof Inet6Address) && (cidr > 128 || cidr < 0))
+            cidr = 128;
+        else if ((address instanceof Inet4Address) && (cidr > 32 || cidr < 0))
+            cidr = 32;
+    }
+
+    public InetAddress getAddress() {
+        return address;
+    }
+
+    public int getCidr() {
+        return cidr;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s/%d", address.getHostAddress(), cidr);
+    }
+
+    @Override
+    public void writeToParcel(final Parcel dest, final int flags) {
+        dest.writeString(this.toString());
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    private IPCidr(final Parcel in) {
+        try {
+            parse(in.readString());
+        } catch (Exception e) {
+        }
+    }
+
+}

app/src/main/java/com/wireguard/config/Interface.java

@@ -9,6 +9,11 @@ import com.wireguard.android.BR;
 import com.wireguard.crypto.KeyEncoding;
 import com.wireguard.crypto.Keypair;
 
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  * Represents the configuration for a WireGuard interface (an [Interface] block).
  */
@@ -26,23 +31,30 @@ public class Interface extends BaseObservable implements Parcelable {
         }
     };
 
-    private String[] addressList;
-    private String[] dnsList;
+    private List<IPCidr> addressList;
+    private List<InetAddress> dnsList;
     private Keypair keypair;
-    private String listenPort;
-    private String mtu;
+    private int listenPort;
+    private int mtu;
     private String privateKey;
 
     public Interface() {
-        addressList = new String[0];
-        dnsList = new String[0];
+        addressList = new LinkedList<>();
+        dnsList = new LinkedList<>();
     }
 
     private Interface(final Parcel in) {
-        addressList = in.createStringArray();
-        dnsList = in.createStringArray();
-        listenPort = in.readString();
-        mtu = in.readString();
+        addressList = in.createTypedArrayList(IPCidr.CREATOR);
+        int dnsItems = in.readInt();
+        dnsList = new LinkedList<>();
+        for (int i = 0; i < dnsItems; ++i) {
+            try {
+                dnsList.add(InetAddress.getByAddress(in.createByteArray()));
+            } catch (Exception e) {
+            }
+        }
+        listenPort = in.readInt();
+        mtu = in.readInt();
         setPrivateKey(in.readString());
     }
 
@@ -60,34 +72,59 @@ public class Interface extends BaseObservable implements Parcelable {
 
     @Bindable
     public String getAddressString() {
+        if (addressList.isEmpty())
+            return null;
         return Attribute.listToString(addressList);
     }
 
     @Bindable
-    public String[] getAddresses() {
-        return addressList;
+    public IPCidr[] getAddresses() {
+        return addressList.toArray(new IPCidr[addressList.size()]);
+    }
+
+    public List<String> getDnsStrings() {
+        List<String> strings = new LinkedList<>();
+        for (final InetAddress addr : dnsList)
+            strings.add(addr.getHostAddress());
+        return strings;
     }
 
     @Bindable
     public String getDnsString() {
-        return Attribute.listToString(dnsList);
+        if (dnsList.isEmpty())
+            return null;
+        return Attribute.listToString(getDnsStrings());
     }
 
     @Bindable
-    public String[] getDnses() {
-        return dnsList;
+    public InetAddress[] getDnses() {
+        return dnsList.toArray(new InetAddress[dnsList.size()]);
     }
 
     @Bindable
-    public String getListenPort() {
+    public int getListenPort() {
         return listenPort;
     }
 
     @Bindable
-    public String getMtu() {
+    public String getListenPortString() {
+        if (listenPort == 0)
+            return null;
+        return new Integer(listenPort).toString();
+    }
+
+    @Bindable
+    public int getMtu() {
         return mtu;
     }
 
+    @Bindable
+    public String getMtuString() {
+        if (mtu == 0)
+            return null;
+        return new Integer(mtu).toString();
+    }
+
     @Bindable
     public String getPrivateKey() {
         return privateKey;
@@ -98,74 +135,90 @@ public class Interface extends BaseObservable implements Parcelable {
         return keypair != null ? keypair.getPublicKey() : null;
     }
 
-    public void parse(final String line) {
+    public void parse(final String line) throws UnknownHostException {
         final Attribute key = Attribute.match(line);
         if (key == Attribute.ADDRESS)
             addAddresses(key.parseList(line));
         else if (key == Attribute.DNS)
             addDnses(key.parseList(line));
         else if (key == Attribute.LISTEN_PORT)
-            setListenPort(key.parse(line));
+            setListenPortString(key.parse(line));
         else if (key == Attribute.MTU)
-            setMtu(key.parse(line));
+            setMtuString(key.parse(line));
         else if (key == Attribute.PRIVATE_KEY)
             setPrivateKey(key.parse(line));
         else
             throw new IllegalArgumentException(line);
     }
 
-    public void addAddresses(String[] addresses) {
-        if (addresses == null || addresses.length == 0)
-            return;
-        String[] both = new String[addresses.length + this.addressList.length];
-        System.arraycopy(this.addressList, 0, both, 0, this.addressList.length);
-        System.arraycopy(addresses, 0, both, this.addressList.length, addresses.length);
-        setAddresses(both);
-    }
-
-    public void setAddresses(String[] addresses) {
-        if (addresses == null)
-            addresses = new String[0];
-        this.addressList = addresses;
+    public void addAddresses(String[] addresses) throws UnknownHostException {
+        if (addresses != null && addresses.length > 0) {
+            for (final String addr : addresses) {
+                if (addr.isEmpty())
+                    throw new UnknownHostException("{empty}");
+                this.addressList.add(new IPCidr(addr));
+            }
+        }
         notifyPropertyChanged(BR.addresses);
+        notifyPropertyChanged(BR.addressString);
+
     }
 
-    public void setAddressString(String addressString) {
-        setAddresses(Attribute.stringToList(addressString));
+    public void setAddressString(final String addressString) {
+        this.addressList.clear();
+        try {
+            addAddresses(Attribute.stringToList(addressString));
+        } catch (Exception e) {
+            this.addressList.clear();
+        }
     }
 
-    public void addDnses(String[] dnses) {
-        if (dnses == null || dnses.length == 0)
-            return;
-        String[] both = new String[dnses.length + this.dnsList.length];
-        System.arraycopy(this.dnsList, 0, both, 0, this.dnsList.length);
-        System.arraycopy(dnses, 0, both, this.dnsList.length, dnses.length);
-        setDnses(both);
-    }
-
-    public void setDnses(String[] dnses) {
-        if (dnses == null)
-            dnses = new String[0];
-        this.dnsList = dnses;
+    public void addDnses(String[] dnses) throws UnknownHostException {
+        if (dnses != null && dnses.length > 0) {
+            for (final String dns : dnses) {
+                if (dns.isEmpty())
+                    throw new UnknownHostException("{empty}");
+                this.dnsList.add(InetAddress.getByName(dns));
+            }
+        }
         notifyPropertyChanged(BR.dnses);
+        notifyPropertyChanged(BR.dnsString);
+
     }
 
-    public void setDnsString(String dnsString) {
-        setDnses(Attribute.stringToList(dnsString));
+    public void setDnsString(final String dnsString) {
+        try {
+            this.dnsList.clear();
+            addDnses(Attribute.stringToList(dnsString));
+        } catch (Exception e) {
+            this.dnsList.clear();
+        }
     }
 
-    public void setListenPort(String listenPort) {
-        if (listenPort != null && listenPort.isEmpty())
-            listenPort = null;
+    public void setListenPort(int listenPort) {
         this.listenPort = listenPort;
         notifyPropertyChanged(BR.listenPort);
+        notifyPropertyChanged(BR.listenPortString);
     }
 
-    public void setMtu(String mtu) {
-        if (mtu != null && mtu.isEmpty())
-            mtu = null;
+    public void setListenPortString(final String port) {
+        if (port != null && !port.isEmpty())
+            setListenPort(Integer.parseInt(port, 10));
+        else
+            setListenPort(0);
+    }
+
+    public void setMtu(int mtu) {
         this.mtu = mtu;
         notifyPropertyChanged(BR.mtu);
+        notifyPropertyChanged(BR.mtuString);
+    }
+
+    public void setMtuString(final String mtu) {
+        if (mtu != null && !mtu.isEmpty())
+            setMtu(Integer.parseInt(mtu, 10));
+        else
+            setMtu(0);
     }
 
     public void setPrivateKey(String privateKey) {
@@ -188,13 +241,13 @@ public class Interface extends BaseObservable implements Parcelable {
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder().append("[Interface]\n");
-        if (addressList != null && addressList.length > 0)
+        if (!addressList.isEmpty())
             sb.append(Attribute.ADDRESS.composeWith(addressList));
-        if (dnsList != null && dnsList.length > 0)
-            sb.append(Attribute.DNS.composeWith(dnsList));
-        if (listenPort != null)
+        if (!dnsList.isEmpty())
+            sb.append(Attribute.DNS.composeWith(getDnsStrings()));
+        if (listenPort != 0)
             sb.append(Attribute.LISTEN_PORT.composeWith(listenPort));
-        if (mtu != null)
+        if (mtu != 0)
             sb.append(Attribute.MTU.composeWith(mtu));
         if (privateKey != null)
             sb.append(Attribute.PRIVATE_KEY.composeWith(privateKey));
@@ -203,10 +256,12 @@ public class Interface extends BaseObservable implements Parcelable {
 
     @Override
     public void writeToParcel(final Parcel dest, final int flags) {
-        dest.writeStringArray(addressList);
-        dest.writeStringArray(dnsList);
-        dest.writeString(listenPort);
-        dest.writeString(mtu);
+        dest.writeTypedList(addressList);
+        dest.writeInt(dnsList.size());
+        for (final InetAddress addr : dnsList)
+            dest.writeByteArray(addr.getAddress());
+        dest.writeInt(listenPort);
+        dest.writeInt(mtu);
         dest.writeString(privateKey);
     }
 }

app/src/main/java/com/wireguard/config/Peer.java

@@ -7,6 +7,14 @@ import android.os.Parcelable;
 
 import com.android.databinding.library.baseAdapters.BR;
 
+import java.net.Inet6Address;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.UnknownHostException;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  * Represents the configuration for a WireGuard peer (a [Peer] block).
  */
@@ -24,22 +32,29 @@ public class Peer extends BaseObservable implements Parcelable {
         }
     };
 
-    private String[] allowedIPList;
-    private String endpoint;
-    private String persistentKeepalive;
+    private List<IPCidr> allowedIPsList;
+    private InetSocketAddress endpoint;
+    private int persistentKeepalive;
     private String preSharedKey;
     private String publicKey;
 
     public Peer() {
-        allowedIPList = new String[0];
+        allowedIPsList = new LinkedList<>();
     }
 
     private Peer(final Parcel in) {
-        allowedIPList = in.createStringArray();
-        endpoint = in.readString();
-        persistentKeepalive = in.readString();
+        allowedIPsList = in.createTypedArrayList(IPCidr.CREATOR);
+        String host = in.readString();
+        int port = in.readInt();
+        if (host != null && !host.isEmpty() && port > 0)
+            endpoint = InetSocketAddress.createUnresolved(host, port);
+        persistentKeepalive = in.readInt();
         preSharedKey = in.readString();
+        if (preSharedKey != null && preSharedKey.isEmpty())
+            preSharedKey = null;
         publicKey = in.readString();
+        if (publicKey != null && publicKey.isEmpty())
+            publicKey = null;
     }
 
     public static Peer newInstance() {
@@ -53,23 +68,53 @@ public class Peer extends BaseObservable implements Parcelable {
 
 
     @Bindable
-    public String getAllowedIPsString() { return Attribute.listToString(allowedIPList); }
-
-    @Bindable
-    public String[] getAllowedIPs() {
-        return allowedIPList;
+    public String getAllowedIPsString() {
+        if (allowedIPsList.isEmpty())
+            return null;
+        return Attribute.listToString(allowedIPsList);
     }
 
     @Bindable
-    public String getEndpoint() {
+    public IPCidr[] getAllowedIPs() {
+        return allowedIPsList.toArray(new IPCidr[allowedIPsList.size()]);
+    }
+
+    @Bindable
+    public InetSocketAddress getEndpoint() {
         return endpoint;
     }
 
     @Bindable
-    public String getPersistentKeepalive() {
+    public String getEndpointString() {
+        if (endpoint == null)
+            return null;
+        return String.format("%s:%d", endpoint.getHostString(), endpoint.getPort());
+    }
+
+    public String getResolvedEndpointString() throws UnknownHostException {
+        if (endpoint == null)
+            throw new UnknownHostException("{empty}");
+        if (endpoint.isUnresolved())
+            endpoint = new InetSocketAddress(endpoint.getHostString(), endpoint.getPort());
+        if (endpoint.isUnresolved())
+            throw new UnknownHostException(endpoint.getHostString());
+        if (endpoint.getAddress() instanceof Inet6Address)
+            return String.format("[%s]:%d", endpoint.getAddress().getHostAddress(), endpoint.getPort());
+        return String.format("%s:%d",  endpoint.getAddress().getHostAddress(), endpoint.getPort());
+    }
+
+    @Bindable
+    public int getPersistentKeepalive() {
         return persistentKeepalive;
     }
 
+    @Bindable
+    public String getPersistentKeepaliveString() {
+        if (persistentKeepalive == 0)
+            return null;
+        return new Integer(persistentKeepalive).toString();
+    }
+
     @Bindable
     public String getPreSharedKey() {
         return preSharedKey;
@@ -80,14 +125,14 @@ public class Peer extends BaseObservable implements Parcelable {
         return publicKey;
     }
 
-    public void parse(final String line) {
+    public void parse(final String line) throws UnknownHostException {
         final Attribute key = Attribute.match(line);
         if (key == Attribute.ALLOWED_IPS)
             addAllowedIPs(key.parseList(line));
         else if (key == Attribute.ENDPOINT)
-            setEndpoint(key.parse(line));
+            setEndpointString(key.parse(line));
         else if (key == Attribute.PERSISTENT_KEEPALIVE)
-            setPersistentKeepalive(key.parse(line));
+            setPersistentKeepaliveString(key.parse(line));
         else if (key == Attribute.PRESHARED_KEY)
             setPreSharedKey(key.parse(line));
         else if (key == Attribute.PUBLIC_KEY)
@@ -96,38 +141,60 @@ public class Peer extends BaseObservable implements Parcelable {
             throw new IllegalArgumentException(line);
     }
 
-    public void addAllowedIPs(String[] allowedIPs) {
-        if (allowedIPs == null || allowedIPs.length == 0)
-            return;
-        String[] both = new String[allowedIPs.length + this.allowedIPList.length];
-        System.arraycopy(this.allowedIPList, 0, both, 0, this.allowedIPList.length);
-        System.arraycopy(allowedIPs, 0, both, this.allowedIPList.length, allowedIPs.length);
-        setAllowedIPs(both);
-    }
-
-    public void setAllowedIPs(String[] allowedIPs) {
-        if (allowedIPs == null)
-            allowedIPs = new String[0];
-        this.allowedIPList = allowedIPs;
+    public void addAllowedIPs(String[] allowedIPs) throws UnknownHostException {
+        if (allowedIPs != null && allowedIPs.length > 0) {
+            for (final String allowedIP : allowedIPs) {
+                if (allowedIP.isEmpty())
+                    throw new UnknownHostException("{empty}");
+                this.allowedIPsList.add(new IPCidr(allowedIP));
+            }
+        }
         notifyPropertyChanged(BR.allowedIPs);
+        notifyPropertyChanged(BR.allowedIPsString);
     }
 
-    public void setAllowedIPsString(String allowedIPsString) {
-        setAllowedIPs(Attribute.stringToList(allowedIPsString));
+    public void setAllowedIPsString(final String allowedIPsString) {
+        try {
+            this.allowedIPsList.clear();
+            addAllowedIPs(Attribute.stringToList(allowedIPsString));
+        } catch (Exception e) {
+            this.allowedIPsList.clear();
+        }
     }
 
-    public void setEndpoint(String endpoint) {
-        if (endpoint != null && endpoint.isEmpty())
-            endpoint = null;
+    public void setEndpoint(InetSocketAddress endpoint) {
         this.endpoint = endpoint;
         notifyPropertyChanged(BR.endpoint);
+        notifyPropertyChanged(BR.endpointString);
     }
 
-    public void setPersistentKeepalive(String persistentKeepalive) {
-        if (persistentKeepalive != null && persistentKeepalive.isEmpty())
-            persistentKeepalive = null;
+    public void setEndpointString(final String endpoint) {
+        if (endpoint != null && !endpoint.isEmpty()) {
+            InetSocketAddress constructedEndpoint;
+            try {
+                if (endpoint.indexOf('/') != -1 || endpoint.indexOf('?') != -1 || endpoint.indexOf('#') != -1)
+                    throw new Exception();
+                URI uri = new URI("wg://" + endpoint);
+                constructedEndpoint = InetSocketAddress.createUnresolved(uri.getHost(), uri.getPort());
+            } catch (Exception e) {
+                return; /* XXX: Uh oh. */
+            }
+            setEndpoint(constructedEndpoint);
+        } else
+            setEndpoint(null);
+    }
+
+    public void setPersistentKeepalive(int persistentKeepalive) {
         this.persistentKeepalive = persistentKeepalive;
         notifyPropertyChanged(BR.persistentKeepalive);
+        notifyPropertyChanged(BR.persistentKeepaliveString);
+    }
+
+    public void setPersistentKeepaliveString(String persistentKeepalive) {
+        if (persistentKeepalive != null && !persistentKeepalive.isEmpty())
+            setPersistentKeepalive(Integer.parseInt(persistentKeepalive, 10));
+        else
+            setPersistentKeepalive(0);
     }
 
     public void setPreSharedKey(String preSharedKey) {
@@ -147,11 +214,11 @@ public class Peer extends BaseObservable implements Parcelable {
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder().append("[Peer]\n");
-        if (allowedIPList != null)
-            sb.append(Attribute.ALLOWED_IPS.composeWith(allowedIPList));
+        if (!allowedIPsList.isEmpty())
+            sb.append(Attribute.ALLOWED_IPS.composeWith(allowedIPsList));
         if (endpoint != null)
-            sb.append(Attribute.ENDPOINT.composeWith(endpoint));
-        if (persistentKeepalive != null)
+            sb.append(Attribute.ENDPOINT.composeWith(getEndpointString()));
+        if (persistentKeepalive != 0)
             sb.append(Attribute.PERSISTENT_KEEPALIVE.composeWith(persistentKeepalive));
         if (preSharedKey != null)
             sb.append(Attribute.PRESHARED_KEY.composeWith(preSharedKey));
@@ -162,9 +229,10 @@ public class Peer extends BaseObservable implements Parcelable {
 
     @Override
     public void writeToParcel(final Parcel dest, final int flags) {
-        dest.writeStringArray(allowedIPList);
-        dest.writeString(endpoint);
-        dest.writeString(persistentKeepalive);
+        dest.writeTypedList(allowedIPsList);
+        dest.writeString(endpoint == null ? null : endpoint.getHostString());
+        dest.writeInt(endpoint == null ? 0 : endpoint.getPort());
+        dest.writeInt(persistentKeepalive);
         dest.writeString(preSharedKey);
         dest.writeString(publicKey);
     }