Merge "Add IIpClient API for IpClient" am: 60b9ad2e am: e89f5333

        "core/java/android/net/dhcp/DhcpServingParamsParcel.aidl",

        "core/java/android/net/dhcp/IDhcpServer.aidl",

        "core/java/android/net/dhcp/IDhcpServerCallbacks.aidl",

        "core/java/android/net/ip/IIpClient.aidl",

        "core/java/android/net/ip/IIpClientCallbacks.aidl",

        "core/java/android/net/ipmemorystore/**/*.aidl",

    ],

    api_dir: "aidl/networkstack",

/**

 * Copyright (c) 2019, 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 perNmissions and

 * limitations under the License.

 */

package android.net.ip;

import android.net.ProxyInfoParcelable;

import android.net.ProvisioningConfigurationParcelable;

/** @hide */

oneway interface IIpClient {

    void completedPreDhcpAction();

    void confirmConfiguration();

    void readPacketFilterComplete(in byte[] data);

    void shutdown();

    void startProvisioning(in ProvisioningConfigurationParcelable req);

    void stop();

    void setTcpBufferSizes(in String tcpBufferSizes);

    void setHttpProxy(in ProxyInfoParcelable proxyInfo);

    void setMulticastFilter(boolean enabled);

}

/**

 * Copyright (c) 2019, 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 perNmissions and

 * limitations under the License.

 */

package android.net.ip;

import android.net.LinkPropertiesParcelable;

import android.net.ip.IIpClient;

import android.net.DhcpResultsParcelable;

/** @hide */

oneway interface IIpClientCallbacks {

    void onIpClientCreated(in IIpClient ipClient);

    void onPreDhcpAction();

    void onPostDhcpAction();

    // This is purely advisory and not an indication of provisioning

    // success or failure.  This is only here for callers that want to

    // expose DHCPv4 results to other APIs (e.g., WifiInfo#setInetAddress).

    // DHCPv4 or static IPv4 configuration failure or success can be

    // determined by whether or not the passed-in DhcpResults object is

    // null or not.

    void onNewDhcpResults(in DhcpResultsParcelable dhcpResults);

    void onProvisioningSuccess(in LinkPropertiesParcelable newLp);

    void onProvisioningFailure(in LinkPropertiesParcelable newLp);

    // Invoked on LinkProperties changes.

    void onLinkPropertiesChange(in LinkPropertiesParcelable newLp);

    // Called when the internal IpReachabilityMonitor (if enabled) has

    // detected the loss of a critical number of required neighbors.

    void onReachabilityLost(in String logMsg);

    // Called when the IpClient state machine terminates.

    void onQuit();

    // Install an APF program to filter incoming packets.

    void installPacketFilter(in byte[] filter);

    // Asynchronously read back the APF program & data buffer from the wifi driver.

    // Due to Wifi HAL limitations, the current implementation only supports dumping the entire

    // buffer. In response to this request, the driver returns the data buffer asynchronously

    // by sending an IpClient#EVENT_READ_PACKET_FILTER_COMPLETE message.

    void startReadPacketFilter();

    // If multicast filtering cannot be accomplished with APF, this function will be called to

    // actuate multicast filtering using another means.

    void setFallbackMulticastFilter(boolean enabled);

    // Enabled/disable Neighbor Discover offload functionality. This is

    // called, for example, whenever 464xlat is being started or stopped.

    void setNeighborDiscoveryOffload(boolean enable);

}

 No newline at end of file

/*

 * Copyright (C) 2019 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.ip;

import android.net.DhcpResults;

import android.net.LinkProperties;

/**

 * Callbacks for handling IpClient events.

 *

 * This is a convenience class to allow clients not to override all methods of IIpClientCallbacks,

 * and avoid unparceling arguments.

 * These methods are called asynchronously on a Binder thread, as IpClient lives in a different

 * process.

 * @hide

 */

public class IpClientCallbacks {

    /**

     * Callback called upon IpClient creation.

     *

     * @param ipClient The Binder token to communicate with IpClient.

     */

    public void onIpClientCreated(IIpClient ipClient) {}

    /**

     * Callback called prior to DHCP discovery/renewal.

     *

     * <p>In order to receive onPreDhcpAction(), call #withPreDhcpAction() when constructing a

     * ProvisioningConfiguration.

     *

     * <p>Implementations of onPreDhcpAction() must call IpClient#completedPreDhcpAction() to

     * indicate that DHCP is clear to proceed.

      */

    public void onPreDhcpAction() {}

    /**

     * Callback called after DHCP discovery/renewal.

     */

    public void onPostDhcpAction() {}

    /**

     * Callback called when new DHCP results are available.

     *

     * <p>This is purely advisory and not an indication of provisioning success or failure.  This is

     * only here for callers that want to expose DHCPv4 results to other APIs

     * (e.g., WifiInfo#setInetAddress).

     *

     * <p>DHCPv4 or static IPv4 configuration failure or success can be determined by whether or not

     * the passed-in DhcpResults object is null.

     */

    public void onNewDhcpResults(DhcpResults dhcpResults) {}

    /**

     * Indicates that provisioning was successful.

     */

    public void onProvisioningSuccess(LinkProperties newLp) {}

    /**

     * Indicates that provisioning failed.

     */

    public void onProvisioningFailure(LinkProperties newLp) {}

    /**

     * Invoked on LinkProperties changes.

     */

    public void onLinkPropertiesChange(LinkProperties newLp) {}

    /**Called when the internal IpReachabilityMonitor (if enabled) has

     * detected the loss of a critical number of required neighbors.

     */

    public void onReachabilityLost(String logMsg) {}

    /**

     * Called when the IpClient state machine terminates.

     */

    public void onQuit() {}

    /**

     * Called to indicate that a new APF program must be installed to filter incoming packets.

     */

    public void installPacketFilter(byte[] filter) {}

    /**

     * Called to indicate that the APF Program & data buffer must be read asynchronously from the

     * wifi driver.

     *

     * <p>Due to Wifi HAL limitations, the current implementation only supports dumping the entire

     * buffer. In response to this request, the driver returns the data buffer asynchronously

     * by sending an IpClient#EVENT_READ_PACKET_FILTER_COMPLETE message.

     */

    public void startReadPacketFilter() {}

    /**

     * If multicast filtering cannot be accomplished with APF, this function will be called to

     * actuate multicast filtering using another means.

     */

    public void setFallbackMulticastFilter(boolean enabled) {}

    /**

     * Enabled/disable Neighbor Discover offload functionality. This is called, for example,

     * whenever 464xlat is being started or stopped.

     */

    public void setNeighborDiscoveryOffload(boolean enable) {}

}

package android.net.apf;

import static android.net.util.NetworkConstants.*;

import static android.system.OsConstants.*;

import static android.net.util.NetworkConstants.ICMPV6_ECHO_REQUEST_TYPE;

import static android.net.util.NetworkConstants.ICMPV6_NEIGHBOR_ADVERTISEMENT;

import static android.net.util.NetworkConstants.ICMPV6_ROUTER_ADVERTISEMENT;

import static android.net.util.NetworkConstants.ICMPV6_ROUTER_SOLICITATION;

import static android.system.OsConstants.AF_PACKET;

import static android.system.OsConstants.ARPHRD_ETHER;

import static android.system.OsConstants.ETH_P_ARP;

import static android.system.OsConstants.ETH_P_IP;

import static android.system.OsConstants.ETH_P_IPV6;

import static android.system.OsConstants.IPPROTO_ICMPV6;

import static android.system.OsConstants.IPPROTO_UDP;

import static android.system.OsConstants.SOCK_RAW;

import static com.android.internal.util.BitUtils.bytesToBEInt;

import static com.android.internal.util.BitUtils.getUint16;

import static com.android.internal.util.BitUtils.getUint32;

import android.net.NetworkUtils;

import android.net.apf.ApfGenerator.IllegalInstructionException;

import android.net.apf.ApfGenerator.Register;

import android.net.ip.IpClient;

import android.net.ip.IpClientCallbacks;

import android.net.metrics.ApfProgramEvent;

import android.net.metrics.ApfStats;

import android.net.metrics.IpConnectivityLog;

import android.text.format.DateUtils;

import android.util.Log;

import android.util.Pair;

import com.android.internal.annotations.GuardedBy;

import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.util.HexDump;

import com.android.internal.util.IndentingPrintWriter;

import libcore.io.IoBridge;

import java.io.FileDescriptor;

import java.io.IOException;

import java.net.Inet4Address;

import java.nio.ByteBuffer;

import java.util.ArrayList;

import java.util.Arrays;

import libcore.io.IoBridge;

/**

 * For networks that support packet filtering via APF programs, {@code ApfFilter}

    private static final int APF_MAX_ETH_TYPE_BLACK_LIST_LEN = 20;

    private final ApfCapabilities mApfCapabilities;

    private final IpClient.Callback mIpClientCallback;

    private final IpClientCallbacks mIpClientCallback;

    private final InterfaceParams mInterfaceParams;

    private final IpConnectivityLog mMetricsLog;

    @VisibleForTesting

    ApfFilter(Context context, ApfConfiguration config, InterfaceParams ifParams,

            IpClient.Callback ipClientCallback, IpConnectivityLog log) {

            IpClientCallbacks ipClientCallback, IpConnectivityLog log) {

        mApfCapabilities = config.apfCapabilities;

        mIpClientCallback = ipClientCallback;

        mInterfaceParams = ifParams;

     * filtering using APF programs.

     */

    public static ApfFilter maybeCreate(Context context, ApfConfiguration config,

            InterfaceParams ifParams, IpClient.Callback ipClientCallback) {

            InterfaceParams ifParams, IpClientCallbacks ipClientCallback) {

        if (context == null || config == null || ifParams == null) return null;

        ApfCapabilities apfCapabilities =  config.apfCapabilities;

        if (apfCapabilities == null) return null;