android.net.LinkProperties Java Examples

private String findLocalIp1(){
    ConnectivityManager connMgr = (ConnectivityManager) IApplication.get_context().getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && connMgr != null) {
        LinkProperties linkProperties;
        String ipAddress = null;
        linkProperties = getLinkProperties(connMgr, NetworkCapabilities.TRANSPORT_VPN);
        if (linkProperties == null)
            linkProperties = getLinkProperties(connMgr, NetworkCapabilities.TRANSPORT_ETHERNET);
        if (linkProperties == null)
            linkProperties = getLinkProperties(connMgr, NetworkCapabilities.TRANSPORT_WIFI);
        if (linkProperties != null)
            ipAddress =  getIp(linkProperties);
        if (ipAddress != null)
            return ipAddress;
    }
    return null;
}
 

public NetworkAgentInfo(Messenger messenger, AsyncChannel ac, Network net, NetworkInfo info,
        LinkProperties lp, NetworkCapabilities nc, int score, Context context, Handler handler,
        NetworkMisc misc, NetworkRequest defaultRequest, ConnectivityService connService) {
    this.messenger = messenger;
    asyncChannel = ac;
    network = net;
    networkInfo = info;
    linkProperties = lp;
    networkCapabilities = nc;
    currentScore = score;
    mConnService = connService;
    mContext = context;
    mHandler = handler;
    networkMonitor = mConnService.createNetworkMonitor(context, handler, this, defaultRequest);
    networkMisc = misc;
}
 

private void broadcastPreciseDataConnectionStateChanged(int state, int networkType,
        String apnType, String apn, String reason, LinkProperties linkProperties,
        String failCause) {
    Intent intent = new Intent(TelephonyManager.ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED);
    intent.putExtra(PhoneConstants.STATE_KEY, state);
    intent.putExtra(PhoneConstants.DATA_NETWORK_TYPE_KEY, networkType);
    if (reason != null) intent.putExtra(PhoneConstants.STATE_CHANGE_REASON_KEY, reason);
    if (apnType != null) intent.putExtra(PhoneConstants.DATA_APN_TYPE_KEY, apnType);
    if (apn != null) intent.putExtra(PhoneConstants.DATA_APN_KEY, apn);
    if (linkProperties != null) {
        intent.putExtra(PhoneConstants.DATA_LINK_PROPERTIES_KEY,linkProperties);
    }
    if (failCause != null) intent.putExtra(PhoneConstants.DATA_FAILURE_CAUSE_KEY, failCause);

    mContext.sendBroadcastAsUser(intent, UserHandle.ALL,
            android.Manifest.permission.READ_PRECISE_PHONE_STATE);
}
 

public void dump(IndentingPrintWriter pw) {
    if (isOffloadDisabled()) {
        pw.println("Offload disabled");
        return;
    }
    final boolean isStarted = started();
    pw.println("Offload HALs " + (isStarted ? "started" : "not started"));
    LinkProperties lp = mUpstreamLinkProperties;
    String upstream = (lp != null) ? lp.getInterfaceName() : null;
    pw.println("Current upstream: " + upstream);
    pw.println("Exempt prefixes: " + mLastLocalPrefixStrs);
    pw.println("NAT timeout update callbacks received during the "
            + (isStarted ? "current" : "last")
            + " offload session: "
            + mNatUpdateCallbacksReceived);
    pw.println("NAT timeout update netlink errors during the "
            + (isStarted ? "current" : "last")
            + " offload session: "
            + mNatUpdateNetlinkErrors);
}
 

private void initializeApi26Nameservers() throws InitializationException {
  if (context == null) {
    throw new InitializationException("Context must be initialized by calling setContext");
  }

  ConnectivityManager cm = context.getSystemService(ConnectivityManager.class);
  Network network = cm.getActiveNetwork();
  if (network == null) {
    // if the device is offline, there's no active network
    return;
  }

  LinkProperties lp = cm.getLinkProperties(network);
  if (lp == null) {
    // can be null for an unknown network, which may happen if networks change
    return;
  }

  for (InetAddress address : lp.getDnsServers()) {
    addNameserver(new InetSocketAddress(address, SimpleResolver.DEFAULT_PORT));
  }

  parseSearchPathList(lp.getDomains(), ",");
}
 

private void notifyLinkPropertiesChanged(String iface, TetherInterfaceStateMachine who,
                                         LinkProperties newLp) {
    final int state;
    synchronized (mPublicSync) {
        final TetherState tetherState = mTetherStates.get(iface);
        if (tetherState != null && tetherState.stateMachine.equals(who)) {
            state = tetherState.lastState;
        } else {
            mLog.log("got notification from stale iface " + iface);
            return;
        }
    }

    mLog.log(String.format(
            "OBSERVED LinkProperties update iface=%s state=%s lp=%s",
            iface, IControlsTethering.getStateString(state), newLp));
    final int which = TetherMasterSM.EVENT_IFACE_UPDATE_LINKPROPERTIES;
    mTetherMasterSM.sendMessage(which, state, 0, newLp);
}
 

@TargetApi(Build.VERSION_CODES.M)
@CalledByNative
private static byte[][] getDnsServers() {
    ConnectivityManager connectivityManager =
            (ConnectivityManager) ContextUtils.getApplicationContext().getSystemService(
                    Context.CONNECTIVITY_SERVICE);
    if (connectivityManager == null) {
        return new byte[0][0];
    }
    Network network = connectivityManager.getActiveNetwork();
    if (network == null) {
        return new byte[0][0];
    }
    LinkProperties linkProperties = connectivityManager.getLinkProperties(network);
    if (linkProperties == null) {
        return new byte[0][0];
    }
    List<InetAddress> dnsServersList = linkProperties.getDnsServers();
    byte[][] dnsServers = new byte[dnsServersList.size()][];
    for (int i = 0; i < dnsServersList.size(); i++) {
        dnsServers[i] = dnsServersList.get(i).getAddress();
    }
    return dnsServers;
}
 

private void setUpstreamNetworkState(NetworkState ns) {
    if (ns == null) {
        mUpstreamNetworkState = null;
    } else {
        // Make a deep copy of the parts we need.
        mUpstreamNetworkState = new NetworkState(
                null,
                new LinkProperties(ns.linkProperties),
                new NetworkCapabilities(ns.networkCapabilities),
                new Network(ns.network),
                null,
                null);
    }

    mLog.log("setUpstreamNetworkState: " + toDebugString(mUpstreamNetworkState));
}
 

private static String[] readDnsServersFromConnectionManager(Context context) {
    LinkedList<String> dnsServers = new LinkedList<>();
    if (Build.VERSION.SDK_INT >= 21 && context != null) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(context.CONNECTIVITY_SERVICE);
        if (connectivityManager != null) {
            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
            for (Network network : connectivityManager.getAllNetworks()) {
                NetworkInfo networkInfo = connectivityManager.getNetworkInfo(network);
                if (networkInfo.getType() == activeNetworkInfo.getType()) {
                    LinkProperties lp = connectivityManager.getLinkProperties(network);
                    for (InetAddress addr : lp.getDnsServers()) {
                        dnsServers.add(addr.getHostAddress());
                    }
                }
            }
        }
    }
    return dnsServers.isEmpty() ? new String[0] : dnsServers.toArray(new String[dnsServers.size()]);
}
 

public void updatePrivateDnsStatus(int netId, LinkProperties lp) {
    // Use the PrivateDnsConfig data pushed to this class instance
    // from ConnectivityService.
    final PrivateDnsConfig privateDnsCfg = mPrivateDnsMap.getOrDefault(netId,
            PRIVATE_DNS_OFF);

    final boolean useTls = privateDnsCfg.useTls;
    final PrivateDnsValidationStatuses statuses =
            useTls ? mPrivateDnsValidationMap.get(netId) : null;
    final boolean validated = (null != statuses) && statuses.hasValidatedServer();
    final boolean strictMode = privateDnsCfg.inStrictMode();
    final String tlsHostname = strictMode ? privateDnsCfg.hostname : null;
    final boolean usingPrivateDns = strictMode || validated;

    lp.setUsePrivateDns(usingPrivateDns);
    lp.setPrivateDnsServerName(tlsHostname);
    if (usingPrivateDns && null != statuses) {
        statuses.fillInValidatedPrivateDns(lp);
    } else {
        lp.setValidatedPrivateDnsServers(Collections.EMPTY_LIST);
    }
}
 

@Override
protected void after(XParam param) throws Throwable {
	switch (mMethod) {
	case getAddresses:
	case getAllAddresses:
		if (param.getResult() != null)
			if (isRestricted(param))
				param.setResult(new ArrayList<InetAddress>());
		break;

	case getAllLinkAddresses:
	case getLinkAddresses:
		if (param.getResult() != null)
			if (isRestricted(param))
				param.setResult(new ArrayList<LinkAddress>());
		break;

	case getStackedLinks:
		if (param.getResult() != null)
			if (isRestricted(param))
				param.setResult(new ArrayList<LinkProperties>());
		break;
	}
}
 

/**
 * Removes stacked link on base link and transitions to IDLE state.
 */
private void handleInterfaceRemoved(String iface) {
    if (!Objects.equals(mIface, iface)) {
        return;
    }
    if (!isRunning() && !isStopping()) {
        return;
    }

    Slog.i(TAG, "interface " + iface + " removed");
    if (!isStopping()) {
        // Ensure clatd is stopped if stop() has not been called: this likely means that clatd
        // has crashed.
        enterStoppingState();
    }
    enterIdleState();
    LinkProperties lp = new LinkProperties(mNetwork.linkProperties);
    lp.removeStackedLink(iface);
    mNetwork.connService().handleUpdateLinkProperties(mNetwork, lp);
}
 

/**
 * Adds stacked link on base link and transitions to RUNNING state.
 */
private void handleInterfaceLinkStateChanged(String iface, boolean up) {
    if (!isStarting() || !up || !Objects.equals(mIface, iface)) {
        return;
    }

    LinkAddress clatAddress = getLinkAddress(iface);
    if (clatAddress == null) {
        Slog.e(TAG, "clatAddress was null for stacked iface " + iface);
        return;
    }

    Slog.i(TAG, String.format("interface %s is up, adding stacked link %s on top of %s",
            mIface, mIface, mBaseIface));
    enterRunningState();
    LinkProperties lp = new LinkProperties(mNetwork.linkProperties);
    lp.addStackedLink(makeLinkProperties(clatAddress));
    mNetwork.connService().handleUpdateLinkProperties(mNetwork, lp);
}
 

private LinkProperties makeLinkProperties(LinkAddress clatAddress) {
    LinkProperties stacked = new LinkProperties();
    stacked.setInterfaceName(mIface);

    // Although the clat interface is a point-to-point tunnel, we don't
    // point the route directly at the interface because some apps don't
    // understand routes without gateways (see, e.g., http://b/9597256
    // http://b/9597516). Instead, set the next hop of the route to the
    // clat IPv4 address itself (for those apps, it doesn't matter what
    // the IP of the gateway is, only that there is one).
    RouteInfo ipv4Default = new RouteInfo(
            new LinkAddress(Inet4Address.ANY, 0),
            clatAddress.getAddress(), mIface);
    stacked.addRoute(ipv4Default);
    stacked.addLinkAddress(clatAddress);
    return stacked;
}
 

/**
 * Copies the stacked clat link in oldLp, if any, to the passed LinkProperties.
 * This is necessary because the LinkProperties in mNetwork come from the transport layer, which
 * has no idea that 464xlat is running on top of it.
 */
public void fixupLinkProperties(LinkProperties oldLp, LinkProperties lp) {
    if (!isRunning()) {
        return;
    }
    if (lp == null || lp.getAllInterfaceNames().contains(mIface)) {
        return;
    }

    Slog.d(TAG, "clatd running, updating NAI for " + mIface);
    for (LinkProperties stacked: oldLp.getStackedLinks()) {
        if (Objects.equals(mIface, stacked.getInterfaceName())) {
            lp.addStackedLink(stacked);
            return;
        }
    }
}
 

protected void setDnsForwarders(final Network network, final LinkProperties lp) {
    // TODO: Set v4 and/or v6 DNS per available connectivity.
    String[] dnsServers = mConfig.defaultIPv4DNS;
    final Collection<InetAddress> dnses = lp.getDnsServers();
    // TODO: Properly support the absence of DNS servers.
    if (dnses != null && !dnses.isEmpty()) {
        // TODO: remove this invocation of NetworkUtils.makeStrings().
        dnsServers = NetworkUtils.makeStrings(dnses);
    }
    try {
        mNMService.setDnsForwarders(network, dnsServers);
        mLog.log(String.format(
                "SET DNS forwarders: network=%s dnsServers=%s",
                network, Arrays.toString(dnsServers)));
    } catch (Exception e) {
        // TODO: Investigate how this can fail and what exactly
        // happens if/when such failures occur.
        mLog.e("setting DNS forwarders failed, " + e);
        transitionTo(mSetDnsForwardersErrorState);
    }
}
 

private LinkProperties getLinkProperties() {
  ConnectivityManager connectivityManager =
      (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
    // getActiveNetwork() requires M or later.
    return null;
  }
  Network activeNetwork = connectivityManager.getActiveNetwork();
  if (activeNetwork == null) {
    return null;
  }
  return connectivityManager.getLinkProperties(activeNetwork);
}
 

private PrivateDnsMode getPrivateDnsMode() {
  if (Build.VERSION.SDK_INT < VERSION_CODES.P) {
    // Private DNS was introduced in P.
    return PrivateDnsMode.NONE;
  }

  LinkProperties linkProperties = getLinkProperties();
  if (linkProperties == null) {
    return PrivateDnsMode.NONE;
  }

  if (linkProperties.getPrivateDnsServerName() != null) {
    return PrivateDnsMode.STRICT;
  }

  if (linkProperties.isPrivateDnsActive()) {
    return PrivateDnsMode.UPGRADED;
  }

  return PrivateDnsMode.NONE;
}
 

/**
 * Analyzes the passed LinkedProperties to figure out whether it routes to most of the IP space.
 *
 * This returns true if the passed LinkedProperties contains routes to either most of the IPv4
 * space or to most of the IPv6 address space, where "most" is defined by the value of the
 * MOST_IPV{4,6}_ADDRESSES_COUNT constants : if more than this number of addresses are matched
 * by any of the routes, then it's decided that most of the space is routed.
 * @hide
 */
@VisibleForTesting
static boolean providesRoutesToMostDestinations(LinkProperties lp) {
    final List<RouteInfo> routes = lp.getAllRoutes();
    if (routes.size() > MAX_ROUTES_TO_EVALUATE) return true;
    final Comparator<IpPrefix> prefixLengthComparator = IpPrefix.lengthComparator();
    TreeSet<IpPrefix> ipv4Prefixes = new TreeSet<>(prefixLengthComparator);
    TreeSet<IpPrefix> ipv6Prefixes = new TreeSet<>(prefixLengthComparator);
    for (final RouteInfo route : routes) {
        IpPrefix destination = route.getDestination();
        if (destination.isIPv4()) {
            ipv4Prefixes.add(destination);
        } else {
            ipv6Prefixes.add(destination);
        }
    }
    if (NetworkUtils.routedIPv4AddressCount(ipv4Prefixes) > MOST_IPV4_ADDRESSES_COUNT) {
        return true;
    }
    return NetworkUtils.routedIPv6AddressCount(ipv6Prefixes)
            .compareTo(MOST_IPV6_ADDRESSES_COUNT) >= 0;
}
 

@Override
public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
    super.onLinkPropertiesChanged(network, linkProperties);

    if (!linkProperties.toString().equals(mLastLinkProperties)) {
        mLastLinkProperties = linkProperties.toString();
        VpnStatus.logDebug(String.format("Linkproperties of %s: %s", network, linkProperties));
    }
}
 

@TargetApi(23)
public static String getCurrentNetworkInterfaceName(){
	ConnectivityManager cm=(ConnectivityManager) ApplicationLoader.applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE);
	Network net=cm.getActiveNetwork();
	if(net==null)
		return null;
	LinkProperties props=cm.getLinkProperties(net);
	if(props==null)
		return null;
	return props.getInterfaceName();
}
 

private static String getDnsServer(Context context) {
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (cm == null)
        return DEFAULT_DNS;

    LinkProperties props = null;

    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
        for (Network network : cm.getAllNetworks()) {
            NetworkInfo ni = cm.getNetworkInfo(network);
            if (ni != null && ni.isConnected()) {
                props = cm.getLinkProperties(network);
                Log.i("Old props=" + props);
                break;
            }
        }
    else {
        Network active = cm.getActiveNetwork();
        if (active == null)
            return DEFAULT_DNS;
        props = cm.getLinkProperties(active);
        Log.i("New props=" + props);
    }

    if (props == null)
        return DEFAULT_DNS;

    List<InetAddress> dns = props.getDnsServers();
    if (dns.size() == 0)
        return DEFAULT_DNS;
    else
        return dns.get(0).getHostAddress();
}
 

public NetworkState getNetworkState() {
    synchronized (this) {
        // Network objects are outwardly immutable so there is no point in duplicating.
        // Duplicating also precludes sharing socket factories and connection pools.
        final String subscriberId = (networkMisc != null) ? networkMisc.subscriberId : null;
        return new NetworkState(new NetworkInfo(networkInfo),
                new LinkProperties(linkProperties),
                new NetworkCapabilities(networkCapabilities), network, subscriberId, null);
    }
}
 

@Override
public void onLinkPropertiesChanged(Network network, LinkProperties newLp) {
    handleLinkProp(network, newLp);
    // TODO(b/110335330): reduce the number of times this is called by
    // only recomputing on the LISTEN_ALL callback.
    recomputeLocalPrefixes();
}
 

@Override
public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
    super.onLinkPropertiesChanged(network, linkProperties);

    if (!linkProperties.toString().equals(mLastLinkProperties)) {
        mLastLinkProperties = linkProperties.toString();
        VpnStatus.logDebug(String.format("Linkproperties of %s: %s", network, linkProperties));
    }
}
 

/**
 * @returns result of linkProperties.isPrivateDnsActive().
 */
static boolean isPrivateDnsActive(LinkProperties linkProperties) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && linkProperties != null) {
        return ApiHelperForP.isPrivateDnsActive(linkProperties);
    }
    return false;
}
 

public void sendOffloadExemptPrefixes(final Set<IpPrefix> localPrefixes) {
    // Add in well-known minimum set.
    PrefixUtils.addNonForwardablePrefixes(localPrefixes);
    // Add tragically hardcoded prefixes.
    localPrefixes.add(PrefixUtils.DEFAULT_WIFI_P2P_PREFIX);

    // Maybe add prefixes or addresses for downstreams, depending on
    // the IP serving mode of each.
    for (TetherInterfaceStateMachine tism : mNotifyList) {
        final LinkProperties lp = tism.linkProperties();

        switch (tism.servingMode()) {
            case IControlsTethering.STATE_UNAVAILABLE:
            case IControlsTethering.STATE_AVAILABLE:
                // No usable LinkProperties in these states.
                continue;
            case IControlsTethering.STATE_TETHERED:
                // Only add IPv4 /32 and IPv6 /128 prefixes. The
                // directly-connected prefixes will be sent as
                // downstream "offload-able" prefixes.
                for (LinkAddress addr : lp.getAllLinkAddresses()) {
                    final InetAddress ip = addr.getAddress();
                    if (ip.isLinkLocalAddress()) continue;
                    localPrefixes.add(PrefixUtils.ipAddressAsPrefix(ip));
                }
                break;
            case IControlsTethering.STATE_LOCAL_ONLY:
                // Add prefixes covering all local IPs.
                localPrefixes.addAll(PrefixUtils.localPrefixesFrom(lp));
                break;
        }
    }

    mOffloadController.setLocalPrefixes(localPrefixes);
}
 

/**
 * @returns result of linkProperties.getPrivateDnsServerName().
 */
private static String getPrivateDnsServerName(LinkProperties linkProperties) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && linkProperties != null) {
        return ApiHelperForP.getPrivateDnsServerName(linkProperties);
    }
    return null;
}
 

private static HashSet<IpPrefix> allLocalPrefixes(Iterable<NetworkState> netStates) {
    final HashSet<IpPrefix> prefixSet = new HashSet<>();

    for (NetworkState ns : netStates) {
        final LinkProperties lp = ns.linkProperties;
        if (lp == null) continue;
        prefixSet.addAll(PrefixUtils.localPrefixesFrom(lp));
    }

    return prefixSet;
}
 

private void updateIPv6TetheringInterfaces() {
    for (TetherInterfaceStateMachine sm : mNotifyList) {
        final LinkProperties lp = getInterfaceIPv6LinkProperties(sm);
        sm.sendMessage(TetherInterfaceStateMachine.CMD_IPV6_TETHER_UPDATE, 0, 0, lp);
        break;
    }
}