Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix spurious DHCP parse error logging. am: 2677b19

Browse Source 
am: 09979b4

* commit '09979b4325a3e797f26e92d842985b5dde5cc76b':
  Fix spurious DHCP parse error logging.

Change-Id: Icd0c5d975dd3f15189ee68227b81d1f30d4cfc37
This commit is contained in:
Hugo Benichi
2016-04-18 04:20:15 +00:00
committed by android-build-merger
parent 2870094a86 09979b4325
commit 3ee0bc46c6
4 changed files with 54 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/java/android/net/metrics/DhcpClientEvent.java
View File

@@ -54,7 +54,7 @@ public class DhcpClientEvent extends IpConnectivityEvent implements Parcelable {
}
};
public static void logEvent(int eventType, String ifName, String msg) {
IpConnectivityEvent.logEvent(eventType, new DhcpClientEvent(ifName, msg));
public static void logStateEvent(String ifName, String state) {
logEvent(IpConnectivityEvent.IPCE_DHCP_STATE_CHANGE, new DhcpClientEvent(ifName, state));
}
};

20
core/java/android/net/metrics/DhcpErrorEvent.java
View File

@@ -48,7 +48,9 @@ public class DhcpErrorEvent extends IpConnectivityEvent implements Parcelable {
public static final int DHCP_UNKNOWN_MSG_TYPE = makeErrorCode(DHCP_ERROR, 5);
public static final int BUFFER_UNDERFLOW = makeErrorCode(MISC_ERROR, 1);
public static final int RECEIVE_ERROR = makeErrorCode(MISC_ERROR, 2);
public final String ifName;
// error code byte format (MSB to LSB):
// byte 0: error type
// byte 1: error subtype
@@ -56,15 +58,18 @@ public class DhcpErrorEvent extends IpConnectivityEvent implements Parcelable {
// byte 3: optional code
public final int errorCode;
private DhcpErrorEvent(int errorCode) {
private DhcpErrorEvent(String ifName, int errorCode) {
this.ifName = ifName;
this.errorCode = errorCode;
}
private DhcpErrorEvent(Parcel in) {
this.ifName = in.readString();
this.errorCode = in.readInt();
}
public void writeToParcel(Parcel out, int flags) {
out.writeString(ifName);
out.writeInt(errorCode);
}
@@ -79,12 +84,17 @@ public class DhcpErrorEvent extends IpConnectivityEvent implements Parcelable {
}
};
public static void logEvent(int errorCode) {
IpConnectivityEvent.logEvent(IPCE_DHCP_PARSE_ERROR, new DhcpErrorEvent(errorCode));
public static void logParseError(String ifName, int errorCode) {
IpConnectivityEvent.logEvent(IPCE_DHCP_PARSE_ERROR, new DhcpErrorEvent(ifName, errorCode));
}
public static void logEvent(int errorCode, int option) {
logEvent((0xFFFF0000 & errorCode) | (0xFF & option));
public static void logReceiveError(String ifName) {
IpConnectivityEvent.logEvent(IPCE_DHCP_RECV_ERROR,
new DhcpErrorEvent(ifName, RECEIVE_ERROR));
}
public static int errorCodeWithOption(int errorCode, int option) {
return (0xFFFF0000 & errorCode) | (0xFF & option);
}
private static int makeErrorCode(int type, int subtype) {

13
services/net/java/android/net/dhcp/DhcpClient.java
View File

@@ -30,8 +30,8 @@ import android.net.DhcpResults;
import android.net.InterfaceConfiguration;
import android.net.LinkAddress;
import android.net.NetworkUtils;
import android.net.metrics.IpConnectivityEvent;
import android.net.metrics.DhcpClientEvent;
import android.net.metrics.DhcpErrorEvent;
import android.os.IBinder;
import android.os.INetworkManagementService;
import android.os.Message;
@@ -358,15 +358,13 @@ public class DhcpClient extends StateMachine {
if (!mStopped) {
Log.e(TAG, "Read error", e);
}
DhcpClientEvent.logEvent(IpConnectivityEvent.IPCE_DHCP_RECV_ERROR,
mIfaceName, e.getMessage());
DhcpErrorEvent.logReceiveError(mIfaceName);
} catch (DhcpPacket.ParseException e) {
Log.e(TAG, "Can't parse packet: " + e.getMessage());
if (PACKET_DBG) {
Log.d(TAG, HexDump.dumpHexString(mPacket, 0, length));
}
DhcpClientEvent.logEvent(IpConnectivityEvent.IPCE_DHCP_PARSE_ERROR, mIfaceName,
e.getMessage());
DhcpErrorEvent.logParseError(mIfaceName, e.errorCode);
}
}
if (DBG) Log.d(TAG, "Receive thread stopped");
@@ -463,9 +461,8 @@ public class DhcpClient extends StateMachine {
abstract class LoggingState extends State {
public void enter() {
String msg = "Entering state " + getName();
if (STATE_DBG) Log.d(TAG, msg);
DhcpClientEvent.logEvent(IpConnectivityEvent.IPCE_DHCP_STATE_CHANGE, mIfaceName, msg);
if (STATE_DBG) Log.d(TAG, "Entering state " + getName());
DhcpClientEvent.logStateEvent(mIfaceName, getName());
}
private String messageName(int what) {

63
services/net/java/android/net/dhcp/DhcpPacket.java
View File

@@ -709,8 +709,10 @@ abstract class DhcpPacket {
}
public static class ParseException extends Exception {
public ParseException(String msg, Object... args) {
public final int errorCode;
public ParseException(int errorCode, String msg, Object... args) {
super(String.format(msg, args));
this.errorCode = errorCode;
}
}
@@ -766,9 +768,8 @@ abstract class DhcpPacket {
// check to see if we need to parse L2, IP, and UDP encaps
if (pktType == ENCAP_L2) {
if (packet.remaining() < MIN_PACKET_LENGTH_L2) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.L2_TOO_SHORT);
throw new ParseException("L2 packet too short, %d < %d",
packet.remaining(), MIN_PACKET_LENGTH_L2);
throw new ParseException(DhcpErrorEvent.L2_TOO_SHORT,
"L2 packet too short, %d < %d", packet.remaining(), MIN_PACKET_LENGTH_L2);
}
byte[] l2dst = new byte[6];
@@ -780,24 +781,22 @@ abstract class DhcpPacket {
short l2type = packet.getShort();
if (l2type != OsConstants.ETH_P_IP) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.L2_WRONG_ETH_TYPE);
throw new ParseException("Unexpected L2 type 0x%04x, expected 0x%04x",
l2type, OsConstants.ETH_P_IP);
throw new ParseException(DhcpErrorEvent.L2_WRONG_ETH_TYPE,
"Unexpected L2 type 0x%04x, expected 0x%04x", l2type, OsConstants.ETH_P_IP);
}
}
if (pktType <= ENCAP_L3) {
if (packet.remaining() < MIN_PACKET_LENGTH_L3) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.L3_TOO_SHORT);
throw new ParseException("L3 packet too short, %d < %d",
packet.remaining(), MIN_PACKET_LENGTH_L3);
throw new ParseException(DhcpErrorEvent.L3_TOO_SHORT,
"L3 packet too short, %d < %d", packet.remaining(), MIN_PACKET_LENGTH_L3);
}
byte ipTypeAndLength = packet.get();
int ipVersion = (ipTypeAndLength & 0xf0) >> 4;
if (ipVersion != 4) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.L3_NOT_IPV4);
throw new ParseException("Invalid IP version %d", ipVersion);
throw new ParseException(
DhcpErrorEvent.L3_NOT_IPV4, "Invalid IP version %d", ipVersion);
}
// System.out.println("ipType is " + ipType);
@@ -814,8 +813,8 @@ abstract class DhcpPacket {
ipDst = readIpAddress(packet);
if (ipProto != IP_TYPE_UDP) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.L4_NOT_UDP);
throw new ParseException("Protocol not UDP: %d", ipProto);
throw new ParseException(
DhcpErrorEvent.L4_NOT_UDP, "Protocol not UDP: %d", ipProto);
}
// Skip options. This cannot cause us to read beyond the end of the buffer because the
@@ -841,15 +840,15 @@ abstract class DhcpPacket {
// socket to drop packets that don't have the right source ports. However, it's
// possible that a packet arrives between when the socket is bound and when the
// filter is set. http://b/26696823 .
DhcpErrorEvent.logEvent(DhcpErrorEvent.L4_WRONG_PORT);
throw new ParseException("Unexpected UDP ports %d->%d", udpSrcPort, udpDstPort);
throw new ParseException(DhcpErrorEvent.L4_WRONG_PORT,
"Unexpected UDP ports %d->%d", udpSrcPort, udpDstPort);
}
}
// We need to check the length even for ENCAP_L3 because the IPv4 header is variable-length.
if (pktType > ENCAP_BOOTP || packet.remaining() < MIN_PACKET_LENGTH_BOOTP) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.BOOTP_TOO_SHORT);
throw new ParseException("Invalid type or BOOTP packet too short, %d < %d",
throw new ParseException(DhcpErrorEvent.BOOTP_TOO_SHORT,
"Invalid type or BOOTP packet too short, %d < %d",
packet.remaining(), MIN_PACKET_LENGTH_BOOTP);
}
@@ -873,8 +872,8 @@ abstract class DhcpPacket {
packet.get(ipv4addr);
relayIp = (Inet4Address) Inet4Address.getByAddress(ipv4addr);
} catch (UnknownHostException ex) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.L3_INVALID_IP);
throw new ParseException("Invalid IPv4 address: %s", Arrays.toString(ipv4addr));
throw new ParseException(DhcpErrorEvent.L3_INVALID_IP,
"Invalid IPv4 address: %s", Arrays.toString(ipv4addr));
}
// Some DHCP servers have been known to announce invalid client hardware address values such
@@ -898,9 +897,9 @@ abstract class DhcpPacket {
int dhcpMagicCookie = packet.getInt();
if (dhcpMagicCookie != DHCP_MAGIC_COOKIE) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.DHCP_BAD_MAGIC_COOKIE);
throw new ParseException("Bad magic cookie 0x%08x, should be 0x%08x", dhcpMagicCookie,
DHCP_MAGIC_COOKIE);
throw new ParseException(DhcpErrorEvent.DHCP_BAD_MAGIC_COOKIE,
"Bad magic cookie 0x%08x, should be 0x%08x",
dhcpMagicCookie, DHCP_MAGIC_COOKIE);
}
// parse options
@@ -1009,15 +1008,17 @@ abstract class DhcpPacket {
}
if (expectedLen != optionLen) {
DhcpErrorEvent.logEvent(
final int errorCode = DhcpErrorEvent.errorCodeWithOption(
DhcpErrorEvent.DHCP_INVALID_OPTION_LENGTH, optionType);
throw new ParseException("Invalid length %d for option %d, expected %d",
throw new ParseException(errorCode,
"Invalid length %d for option %d, expected %d",
optionLen, optionType, expectedLen);
}
}
} catch (BufferUnderflowException e) {
DhcpErrorEvent.logEvent(DhcpErrorEvent.BUFFER_UNDERFLOW, optionType);
throw new ParseException("BufferUnderflowException");
final int errorCode = DhcpErrorEvent.errorCodeWithOption(
DhcpErrorEvent.BUFFER_UNDERFLOW, optionType);
throw new ParseException(errorCode, "BufferUnderflowException");
}
}
@@ -1025,8 +1026,8 @@ abstract class DhcpPacket {
switch(dhcpType) {
case (byte) 0xFF:
DhcpErrorEvent.logEvent(DhcpErrorEvent.DHCP_NO_MSG_TYPE);
throw new ParseException("No DHCP message type option");
throw new ParseException(DhcpErrorEvent.DHCP_NO_MSG_TYPE,
"No DHCP message type option");
case DHCP_MESSAGE_TYPE_DISCOVER:
newPacket = new DhcpDiscoverPacket(
transactionId, secs, clientMac, broadcast);
@@ -1059,8 +1060,8 @@ abstract class DhcpPacket {
clientMac);
break;
default:
DhcpErrorEvent.logEvent(DhcpErrorEvent.DHCP_UNKNOWN_MSG_TYPE);
throw new ParseException("Unimplemented DHCP type %d", dhcpType);
throw new ParseException(DhcpErrorEvent.DHCP_UNKNOWN_MSG_TYPE,
"Unimplemented DHCP type %d", dhcpType);
}
newPacket.mBroadcastAddress = bcAddr;