LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge changes from topic "bpf_tether4_rename" am: 3c35666892

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/packages/modules/Connectivity/+/1559687

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I0addb9a731cdedfb97db001b8e09cb3409f82008
This commit is contained in:
Lorenzo Colitti
2021-01-26 14:06:50 +00:00
committed by Automerger Merge Worker
parent ec93812466 3c35666892
commit 7d0693f6dc
11 changed files with 73 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
Tethering/apishim/30/com/android/networkstack/tethering/apishim/api30/BpfCoordinatorShimImpl.java
View File

@@ -28,11 +28,9 @@ import androidx.annotation.Nullable;
import com.android.networkstack.tethering.BpfCoordinator.Dependencies;
import com.android.networkstack.tethering.BpfCoordinator.Ipv6ForwardingRule;
import com.android.networkstack.tethering.TetherDownstream4Key;
import com.android.networkstack.tethering.TetherDownstream4Value;
import com.android.networkstack.tethering.Tether4Key;
import com.android.networkstack.tethering.Tether4Value;
import com.android.networkstack.tethering.TetherStatsValue;
import com.android.networkstack.tethering.TetherUpstream4Key;
import com.android.networkstack.tethering.TetherUpstream4Value;
/**
* Bpf coordinator class for API shims.
@@ -136,27 +134,14 @@ public class BpfCoordinatorShimImpl
}
@Override
public boolean tetherOffloadRuleAdd(@NonNull TetherDownstream4Key key,
@NonNull TetherDownstream4Value value) {
public boolean tetherOffloadRuleAdd(boolean downstream, @NonNull Tether4Key key,
@NonNull Tether4Value value) {
/* no op */
return true;
}
@Override
public boolean tetherOffloadRuleRemove(@NonNull TetherDownstream4Key key) {
/* no op */
return true;
}
@Override
public boolean tetherOffloadRuleAdd(@NonNull TetherUpstream4Key key,
@NonNull TetherUpstream4Value value) {
/* no op */
return true;
}
@Override
public boolean tetherOffloadRuleRemove(@NonNull TetherUpstream4Key key) {
public boolean tetherOffloadRuleRemove(boolean downstream, @NonNull Tether4Key key) {
/* no op */
return true;
}

60
Tethering/apishim/31/com/android/networkstack/tethering/apishim/api31/BpfCoordinatorShimImpl.java
View File

@@ -30,16 +30,14 @@ import androidx.annotation.Nullable;
import com.android.networkstack.tethering.BpfCoordinator.Dependencies;
import com.android.networkstack.tethering.BpfCoordinator.Ipv6ForwardingRule;
import com.android.networkstack.tethering.BpfMap;
import com.android.networkstack.tethering.TetherDownstream4Key;
import com.android.networkstack.tethering.TetherDownstream4Value;
import com.android.networkstack.tethering.Tether4Key;
import com.android.networkstack.tethering.Tether4Value;
import com.android.networkstack.tethering.TetherDownstream6Key;
import com.android.networkstack.tethering.TetherDownstream6Value;
import com.android.networkstack.tethering.TetherLimitKey;
import com.android.networkstack.tethering.TetherLimitValue;
import com.android.networkstack.tethering.TetherStatsKey;
import com.android.networkstack.tethering.TetherStatsValue;
import com.android.networkstack.tethering.TetherUpstream4Key;
import com.android.networkstack.tethering.TetherUpstream4Value;
import java.io.FileDescriptor;
@@ -61,12 +59,12 @@ public class BpfCoordinatorShimImpl
// BPF map of ingress queueing discipline which pre-processes the packets by the IPv4
// downstream rules.
@Nullable
private final BpfMap<TetherDownstream4Key, TetherDownstream4Value> mBpfDownstream4Map;
private final BpfMap<Tether4Key, Tether4Value> mBpfDownstream4Map;
// BPF map of ingress queueing discipline which pre-processes the packets by the IPv4
// upstream rules.
@Nullable
private final BpfMap<TetherUpstream4Key, TetherUpstream4Value> mBpfUpstream4Map;
private final BpfMap<Tether4Key, Tether4Value> mBpfUpstream4Map;
// BPF map of ingress queueing discipline which pre-processes the packets by the IPv6
// forwarding rules.
@@ -250,8 +248,8 @@ public class BpfCoordinatorShimImpl
}
@Override
public boolean tetherOffloadRuleAdd(@NonNull TetherDownstream4Key key,
@NonNull TetherDownstream4Value value) {
public boolean tetherOffloadRuleAdd(boolean downstream, @NonNull Tether4Key key,
@NonNull Tether4Value value) {
if (!isInitialized()) return false;
try {
@@ -259,41 +257,11 @@ public class BpfCoordinatorShimImpl
// map pair twice causes the unexpected refresh. Must be fixed before starting the
// conntrack timeout extension implementation.
// TODO: consider using insertEntry.
mBpfDownstream4Map.updateEntry(key, value);
} catch (ErrnoException e) {
mLog.e("Could not update entry: ", e);
return false;
}
return true;
}
@Override
public boolean tetherOffloadRuleRemove(@NonNull TetherDownstream4Key key) {
if (!isInitialized()) return false;
try {
mBpfDownstream4Map.deleteEntry(key);
} catch (ErrnoException e) {
// Silent if the rule did not exist.
if (e.errno != OsConstants.ENOENT) {
mLog.e("Could not delete entry: ", e);
return false;
if (downstream) {
mBpfDownstream4Map.updateEntry(key, value);
} else {
mBpfUpstream4Map.updateEntry(key, value);
}
}
return true;
}
@Override
public boolean tetherOffloadRuleAdd(@NonNull TetherUpstream4Key key,
@NonNull TetherUpstream4Value value) {
if (!isInitialized()) return false;
try {
// The last used time field of the value is updated by the bpf program. Adding the same
// map pair twice causes the unexpected refresh. Must be fixed before starting the
// conntrack timeout extension implementation.
// TODO: consider using insertEntry.
mBpfUpstream4Map.updateEntry(key, value);
} catch (ErrnoException e) {
mLog.e("Could not update entry: ", e);
return false;
@@ -302,11 +270,15 @@ public class BpfCoordinatorShimImpl
}
@Override
public boolean tetherOffloadRuleRemove(@NonNull TetherUpstream4Key key) {
public boolean tetherOffloadRuleRemove(boolean downstream, @NonNull Tether4Key key) {
if (!isInitialized()) return false;
try {
mBpfUpstream4Map.deleteEntry(key);
if (downstream) {
mBpfDownstream4Map.deleteEntry(key);
} else {
mBpfUpstream4Map.deleteEntry(key);
}
} catch (ErrnoException e) {
// Silent if the rule did not exist.
if (e.errno != OsConstants.ENOENT) {

27
Tethering/apishim/common/com/android/networkstack/tethering/apishim/common/BpfCoordinatorShim.java
View File

@@ -23,11 +23,9 @@ import androidx.annotation.Nullable;
import com.android.networkstack.tethering.BpfCoordinator.Dependencies;
import com.android.networkstack.tethering.BpfCoordinator.Ipv6ForwardingRule;
import com.android.networkstack.tethering.TetherDownstream4Key;
import com.android.networkstack.tethering.TetherDownstream4Value;
import com.android.networkstack.tethering.Tether4Key;
import com.android.networkstack.tethering.Tether4Value;
import com.android.networkstack.tethering.TetherStatsValue;
import com.android.networkstack.tethering.TetherUpstream4Key;
import com.android.networkstack.tethering.TetherUpstream4Value;
/**
* Bpf coordinator class for API shims.
@@ -114,25 +112,14 @@ public abstract class BpfCoordinatorShim {
public abstract TetherStatsValue tetherOffloadGetAndClearStats(int ifIndex);
/**
* Adds a tethering IPv4 downstream offload rule to BPF map.
* Adds a tethering IPv4 offload rule to appropriate BPF map.
*/
public abstract boolean tetherOffloadRuleAdd(@NonNull TetherDownstream4Key key,
@NonNull TetherDownstream4Value value);
public abstract boolean tetherOffloadRuleAdd(boolean downstream, @NonNull Tether4Key key,
@NonNull Tether4Value value);
/**
* Deletes a tethering IPv4 downstream offload rule from the BPF map.
* Deletes a tethering IPv4 offload rule from the appropriate BPF map.
*/
public abstract boolean tetherOffloadRuleRemove(@NonNull TetherDownstream4Key key);
/**
* Adds a tethering IPv4 upstream offload rule to BPF map.
*/
public abstract boolean tetherOffloadRuleAdd(@NonNull TetherUpstream4Key key,
@NonNull TetherUpstream4Value value);
/**
* Deletes a tethering IPv4 upstream offload rule from the BPF map.
*/
public abstract boolean tetherOffloadRuleRemove(@NonNull TetherUpstream4Key key);
public abstract boolean tetherOffloadRuleRemove(boolean downstream, @NonNull Tether4Key key);
}

36
Tethering/bpf_progs/offload.c
View File

@@ -285,11 +285,9 @@ DEFINE_BPF_PROG_KVER_RANGE("schedcls/tether_upstream6_rawip$stub", AID_ROOT, AID
// ----- IPv4 Support -----
DEFINE_BPF_MAP_GRW(tether_downstream4_map, HASH, TetherDownstream4Key, TetherDownstream4Value, 64,
AID_NETWORK_STACK)
DEFINE_BPF_MAP_GRW(tether_downstream4_map, HASH, Tether4Key, Tether4Value, 64, AID_NETWORK_STACK)
DEFINE_BPF_MAP_GRW(tether_upstream4_map, HASH, TetherUpstream4Key, TetherUpstream4Value, 64,
AID_NETWORK_STACK)
DEFINE_BPF_MAP_GRW(tether_upstream4_map, HASH, Tether4Key, Tether4Value, 64, AID_NETWORK_STACK)
static inline __always_inline int do_forward4(struct __sk_buff* skb, const bool is_ethernet,
const bool downstream) {
@@ -358,7 +356,7 @@ static inline __always_inline int do_forward4(struct __sk_buff* skb, const bool
if (data + l2_header_size + sizeof(*ip) + sizeof(*udph) > data_end) return TC_ACT_OK;
}
TetherDownstream4Key kd = {
Tether4Key k = {
.iif = skb->ifindex,
.l4Proto = ip->protocol,
.src4.s_addr = ip->saddr,
@@ -366,26 +364,15 @@ static inline __always_inline int do_forward4(struct __sk_buff* skb, const bool
.srcPort = is_tcp ? tcph->source : udph->source,
.dstPort = is_tcp ? tcph->dest : udph->dest,
};
if (is_ethernet) for (int i = 0; i < ETH_ALEN; ++i) kd.dstMac[i] = eth->h_dest[i];
if (is_ethernet) for (int i = 0; i < ETH_ALEN; ++i) k.dstMac[i] = eth->h_dest[i];
TetherUpstream4Key ku = {
.iif = skb->ifindex,
.l4Proto = ip->protocol,
.src4.s_addr = ip->saddr,
.dst4.s_addr = ip->daddr,
.srcPort = is_tcp ? tcph->source : udph->source,
.dstPort = is_tcp ? tcph->dest : udph->dest,
};
if (is_ethernet) for (int i = 0; i < ETH_ALEN; ++i) ku.dstMac[i] = eth->h_dest[i];
TetherDownstream4Value* vd = downstream ? bpf_tether_downstream4_map_lookup_elem(&kd) : NULL;
TetherUpstream4Value* vu = downstream ? NULL : bpf_tether_upstream4_map_lookup_elem(&ku);
Tether4Value* v = downstream ? bpf_tether_downstream4_map_lookup_elem(&k)
: bpf_tether_upstream4_map_lookup_elem(&k);
// If we don't find any offload information then simply let the core stack handle it...
if (downstream && !vd) return TC_ACT_OK;
if (!downstream && !vu) return TC_ACT_OK;
if (!v) return TC_ACT_OK;
uint32_t stat_and_limit_k = downstream ? skb->ifindex : vu->oif;
uint32_t stat_and_limit_k = downstream ? skb->ifindex : v->oif;
TetherStatsValue* stat_v = bpf_tether_stats_map_lookup_elem(&stat_and_limit_k);
@@ -398,8 +385,7 @@ static inline __always_inline int do_forward4(struct __sk_buff* skb, const bool
if (!limit_v) return TC_ACT_OK;
// Required IPv4 minimum mtu is 68, below that not clear what we should do, abort...
const int pmtu = downstream ? vd->pmtu : vu->pmtu;
if (pmtu < 68) return TC_ACT_OK;
if (v->pmtu < 68) return TC_ACT_OK;
// Approximate handling of TCP/IPv4 overhead for incoming LRO/GRO packets: default
// outbound path mtu of 1500 is not necessarily correct, but worst case we simply
@@ -410,9 +396,9 @@ static inline __always_inline int do_forward4(struct __sk_buff* skb, const bool
// (This is also blindly assuming 12 bytes of tcp timestamp option in tcp header)
uint64_t packets = 1;
uint64_t bytes = skb->len;
if (bytes > pmtu) {
if (bytes > v->pmtu) {
const int tcp_overhead = sizeof(struct iphdr) + sizeof(struct tcphdr) + 12;
const int mss = pmtu - tcp_overhead;
const int mss = v->pmtu - tcp_overhead;
const uint64_t payload = bytes - tcp_overhead;
packets = (payload + mss - 1) / mss;
bytes = tcp_overhead * packets + payload;

40
Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
View File

@@ -237,11 +237,11 @@ public class BpfCoordinator {
}
/** Get downstream4 BPF map. */
@Nullable public BpfMap<TetherDownstream4Key, TetherDownstream4Value>
@Nullable public BpfMap<Tether4Key, Tether4Value>
getBpfDownstream4Map() {
try {
return new BpfMap<>(TETHER_DOWNSTREAM4_MAP_PATH,
BpfMap.BPF_F_RDWR, TetherDownstream4Key.class, TetherDownstream4Value.class);
BpfMap.BPF_F_RDWR, Tether4Key.class, Tether4Value.class);
} catch (ErrnoException e) {
Log.e(TAG, "Cannot create downstream4 map: " + e);
return null;
@@ -249,11 +249,11 @@ public class BpfCoordinator {
}
/** Get upstream4 BPF map. */
@Nullable public BpfMap<TetherUpstream4Key, TetherUpstream4Value>
@Nullable public BpfMap<Tether4Key, Tether4Value>
getBpfUpstream4Map() {
try {
return new BpfMap<>(TETHER_UPSTREAM4_MAP_PATH,
BpfMap.BPF_F_RDWR, TetherUpstream4Key.class, TetherUpstream4Value.class);
BpfMap.BPF_F_RDWR, Tether4Key.class, Tether4Value.class);
} catch (ErrnoException e) {
Log.e(TAG, "Cannot create upstream4 map: " + e);
return null;
@@ -906,25 +906,25 @@ public class BpfCoordinator {
// TODO: add ether ip support.
private class BpfConntrackEventConsumer implements ConntrackEventConsumer {
@NonNull
private TetherUpstream4Key makeTetherUpstream4Key(
private Tether4Key makeTether4Key(
@NonNull ConntrackEvent e, @NonNull ClientInfo c) {
return new TetherUpstream4Key(c.downstreamIfindex, c.downstreamMac,
return new Tether4Key(c.downstreamIfindex, c.downstreamMac,
e.tupleOrig.protoNum, e.tupleOrig.srcIp.getAddress(),
e.tupleOrig.dstIp.getAddress(), e.tupleOrig.srcPort, e.tupleOrig.dstPort);
}
@NonNull
private TetherDownstream4Key makeTetherDownstream4Key(
private Tether4Key makeTether4Key(
@NonNull ConntrackEvent e, @NonNull ClientInfo c, int upstreamIndex) {
return new TetherDownstream4Key(upstreamIndex, NULL_MAC_ADDRESS /* dstMac (rawip) */,
return new Tether4Key(upstreamIndex, NULL_MAC_ADDRESS /* dstMac (rawip) */,
e.tupleReply.protoNum, e.tupleReply.srcIp.getAddress(),
e.tupleReply.dstIp.getAddress(), e.tupleReply.srcPort, e.tupleReply.dstPort);
}
@NonNull
private TetherUpstream4Value makeTetherUpstream4Value(@NonNull ConntrackEvent e,
private Tether4Value makeTether4Value(@NonNull ConntrackEvent e,
int upstreamIndex) {
return new TetherUpstream4Value(upstreamIndex,
return new Tether4Value(upstreamIndex,
NULL_MAC_ADDRESS /* ethDstMac (rawip) */,
NULL_MAC_ADDRESS /* ethSrcMac (rawip) */, ETH_P_IP,
NetworkStackConstants.ETHER_MTU, toIpv4MappedAddressBytes(e.tupleReply.dstIp),
@@ -933,9 +933,9 @@ public class BpfCoordinator {
}
@NonNull
private TetherDownstream4Value makeTetherDownstream4Value(@NonNull ConntrackEvent e,
private Tether4Value makeTether4Value(@NonNull ConntrackEvent e,
@NonNull ClientInfo c, int upstreamIndex) {
return new TetherDownstream4Value(c.downstreamIfindex,
return new Tether4Value(c.downstreamIfindex,
c.clientMac, c.downstreamMac, ETH_P_IP, NetworkStackConstants.ETHER_MTU,
e.tupleOrig.dstIp.getAddress(), e.tupleOrig.srcIp.getAddress(),
e.tupleOrig.dstPort, e.tupleOrig.srcPort,
@@ -962,24 +962,24 @@ public class BpfCoordinator {
final Integer upstreamIndex = mIpv4UpstreamIndices.get(e.tupleReply.dstIp);
if (upstreamIndex == null) return;
final TetherUpstream4Key upstream4Key = makeTetherUpstream4Key(e, tetherClient);
final TetherDownstream4Key downstream4Key = makeTetherDownstream4Key(e,
final Tether4Key upstream4Key = makeTether4Key(e, tetherClient);
final Tether4Key downstream4Key = makeTether4Key(e,
tetherClient, upstreamIndex);
if (e.msgType == (NetlinkConstants.NFNL_SUBSYS_CTNETLINK << 8
| NetlinkConstants.IPCTNL_MSG_CT_DELETE)) {
mBpfCoordinatorShim.tetherOffloadRuleRemove(upstream4Key);
mBpfCoordinatorShim.tetherOffloadRuleRemove(downstream4Key);
mBpfCoordinatorShim.tetherOffloadRuleRemove(false, upstream4Key);
mBpfCoordinatorShim.tetherOffloadRuleRemove(true, downstream4Key);
return;
}
final TetherUpstream4Value upstream4Value = makeTetherUpstream4Value(e,
final Tether4Value upstream4Value = makeTether4Value(e,
upstreamIndex);
final TetherDownstream4Value downstream4Value = makeTetherDownstream4Value(e,
final Tether4Value downstream4Value = makeTether4Value(e,
tetherClient, upstreamIndex);
mBpfCoordinatorShim.tetherOffloadRuleAdd(upstream4Key, upstream4Value);
mBpfCoordinatorShim.tetherOffloadRuleAdd(downstream4Key, downstream4Value);
mBpfCoordinatorShim.tetherOffloadRuleAdd(false, upstream4Key, upstream4Value);
mBpfCoordinatorShim.tetherOffloadRuleAdd(true, downstream4Key, downstream4Value);
}
}

4
Tethering/src/com/android/networkstack/tethering/TetherUpstream4Key.java → Tethering/src/com/android/networkstack/tethering/Tether4Key.java
View File

@@ -29,7 +29,7 @@ import java.net.UnknownHostException;
import java.util.Objects;
/** The key of BpfMap which is used for IPv4 bpf offload. */
public class TetherUpstream4Key extends Struct {
public class Tether4Key extends Struct {
@Field(order = 0, type = Type.U32)
public final long iif;
@@ -51,7 +51,7 @@ public class TetherUpstream4Key extends Struct {
@Field(order = 6, type = Type.UBE16)
public final int dstPort;
public TetherUpstream4Key(final long iif, @NonNull final MacAddress dstMac, final short l4proto,
public Tether4Key(final long iif, @NonNull final MacAddress dstMac, final short l4proto,
final byte[] src4, final byte[] dst4, final int srcPort,
final int dstPort) {
Objects.requireNonNull(dstMac);

4
Tethering/src/com/android/networkstack/tethering/TetherUpstream4Value.java → Tethering/src/com/android/networkstack/tethering/Tether4Value.java
View File

@@ -29,7 +29,7 @@ import java.net.UnknownHostException;
import java.util.Objects;
/** The value of BpfMap which is used for IPv4 bpf offload. */
public class TetherUpstream4Value extends Struct {
public class Tether4Value extends Struct {
@Field(order = 0, type = Type.U32)
public final long oif;
@@ -60,7 +60,7 @@ public class TetherUpstream4Value extends Struct {
@Field(order = 9, type = Type.U63)
public final long lastUsed;
public TetherUpstream4Value(final long oif, @NonNull final MacAddress ethDstMac,
public Tether4Value(final long oif, @NonNull final MacAddress ethDstMac,
@NonNull final MacAddress ethSrcMac, final int ethProto, final int pmtu,
final byte[] src46, final byte[] dst46, final int srcPort,
final int dstPort, final long lastUsed) {

79
Tethering/src/com/android/networkstack/tethering/TetherDownstream4Key.java
View File

@@ -1,79 +0,0 @@
/*
* Copyright (C) 2020 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 com.android.networkstack.tethering;
import android.net.MacAddress;
import com.android.net.module.util.Struct;
import com.android.net.module.util.Struct.Field;
import com.android.net.module.util.Struct.Type;
import java.net.Inet4Address;
import java.net.UnknownHostException;
import java.util.Objects;
/** The key of BpfMap which is used for IPv4 bpf offload. */
public class TetherDownstream4Key extends Struct {
@Field(order = 0, type = Type.U32)
public final long iif;
@Field(order = 1, type = Type.EUI48)
public final MacAddress dstMac;
@Field(order = 2, type = Type.U8, padding = 1)
public final short l4proto;
@Field(order = 3, type = Type.ByteArray, arraysize = 4)
public final byte[] src4;
@Field(order = 4, type = Type.ByteArray, arraysize = 4)
public final byte[] dst4;
@Field(order = 5, type = Type.UBE16)
public final int srcPort;
@Field(order = 6, type = Type.UBE16)
public final int dstPort;
public TetherDownstream4Key(final long iif, final MacAddress dstMac, final short l4proto,
final byte[] src4, final byte[] dst4, final int srcPort,
final int dstPort) {
Objects.requireNonNull(dstMac);
this.iif = iif;
this.dstMac = dstMac;
this.l4proto = l4proto;
this.src4 = src4;
this.dst4 = dst4;
this.srcPort = srcPort;
this.dstPort = dstPort;
}
@Override
public String toString() {
try {
return String.format(
"iif: %d, dstMac: %s, l4proto: %d, src4: %s, dst4: %s, "
+ "srcPort: %d, dstPort: %d",
iif, dstMac, l4proto,
Inet4Address.getByAddress(src4), Inet4Address.getByAddress(dst4),
Short.toUnsignedInt((short) srcPort), Short.toUnsignedInt((short) dstPort));
} catch (UnknownHostException | IllegalArgumentException e) {
return String.format("Invalid IP address", e);
}
}
}

97
Tethering/src/com/android/networkstack/tethering/TetherDownstream4Value.java
View File

@@ -1,97 +0,0 @@
/*
* Copyright (C) 2020 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 com.android.networkstack.tethering;
import android.net.MacAddress;
import androidx.annotation.NonNull;
import com.android.net.module.util.Struct;
import com.android.net.module.util.Struct.Field;
import com.android.net.module.util.Struct.Type;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Objects;
/** The value of BpfMap which is used for IPv4 bpf offload. */
public class TetherDownstream4Value extends Struct {
@Field(order = 0, type = Type.U32)
public final long oif;
// The ethhdr struct which is defined in uapi/linux/if_ether.h
@Field(order = 1, type = Type.EUI48)
public final MacAddress ethDstMac;
@Field(order = 2, type = Type.EUI48)
public final MacAddress ethSrcMac;
@Field(order = 3, type = Type.UBE16)
public final int ethProto; // Packet type ID field.
@Field(order = 4, type = Type.U16)
public final int pmtu;
@Field(order = 5, type = Type.ByteArray, arraysize = 4)
public final byte[] src4;
@Field(order = 6, type = Type.ByteArray, arraysize = 4)
public final byte[] dst4;
@Field(order = 7, type = Type.UBE16)
public final int srcPort;
@Field(order = 8, type = Type.UBE16)
public final int dstPort;
// TODO: consider using U64.
@Field(order = 9, type = Type.U63)
public final long lastUsed;
public TetherDownstream4Value(final long oif, @NonNull final MacAddress ethDstMac,
@NonNull final MacAddress ethSrcMac, final int ethProto, final int pmtu,
final byte[] src4, final byte[] dst4, final int srcPort,
final int dstPort, final long lastUsed) {
Objects.requireNonNull(ethDstMac);
Objects.requireNonNull(ethSrcMac);
this.oif = oif;
this.ethDstMac = ethDstMac;
this.ethSrcMac = ethSrcMac;
this.ethProto = ethProto;
this.pmtu = pmtu;
this.src4 = src4;
this.dst4 = dst4;
this.srcPort = srcPort;
this.dstPort = dstPort;
this.lastUsed = lastUsed;
}
@Override
public String toString() {
try {
return String.format(
"oif: %d, ethDstMac: %s, ethSrcMac: %s, ethProto: %d, pmtu: %d, "
+ "src4: %s, dst4: %s, srcPort: %d, dstPort: %d, "
+ "lastUsed: %d",
oif, ethDstMac, ethSrcMac, ethProto, pmtu,
InetAddress.getByAddress(src4), InetAddress.getByAddress(dst4),
Short.toUnsignedInt((short) srcPort), Short.toUnsignedInt((short) dstPort),
lastUsed);
} catch (UnknownHostException | IllegalArgumentException e) {
return String.format("Invalid IP address", e);
}
}
}

14
Tethering/tests/unit/src/android/net/ip/IpServerTest.java
View File

@@ -104,16 +104,14 @@ import com.android.networkstack.tethering.BpfCoordinator;
import com.android.networkstack.tethering.BpfCoordinator.Ipv6ForwardingRule;
import com.android.networkstack.tethering.BpfMap;
import com.android.networkstack.tethering.PrivateAddressCoordinator;
import com.android.networkstack.tethering.TetherDownstream4Key;
import com.android.networkstack.tethering.TetherDownstream4Value;
import com.android.networkstack.tethering.Tether4Key;
import com.android.networkstack.tethering.Tether4Value;
import com.android.networkstack.tethering.TetherDownstream6Key;
import com.android.networkstack.tethering.TetherDownstream6Value;
import com.android.networkstack.tethering.TetherLimitKey;
import com.android.networkstack.tethering.TetherLimitValue;
import com.android.networkstack.tethering.TetherStatsKey;
import com.android.networkstack.tethering.TetherStatsValue;
import com.android.networkstack.tethering.TetherUpstream4Key;
import com.android.networkstack.tethering.TetherUpstream4Value;
import com.android.networkstack.tethering.TetheringConfiguration;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRule.IgnoreAfter;
@@ -177,8 +175,8 @@ public class IpServerTest {
@Mock private NetworkStatsManager mStatsManager;
@Mock private TetheringConfiguration mTetherConfig;
@Mock private ConntrackMonitor mConntrackMonitor;
@Mock private BpfMap<TetherDownstream4Key, TetherDownstream4Value> mBpfDownstream4Map;
@Mock private BpfMap<TetherUpstream4Key, TetherUpstream4Value> mBpfUpstream4Map;
@Mock private BpfMap<Tether4Key, Tether4Value> mBpfDownstream4Map;
@Mock private BpfMap<Tether4Key, Tether4Value> mBpfUpstream4Map;
@Mock private BpfMap<TetherDownstream6Key, TetherDownstream6Value> mBpfDownstream6Map;
@Mock private BpfMap<TetherStatsKey, TetherStatsValue> mBpfStatsMap;
@Mock private BpfMap<TetherLimitKey, TetherLimitValue> mBpfLimitMap;
@@ -309,13 +307,13 @@ public class IpServerTest {
}
@Nullable
public BpfMap<TetherDownstream4Key, TetherDownstream4Value>
public BpfMap<Tether4Key, Tether4Value>
getBpfDownstream4Map() {
return mBpfDownstream4Map;
}
@Nullable
public BpfMap<TetherUpstream4Key, TetherUpstream4Value>
public BpfMap<Tether4Key, Tether4Value>
getBpfUpstream4Map() {
return mBpfUpstream4Map;
}

8
Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
View File

@@ -158,8 +158,8 @@ public class BpfCoordinatorTest {
@Mock private IpServer mIpServer2;
@Mock private TetheringConfiguration mTetherConfig;
@Mock private ConntrackMonitor mConntrackMonitor;
@Mock private BpfMap<TetherDownstream4Key, TetherDownstream4Value> mBpfDownstream4Map;
@Mock private BpfMap<TetherUpstream4Key, TetherUpstream4Value> mBpfUpstream4Map;
@Mock private BpfMap<Tether4Key, Tether4Value> mBpfDownstream4Map;
@Mock private BpfMap<Tether4Key, Tether4Value> mBpfUpstream4Map;
@Mock private BpfMap<TetherDownstream6Key, TetherDownstream6Value> mBpfDownstream6Map;
// Late init since methods must be called by the thread that created this object.
@@ -205,13 +205,13 @@ public class BpfCoordinatorTest {
}
@Nullable
public BpfMap<TetherDownstream4Key, TetherDownstream4Value>
public BpfMap<Tether4Key, Tether4Value>
getBpfDownstream4Map() {
return mBpfDownstream4Map;
}
@Nullable
public BpfMap<TetherUpstream4Key, TetherUpstream4Value>
public BpfMap<Tether4Key, Tether4Value>
getBpfUpstream4Map() {
return mBpfUpstream4Map;
}