core/java/android/net/LinkProperties.java

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.net;
  18
  19 import android.net.ProxyProperties;
  20 import android.os.Parcelable;
  21 import android.os.Parcel;
  22 import android.text.TextUtils;
  23
  24 import java.net.InetAddress;
  25 import java.net.UnknownHostException;
  26 import java.util.ArrayList;
  27 import java.util.Collection;
  28 import java.util.Collections;
  29
  30 /**
  31  * Describes the properties of a network link.
  32  *
  33  * A link represents a connection to a network.
  34  * It may have multiple addresses and multiple gateways,
  35  * multiple dns servers but only one http proxy.
  36  *
  37  * Because it's a single network, the dns's
  38  * are interchangeable and don't need associating with
  39  * particular addresses.  The gateways similarly don't
  40  * need associating with particular addresses.
  41  *
  42  * A dual stack interface works fine in this model:
  43  * each address has it's own prefix length to describe
  44  * the local network.  The dns servers all return
  45  * both v4 addresses and v6 addresses regardless of the
  46  * address family of the server itself (rfc4213) and we
  47  * don't care which is used.  The gateways will be
  48  * selected based on the destination address and the
  49  * source address has no relavence.
  50  * @hide
  51  */
  52 public class LinkProperties implements Parcelable {
  53
  54     String mIfaceName;
  55     private Collection<LinkAddress> mLinkAddresses = new ArrayList<LinkAddress>();
  56     private Collection<InetAddress> mDnses = new ArrayList<InetAddress>();
  57     private Collection<RouteInfo> mRoutes = new ArrayList<RouteInfo>();
  58     private ProxyProperties mHttpProxy;
  59
  60     public static class CompareResult<T> {
  61         public Collection<T> removed = new ArrayList<T>();
  62         public Collection<T> added = new ArrayList<T>();
  63
  64         @Override
  65         public String toString() {
  66             String retVal = "removed=[";
  67             for (T addr : removed) retVal += addr.toString() + ",";
  68             retVal += "] added=[";
  69             for (T addr : added) retVal += addr.toString() + ",";
  70             retVal += "]";
  71             return retVal;
  72         }
  73     }
  74
  75     public LinkProperties() {
  76         clear();
  77     }
  78
  79     // copy constructor instead of clone
  80     public LinkProperties(LinkProperties source) {
  81         if (source != null) {
  82             mIfaceName = source.getInterfaceName();
  83             for (LinkAddress l : source.getLinkAddresses()) mLinkAddresses.add(l);
  84             for (InetAddress i : source.getDnses()) mDnses.add(i);
  85             for (RouteInfo r : source.getRoutes()) mRoutes.add(r);
  86             mHttpProxy = (source.getHttpProxy() == null)  ?
  87                 null : new ProxyProperties(source.getHttpProxy());
  88         }
  89     }
  90
  91     public void setInterfaceName(String iface) {
  92         mIfaceName = iface;
  93     }
  94
  95     public String getInterfaceName() {
  96         return mIfaceName;
  97     }
  98
  99     public Collection<InetAddress> getAddresses() {
 100         Collection<InetAddress> addresses = new ArrayList<InetAddress>();
 101         for (LinkAddress linkAddress : mLinkAddresses) {
 102             addresses.add(linkAddress.getAddress());
 103         }
 104         return Collections.unmodifiableCollection(addresses);
 105     }
 106
 107     public void addLinkAddress(LinkAddress address) {
 108         if (address != null) mLinkAddresses.add(address);
 109     }
 110
 111     public Collection<LinkAddress> getLinkAddresses() {
 112         return Collections.unmodifiableCollection(mLinkAddresses);
 113     }
 114
 115     public void addDns(InetAddress dns) {
 116         if (dns != null) mDnses.add(dns);
 117     }
 118
 119     public Collection<InetAddress> getDnses() {
 120         return Collections.unmodifiableCollection(mDnses);
 121     }
 122
 123     public void addRoute(RouteInfo route) {
 124         if (route != null) mRoutes.add(route);
 125     }
 126     public Collection<RouteInfo> getRoutes() {
 127         return Collections.unmodifiableCollection(mRoutes);
 128     }
 129
 130     public void setHttpProxy(ProxyProperties proxy) {
 131         mHttpProxy = proxy;
 132     }
 133     public ProxyProperties getHttpProxy() {
 134         return mHttpProxy;
 135     }
 136
 137     public void clear() {
 138         mIfaceName = null;
 139         mLinkAddresses.clear();
 140         mDnses.clear();
 141         mRoutes.clear();
 142         mHttpProxy = null;
 143     }
 144
 145     /**
 146      * Implement the Parcelable interface
 147      * @hide
 148      */
 149     public int describeContents() {
 150         return 0;
 151     }
 152
 153     @Override
 154     public String toString() {
 155         String ifaceName = (mIfaceName == null ? "" : "InterfaceName: " + mIfaceName + " ");
 156
 157         String linkAddresses = "LinkAddresses: [";
 158         for (LinkAddress addr : mLinkAddresses) linkAddresses += addr.toString() + ",";
 159         linkAddresses += "] ";
 160
 161         String dns = "DnsAddresses: [";
 162         for (InetAddress addr : mDnses) dns += addr.getHostAddress() + ",";
 163         dns += "] ";
 164
 165         String routes = "Routes: [";
 166         for (RouteInfo route : mRoutes) routes += route.toString() + ",";
 167         routes += "] ";
 168         String proxy = (mHttpProxy == null ? "" : "HttpProxy: " + mHttpProxy.toString() + " ");
 169
 170         return ifaceName + linkAddresses + routes + dns + proxy;
 171     }
 172
 173     /**
 174      * Compares this {@code LinkProperties} interface name against the target
 175      *
 176      * @param target LinkProperties to compare.
 177      * @return {@code true} if both are identical, {@code false} otherwise.
 178      */
 179     public boolean isIdenticalInterfaceName(LinkProperties target) {
 180         return TextUtils.equals(getInterfaceName(), target.getInterfaceName());
 181     }
 182
 183     /**
 184      * Compares this {@code LinkProperties} interface name against the target
 185      *
 186      * @param target LinkProperties to compare.
 187      * @return {@code true} if both are identical, {@code false} otherwise.
 188      */
 189     public boolean isIdenticalAddresses(LinkProperties target) {
 190         Collection<InetAddress> targetAddresses = target.getAddresses();
 191         Collection<InetAddress> sourceAddresses = getAddresses();
 192         return (sourceAddresses.size() == targetAddresses.size()) ?
 193                     sourceAddresses.containsAll(targetAddresses) : false;
 194     }
 195
 196     /**
 197      * Compares this {@code LinkProperties} DNS addresses against the target
 198      *
 199      * @param target LinkProperties to compare.
 200      * @return {@code true} if both are identical, {@code false} otherwise.
 201      */
 202     public boolean isIdenticalDnses(LinkProperties target) {
 203         Collection<InetAddress> targetDnses = target.getDnses();
 204         return (mDnses.size() == targetDnses.size()) ?
 205                     mDnses.containsAll(targetDnses) : false;
 206     }
 207
 208     /**
 209      * Compares this {@code LinkProperties} Routes against the target
 210      *
 211      * @param target LinkProperties to compare.
 212      * @return {@code true} if both are identical, {@code false} otherwise.
 213      */
 214     public boolean isIdenticalRoutes(LinkProperties target) {
 215         Collection<RouteInfo> targetRoutes = target.getRoutes();
 216         return (mRoutes.size() == targetRoutes.size()) ?
 217                     mRoutes.containsAll(targetRoutes) : false;
 218     }
 219
 220     /**
 221      * Compares this {@code LinkProperties} HttpProxy against the target
 222      *
 223      * @param target LinkProperties to compare.
 224      * @return {@code true} if both are identical, {@code false} otherwise.
 225      */
 226     public boolean isIdenticalHttpProxy(LinkProperties target) {
 227         return getHttpProxy() == null ? target.getHttpProxy() == null :
 228                     getHttpProxy().equals(target.getHttpProxy());
 229     }
 230
 231     @Override
 232     /**
 233      * Compares this {@code LinkProperties} instance against the target
 234      * LinkProperties in {@code obj}. Two LinkPropertieses are equal if
 235      * all their fields are equal in values.
 236      *
 237      * For collection fields, such as mDnses, containsAll() is used to check
 238      * if two collections contains the same elements, independent of order.
 239      * There are two thoughts regarding containsAll()
 240      * 1. Duplicated elements. eg, (A, B, B) and (A, A, B) are equal.
 241      * 2. Worst case performance is O(n^2).
 242      *
 243      * @param obj the object to be tested for equality.
 244      * @return {@code true} if both objects are equal, {@code false} otherwise.
 245      */
 246     public boolean equals(Object obj) {
 247         if (this == obj) return true;
 248
 249         if (!(obj instanceof LinkProperties)) return false;
 250
 251         LinkProperties target = (LinkProperties) obj;
 252
 253         return isIdenticalInterfaceName(target) &&
 254                 isIdenticalAddresses(target) &&
 255                 isIdenticalDnses(target) &&
 256                 isIdenticalRoutes(target) &&
 257                 isIdenticalHttpProxy(target);
 258     }
 259
 260     /**
 261      * Return two lists, a list of addresses that would be removed from
 262      * mLinkAddresses and a list of addresses that would be added to
 263      * mLinkAddress which would then result in target and mLinkAddresses
 264      * being the same list.
 265      *
 266      * @param target is a LinkProperties with the new list of addresses
 267      * @return the removed and added lists.
 268      */
 269     public CompareResult<LinkAddress> compareAddresses(LinkProperties target) {
 270         /*
 271          * Duplicate the LinkAddresses into removed, we will be removing
 272          * address which are common between mLinkAddresses and target
 273          * leaving the addresses that are different. And address which
 274          * are in target but not in mLinkAddresses are placed in the
 275          * addedAddresses.
 276          */
 277         CompareResult<LinkAddress> result = new CompareResult<LinkAddress>();
 278         result.removed = new ArrayList<LinkAddress>(mLinkAddresses);
 279         result.added.clear();
 280         if (target != null) {
 281             for (LinkAddress newAddress : target.getLinkAddresses()) {
 282                 if (! result.removed.remove(newAddress)) {
 283                     result.added.add(newAddress);
 284                 }
 285             }
 286         }
 287         return result;
 288     }
 289
 290     /**
 291      * Return two lists, a list of dns addresses that would be removed from
 292      * mDnses and a list of addresses that would be added to
 293      * mDnses which would then result in target and mDnses
 294      * being the same list.
 295      *
 296      * @param target is a LinkProperties with the new list of dns addresses
 297      * @return the removed and added lists.
 298      */
 299     public CompareResult<InetAddress> compareDnses(LinkProperties target) {
 300         /*
 301          * Duplicate the InetAddresses into removed, we will be removing
 302          * dns address which are common between mDnses and target
 303          * leaving the addresses that are different. And dns address which
 304          * are in target but not in mDnses are placed in the
 305          * addedAddresses.
 306          */
 307         CompareResult<InetAddress> result = new CompareResult<InetAddress>();
 308
 309         result.removed = new ArrayList<InetAddress>(mDnses);
 310         result.added.clear();
 311         if (target != null) {
 312             for (InetAddress newAddress : target.getDnses()) {
 313                 if (! result.removed.remove(newAddress)) {
 314                     result.added.add(newAddress);
 315                 }
 316             }
 317         }
 318         return result;
 319     }
 320
 321     /**
 322      * Return two lists, a list of routes that would be removed from
 323      * mRoutes and a list of routes that would be added to
 324      * mRoutes which would then result in target and mRoutes
 325      * being the same list.
 326      *
 327      * @param target is a LinkProperties with the new list of routes
 328      * @return the removed and added lists.
 329      */
 330     public CompareResult<RouteInfo> compareRoutes(LinkProperties target) {
 331         /*
 332          * Duplicate the RouteInfos into removed, we will be removing
 333          * routes which are common between mDnses and target
 334          * leaving the routes that are different. And route address which
 335          * are in target but not in mRoutes are placed in added.
 336          */
 337         CompareResult<RouteInfo> result = new CompareResult<RouteInfo>();
 338
 339         result.removed = new ArrayList<RouteInfo>(mRoutes);
 340         result.added.clear();
 341         if (target != null) {
 342             for (RouteInfo r : target.getRoutes()) {
 343                 if (! result.removed.remove(r)) {
 344                     result.added.add(r);
 345                 }
 346             }
 347         }
 348         return result;
 349     }
 350
 351
 352     @Override
 353     /**
 354      * generate hashcode based on significant fields
 355      * Equal objects must produce the same hash code, while unequal objects
 356      * may have the same hash codes.
 357      */
 358     public int hashCode() {
 359         return ((null == mIfaceName) ? 0 : mIfaceName.hashCode()
 360                 + mLinkAddresses.size() * 31
 361                 + mDnses.size() * 37
 362                 + mRoutes.size() * 41
 363                 + ((null == mHttpProxy) ? 0 : mHttpProxy.hashCode()));
 364     }
 365
 366     /**
 367      * Implement the Parcelable interface.
 368      * @hide
 369      */
 370     public void writeToParcel(Parcel dest, int flags) {
 371         dest.writeString(getInterfaceName());
 372         dest.writeInt(mLinkAddresses.size());
 373         for(LinkAddress linkAddress : mLinkAddresses) {
 374             dest.writeParcelable(linkAddress, flags);
 375         }
 376
 377         dest.writeInt(mDnses.size());
 378         for(InetAddress d : mDnses) {
 379             dest.writeByteArray(d.getAddress());
 380         }
 381
 382         dest.writeInt(mRoutes.size());
 383         for(RouteInfo route : mRoutes) {
 384             dest.writeParcelable(route, flags);
 385         }
 386
 387         if (mHttpProxy != null) {
 388             dest.writeByte((byte)1);
 389             dest.writeParcelable(mHttpProxy, flags);
 390         } else {
 391             dest.writeByte((byte)0);
 392         }
 393     }
 394
 395     /**
 396      * Implement the Parcelable interface.
 397      * @hide
 398      */
 399     public static final Creator<LinkProperties> CREATOR =
 400         new Creator<LinkProperties>() {
 401             public LinkProperties createFromParcel(Parcel in) {
 402                 LinkProperties netProp = new LinkProperties();
 403                 String iface = in.readString();
 404                 if (iface != null) {
 405                     try {
 406                         netProp.setInterfaceName(iface);
 407                     } catch (Exception e) {
 408                         return null;
 409                     }
 410                 }
 411                 int addressCount = in.readInt();
 412                 for (int i=0; i<addressCount; i++) {
 413                     netProp.addLinkAddress((LinkAddress)in.readParcelable(null));
 414                 }
 415                 addressCount = in.readInt();
 416                 for (int i=0; i<addressCount; i++) {
 417                     try {
 418                         netProp.addDns(InetAddress.getByAddress(in.createByteArray()));
 419                     } catch (UnknownHostException e) { }
 420                 }
 421                 addressCount = in.readInt();
 422                 for (int i=0; i<addressCount; i++) {
 423                     netProp.addRoute((RouteInfo)in.readParcelable(null));
 424                 }
 425                 if (in.readByte() == 1) {
 426                     netProp.setHttpProxy((ProxyProperties)in.readParcelable(null));
 427                 }
 428                 return netProp;
 429             }
 430
 431             public LinkProperties[] newArray(int size) {
 432                 return new LinkProperties[size];
 433             }
 434         };
 435 }