Merge changes from topic "cherrypicker-L35800000961165098:N58500001377174291"...

/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package android.net;

import android.net.NetworkStats;

/**

 * Interface for NetworkManagementService to query tethering statistics and set data limits.

 *

 * TODO: this does not really need to be an interface since Tethering runs in the same process

 * as NetworkManagementService. Consider refactoring Tethering to use direct access to

 * NetworkManagementService instead of using INetworkManagementService, and then deleting this

 * interface.

 *

 * @hide

 */

interface ITetheringStatsProvider {

    // Returns cumulative statistics for all tethering sessions since boot, on all upstreams.

    // @code {how} is one of the NetworkStats.STATS_PER_* constants. If {@code how} is

    // {@code STATS_PER_IFACE}, the provider should not include any traffic that is already

    // counted by kernel interface counters.

    NetworkStats getTetherStats(int how);

    // Sets the interface quota for the specified upstream interface. This is defined as the number

    // of bytes, starting from zero and counting from now, after which data should stop being

    // forwarded to/from the specified upstream. A value of QUOTA_UNLIMITED means there is no limit.

    void setInterfaceQuota(String iface, long quotaBytes);

    // Indicates that no data usage limit is set.

    const int QUOTA_UNLIMITED = -1;

}

import android.net.InterfaceConfiguration;

import android.net.INetworkManagementEventObserver;

import android.net.ITetheringStatsProvider;

import android.net.Network;

import android.net.NetworkStats;

import android.net.RouteInfo;

    @UnsupportedAppUsage

    void startTethering(in String[] dhcpRanges);

    /**

     * Start tethering services with the specified dhcp server range and

     * DNS proxy config.

     * {@code boolean} is used to control legacy DNS proxy server.

     * {@code String[]} is a set of start end pairs defining the ranges.

     */

    void startTetheringWithConfiguration(boolean usingLegacyDnsProxy, in String[] dhcpRanges);

    /**

     * Stop currently running tethering services

     */

    @UnsupportedAppUsage

    String[] listTetheredInterfaces();

    /**

     * Returns the list of DNS forwarders (in order of priority)

     */

    String[] getDnsForwarders();

    /**

     * Enables unidirectional packet forwarding from {@code fromIface} to

     * {@code toIface}.

     */

    void startInterfaceForwarding(String fromIface, String toIface);

    /**

     * Disables unidirectional packet forwarding from {@code fromIface} to

     * {@code toIface}.

     */

    void stopInterfaceForwarding(String fromIface, String toIface);

    /**

     *  Enables Network Address Translation between two interfaces.

     *  The address and netmask of the external interface is used for

    @UnsupportedAppUsage

    void disableNat(String internalInterface, String externalInterface);

    /**

     * Registers a {@code ITetheringStatsProvider} to provide tethering statistics.

     * All registered providers will be called in order, and their results will be added together.

     * Netd is always registered as a tethering stats provider.

     */

    void registerTetheringStatsProvider(ITetheringStatsProvider provider, String name);

    /**

     * Unregisters a previously-registered {@code ITetheringStatsProvider}.

     */

    void unregisterTetheringStatsProvider(ITetheringStatsProvider provider);

    /**

     * Reports that a tethering provider has reached a data limit.

     *

     * Currently triggers a global alert, which causes NetworkStatsService to poll counters and

     * re-evaluate data usage.

     *

     * This does not take an interface name because:

     * 1. The tethering offload stats provider cannot reliably determine the interface on which the

     *    limit was reached, because the HAL does not provide it.

     * 2. Firing an interface-specific alert instead of a global alert isn't really useful since in

     *    all cases of interest, the system responds to both in the same way - it polls stats, and

     *    then notifies NetworkPolicyManagerService of the fact.

     */

    void tetherLimitReached(ITetheringStatsProvider provider);

    /**

     ** DATA USAGE RELATED

     **/

    /**

     * Return summary of network statistics all tethering interfaces.

     */

    NetworkStats getNetworkStatsTethering(int how);

    /**

     * Set quota for an interface.

     */

     */

    void removeInterfaceAlert(String iface);

    /**

     * Set alert across all interfaces.

     */

    void setGlobalAlert(long alertBytes);

    /**

     * Control network activity of a UID over interfaces with a quota limit.

     */

    void setFirewallEnabled(boolean enabled);

    boolean isFirewallEnabled();

    void setFirewallInterfaceRule(String iface, boolean allow);

    void setFirewallUidRule(int chain, int uid, int rule);

    void setFirewallUidRules(int chain, in int[] uids, in int[] rules);

    void setFirewallChainEnabled(int chain, boolean enable);

     */

    void denyProtect(int uid);

    void addInterfaceToLocalNetwork(String iface, in List<RouteInfo> routes);

    void removeInterfaceFromLocalNetwork(String iface);

    int removeRoutesFromLocalNetwork(in List<RouteInfo> routes);

    @EnforcePermission("OBSERVE_NETWORK_POLICY")

    boolean isNetworkRestricted(int uid);

}