dhcpv4.cc - platform/system/connectivity/dhcp_client - Git at Google

 //
 // Copyright (C) 2015 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.
 //

 #include "dhcp_client/dhcpv4.h"

 #include <linux/filter.h>
 #include <linux/if_packet.h>
 #include <net/ethernet.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <netinet/ip.h>
 #include <netinet/udp.h>

 #include <random>

 #include <base/bind.h>
 #include <base/logging.h>

 #include "dhcp_client/dhcp_message.h"

 using base::Bind;
 using base::Unretained;
 using shill::ByteString;
 using shill::IOHandlerFactoryContainer;

 namespace dhcp_client {

 namespace {
 // UDP port numbers for DHCP.
 const uint16_t kDHCPServerPort = 67;
 const uint16_t kDHCPClientPort = 68;

 const int kInvalidSocketDescriptor = -1;

 // RFC 791: the minimum value for a correct header is 20 octets.
 // The maximum value is 60 octets.
 const size_t kIPHeaderMinLength = 20;
 const size_t kIPHeaderMaxLength = 60;

 // Socket filter for dhcp packet.
 const sock_filter dhcp_bpf_filter[] = {
   BPF_STMT(BPF_LD + BPF_B + BPF_ABS, 23 - ETH_HLEN),
   BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 6),
   BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20 - ETH_HLEN),
   BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 4, 0),
   BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 14 - ETH_HLEN),
   BPF_STMT(BPF_LD + BPF_H + BPF_IND, 16 - ETH_HLEN),
   BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, kDHCPClientPort, 0, 1),
   BPF_STMT(BPF_RET + BPF_K, 0x0fffffff),
   BPF_STMT(BPF_RET + BPF_K, 0),
 };
 const int dhcp_bpf_filter_len =
     sizeof(dhcp_bpf_filter) / sizeof(dhcp_bpf_filter[0]);
 }  // namespace

 DHCPV4::DHCPV4(const std::string& interface_name,
                const ByteString& hardware_address,
                unsigned int interface_index,
                const std::string& network_id,
                bool request_hostname,
                bool arp_gateway,
                bool unicast_arp,
                EventDispatcherInterface* event_dispatcher)
     : interface_name_(interface_name),
       hardware_address_(hardware_address),
       interface_index_(interface_index),
       network_id_(network_id),
       request_hostname_(request_hostname),
       arp_gateway_(arp_gateway),
       unicast_arp_(unicast_arp),
       event_dispatcher_(event_dispatcher),
       io_handler_factory_(
           IOHandlerFactoryContainer::GetInstance()->GetIOHandlerFactory()),
       state_(State::INIT),
       from_(INADDR_ANY),
       to_(INADDR_BROADCAST),
       socket_(kInvalidSocketDescriptor),
       sockets_(new shill::Sockets()),
       random_engine_(time(nullptr)) {
 }

 DHCPV4::~DHCPV4() {
   Stop();
 }

 void DHCPV4::ParseRawPacket(shill::InputData* data) {
   if (data->len < sizeof(iphdr)) {
     LOG(ERROR) << "Invalid packet length from buffer";
     return;
   }
   // The socket filter has finished part the header validation.
   // This function will perform the remaining part.
   int header_len = ValidatePacketHeader(data->buf, data->len);
   if (header_len == -1) {
     return;
   }
   unsigned char* buffer = data->buf + header_len;
   DHCPMessage msg;
   if (!DHCPMessage::InitFromBuffer(buffer, data->len - header_len, &msg)) {
     LOG(ERROR) << "Failed to initialize DHCP message from buffer";
     return;
   }
   // In INIT state the client ignores all messages from server.
   if (state_ == State::INIT) {
     return;
   }
   // Check transaction id with the existing one.
   if (msg.transaction_id() != transaction_id_) {
     LOG(ERROR) << "Transaction id(xid) doesn't match";
     return;
   }
   uint8_t message_type = msg.message_type();
   switch (message_type) {
     case kDHCPMessageTypeOffer:
       HandleOffer(msg);
       break;
     case kDHCPMessageTypeAck:
       HandleAck(msg);
       break;
     case kDHCPMessageTypeNak:
       HandleNak(msg);
       break;
     default:
       LOG(ERROR) << "Invalid message type: "
                  << static_cast<int>(message_type);
   }
 }

 void DHCPV4::OnReadError(const std::string& error_msg) {
   LOG(INFO) << __func__;
 }

 bool DHCPV4::Start() {
   if (!CreateRawSocket()) {
     return false;
   }

   input_handler_.reset(io_handler_factory_->CreateIOInputHandler(
       socket_,
       Bind(&DHCPV4::ParseRawPacket, Unretained(this)),
       Bind(&DHCPV4::OnReadError, Unretained(this))));
   return true;
 }

 void DHCPV4::Stop() {
   input_handler_.reset();
   if (socket_ != kInvalidSocketDescriptor) {
     sockets_->Close(socket_);
   }
 }

 bool DHCPV4::CreateRawSocket() {
   int fd = sockets_->Socket(PF_PACKET,
                             SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
                             htons(ETHERTYPE_IP));
   if (fd == kInvalidSocketDescriptor) {
     PLOG(ERROR) << "Failed to create socket";
     return false;
   }
   shill::ScopedSocketCloser socket_closer(sockets_.get(), fd);

   // Apply the socket filter.
   sock_fprog pf;
   memset(&pf, 0, sizeof(pf));
   pf.filter = const_cast<sock_filter*>(dhcp_bpf_filter);
   pf.len = dhcp_bpf_filter_len;

   if (sockets_->AttachFilter(fd, &pf) != 0) {
     PLOG(ERROR) << "Failed to attach filter";
     return false;
   }

   if (sockets_->ReuseAddress(fd) == -1) {
     PLOG(ERROR) << "Failed to reuse socket address";
     return false;
   }

   if (sockets_->BindToDevice(fd, interface_name_) < 0) {
     PLOG(ERROR) << "Failed to bind socket to device";
     return false;
   }

   struct sockaddr_ll local;
   memset(&local, 0, sizeof(local));
   local.sll_family = PF_PACKET;
   local.sll_protocol = htons(ETHERTYPE_IP);
   local.sll_ifindex = static_cast<int>(interface_index_);

   if (sockets_->Bind(fd,
                      reinterpret_cast<struct sockaddr*>(&local),
                      sizeof(local)) < 0) {
     PLOG(ERROR) << "Failed to bind to address";
     return false;
   }

   socket_ = socket_closer.Release();
   return true;
 }

 void DHCPV4::HandleOffer(const DHCPMessage& msg) {
   return;
 }

 void DHCPV4::HandleAck(const DHCPMessage& msg) {
   return;
 }

 void DHCPV4::HandleNak(const DHCPMessage& msg) {
   return;
 }

 bool DHCPV4::MakeRawPacket(const DHCPMessage& message, ByteString* output) {
   ByteString payload;
   if (!message.Serialize(&payload)) {
     LOG(ERROR) << "Failed to serialzie dhcp message";
     return false;
   }
   const size_t header_len = sizeof(struct iphdr) + sizeof(struct udphdr);
   const size_t payload_len = payload.GetLength();

   char buffer[header_len + payload_len];
   memset(buffer, 0, header_len + payload_len);
   struct iphdr* ip = reinterpret_cast<struct iphdr*>(buffer);
   struct udphdr* udp = reinterpret_cast<struct udphdr*>(buffer + sizeof(*ip));

   if (!payload.CopyData(payload_len, buffer + header_len)) {
     LOG(ERROR) << "Failed to copy data from payload";
     return false;
   }
   udp->uh_sport = htons(kDHCPClientPort);
   udp->uh_dport = htons(kDHCPServerPort);
   udp->uh_ulen =
       htons(static_cast<uint16_t>(sizeof(*udp) + payload.GetLength()));

   // Fill pseudo header (for UDP checksum computing):
   // Protocol.
   ip->protocol = IPPROTO_UDP;
   // Source IP address.
   ip->saddr = htonl(from_);
   // Destination IP address.
   ip->daddr = htonl(to_);
   // Total length, use udp packet length for pseudo header.
   ip->tot_len = udp->uh_ulen;
   // Calculate udp checksum based on:
   // IPV4 pseudo header, UDP header, and payload.
   udp->uh_sum = htons(DHCPMessage::ComputeChecksum(
       reinterpret_cast<const uint8_t*>(buffer),
       header_len + payload_len));

   // IP version.
   ip->version = IPVERSION;
   // IP header length.
   ip->ihl = sizeof(*ip) >> 2;
   // Fragment offset field.
   // The DHCP packet is always smaller than MTU,
   // so fragmentation is not needed.
   ip->frag_off = 0;
   // Identification.
   ip->id = static_cast<uint16_t>(
       std::uniform_int_distribution<unsigned int>()(
           random_engine_) % UINT16_MAX + 1);
   // Time to live.
   ip->ttl = IPDEFTTL;
   // Total length.
   ip->tot_len = htons(static_cast<uint16_t>(header_len+ payload.GetLength()));
   // Calculate IP Checksum only based on IP header.
   ip->check = htons(DHCPMessage::ComputeChecksum(
       reinterpret_cast<const uint8_t*>(ip),
       sizeof(*ip)));

   *output = ByteString(buffer, header_len + payload_len);
   return true;
 }

 bool DHCPV4::SendRawPacket(const ByteString& packet) {
   struct sockaddr_ll remote;
   memset(&remote, 0, sizeof(remote));
   remote.sll_family = AF_PACKET;
   remote.sll_protocol = htons(ETHERTYPE_IP);
   remote.sll_ifindex = interface_index_;
   remote.sll_hatype = htons(ARPHRD_ETHER);
   // Use broadcast hardware address.
   remote.sll_halen = IFHWADDRLEN;
   memset(remote.sll_addr, 0xff, IFHWADDRLEN);

   size_t result = sockets_->SendTo(socket_,
                                    packet.GetConstData(),
                                    packet.GetLength(),
                                    0,
                                    reinterpret_cast<struct sockaddr *>(&remote),
                                    sizeof(remote));

   if (result != packet.GetLength()) {
     PLOG(ERROR) << "Socket sento failed";
     return false;
   }
   return true;
 }

 int DHCPV4::ValidatePacketHeader(const unsigned char* buffer, size_t len) {
   const struct iphdr* ip =
       reinterpret_cast<const struct iphdr*>(buffer);
   const size_t ip_header_len = static_cast<size_t>(ip->ihl) << 2;
   if (ip_header_len < kIPHeaderMinLength ||
       ip_header_len > kIPHeaderMaxLength) {
     LOG(ERROR) << "Invalid Internet Header Length: "
                << ip_header_len << " bytes";
     return -1;
   }
   if (ip->tot_len != len) {
     LOG(ERROR) << "Invalid IP total length";
     return -1;
   }
   // TODO(nywang): Validate other ip header fields.

   const struct udphdr* udp =
       reinterpret_cast<const struct udphdr*>(buffer + ip_header_len);
   if (udp->uh_sport != htons(kDHCPServerPort) ||
       udp->uh_dport != htons(kDHCPClientPort)) {
     LOG(ERROR) << "Invlaid UDP ports";
     return -1;
   }
   if (udp->uh_ulen != len - ip_header_len) {
     LOG(ERROR) << "Invalid UDP total length";
     return -1;
   }
   // TODO(nywang): Validate UDP checksum.

   return ip_header_len + sizeof(*udp);
 }

 }  // namespace dhcp_client
	//
	// Copyright (C) 2015 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.
	//

	#include "dhcp_client/dhcpv4.h"

	#include <linux/filter.h>
	#include <linux/if_packet.h>
	#include <net/ethernet.h>
	#include <net/if.h>
	#include <net/if_arp.h>
	#include <netinet/ip.h>
	#include <netinet/udp.h>

	#include <random>

	#include <base/bind.h>
	#include <base/logging.h>

	#include "dhcp_client/dhcp_message.h"

	using base::Bind;
	using base::Unretained;
	using shill::ByteString;
	using shill::IOHandlerFactoryContainer;

	namespace dhcp_client {

	namespace {
	// UDP port numbers for DHCP.
	const uint16_t kDHCPServerPort = 67;
	const uint16_t kDHCPClientPort = 68;

	const int kInvalidSocketDescriptor = -1;

	// RFC 791: the minimum value for a correct header is 20 octets.
	// The maximum value is 60 octets.
	const size_t kIPHeaderMinLength = 20;
	const size_t kIPHeaderMaxLength = 60;

	// Socket filter for dhcp packet.
	const sock_filter dhcp_bpf_filter[] = {
	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, 23 - ETH_HLEN),
	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 6),
	BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20 - ETH_HLEN),
	BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 4, 0),
	BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 14 - ETH_HLEN),
	BPF_STMT(BPF_LD + BPF_H + BPF_IND, 16 - ETH_HLEN),
	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, kDHCPClientPort, 0, 1),
	BPF_STMT(BPF_RET + BPF_K, 0x0fffffff),
	BPF_STMT(BPF_RET + BPF_K, 0),
	};
	const int dhcp_bpf_filter_len =
	sizeof(dhcp_bpf_filter) / sizeof(dhcp_bpf_filter[0]);
	} // namespace

	DHCPV4::DHCPV4(const std::string& interface_name,
	const ByteString& hardware_address,
	unsigned int interface_index,
	const std::string& network_id,
	bool request_hostname,
	bool arp_gateway,
	bool unicast_arp,
	EventDispatcherInterface* event_dispatcher)
	: interface_name_(interface_name),
	hardware_address_(hardware_address),
	interface_index_(interface_index),
	network_id_(network_id),
	request_hostname_(request_hostname),
	arp_gateway_(arp_gateway),
	unicast_arp_(unicast_arp),
	event_dispatcher_(event_dispatcher),
	io_handler_factory_(
	IOHandlerFactoryContainer::GetInstance()->GetIOHandlerFactory()),
	state_(State::INIT),
	from_(INADDR_ANY),
	to_(INADDR_BROADCAST),
	socket_(kInvalidSocketDescriptor),
	sockets_(new shill::Sockets()),
	random_engine_(time(nullptr)) {
	}

	DHCPV4::~DHCPV4() {
	Stop();
	}

	void DHCPV4::ParseRawPacket(shill::InputData* data) {
	if (data->len < sizeof(iphdr)) {
	LOG(ERROR) << "Invalid packet length from buffer";
	return;
	}
	// The socket filter has finished part the header validation.
	// This function will perform the remaining part.
	int header_len = ValidatePacketHeader(data->buf, data->len);
	if (header_len == -1) {
	return;
	}
	unsigned char* buffer = data->buf + header_len;
	DHCPMessage msg;
	if (!DHCPMessage::InitFromBuffer(buffer, data->len - header_len, &msg)) {
	LOG(ERROR) << "Failed to initialize DHCP message from buffer";
	return;
	}
	// In INIT state the client ignores all messages from server.
	if (state_ == State::INIT) {
	return;
	}
	// Check transaction id with the existing one.
	if (msg.transaction_id() != transaction_id_) {
	LOG(ERROR) << "Transaction id(xid) doesn't match";
	return;
	}
	uint8_t message_type = msg.message_type();
	switch (message_type) {
	case kDHCPMessageTypeOffer:
	HandleOffer(msg);
	break;
	case kDHCPMessageTypeAck:
	HandleAck(msg);
	break;
	case kDHCPMessageTypeNak:
	HandleNak(msg);
	break;
	default:
	LOG(ERROR) << "Invalid message type: "
	<< static_cast<int>(message_type);
	}
	}

	void DHCPV4::OnReadError(const std::string& error_msg) {
	LOG(INFO) << __func__;
	}

	bool DHCPV4::Start() {
	if (!CreateRawSocket()) {
	return false;
	}

	input_handler_.reset(io_handler_factory_->CreateIOInputHandler(
	socket_,
	Bind(&DHCPV4::ParseRawPacket, Unretained(this)),
	Bind(&DHCPV4::OnReadError, Unretained(this))));
	return true;
	}

	void DHCPV4::Stop() {
	input_handler_.reset();
	if (socket_ != kInvalidSocketDescriptor) {
	sockets_->Close(socket_);
	}
	}

	bool DHCPV4::CreateRawSocket() {
	int fd = sockets_->Socket(PF_PACKET,
	SOCK_DGRAM \| SOCK_CLOEXEC \| SOCK_NONBLOCK,
	htons(ETHERTYPE_IP));
	if (fd == kInvalidSocketDescriptor) {
	PLOG(ERROR) << "Failed to create socket";
	return false;
	}
	shill::ScopedSocketCloser socket_closer(sockets_.get(), fd);

	// Apply the socket filter.
	sock_fprog pf;
	memset(&pf, 0, sizeof(pf));
	pf.filter = const_cast<sock_filter*>(dhcp_bpf_filter);
	pf.len = dhcp_bpf_filter_len;

	if (sockets_->AttachFilter(fd, &pf) != 0) {
	PLOG(ERROR) << "Failed to attach filter";
	return false;
	}

	if (sockets_->ReuseAddress(fd) == -1) {
	PLOG(ERROR) << "Failed to reuse socket address";
	return false;
	}

	if (sockets_->BindToDevice(fd, interface_name_) < 0) {
	PLOG(ERROR) << "Failed to bind socket to device";
	return false;
	}

	struct sockaddr_ll local;
	memset(&local, 0, sizeof(local));
	local.sll_family = PF_PACKET;
	local.sll_protocol = htons(ETHERTYPE_IP);
	local.sll_ifindex = static_cast<int>(interface_index_);

	if (sockets_->Bind(fd,
	reinterpret_cast<struct sockaddr*>(&local),
	sizeof(local)) < 0) {
	PLOG(ERROR) << "Failed to bind to address";
	return false;
	}

	socket_ = socket_closer.Release();
	return true;
	}

	void DHCPV4::HandleOffer(const DHCPMessage& msg) {
	return;
	}

	void DHCPV4::HandleAck(const DHCPMessage& msg) {
	return;
	}

	void DHCPV4::HandleNak(const DHCPMessage& msg) {
	return;
	}

	bool DHCPV4::MakeRawPacket(const DHCPMessage& message, ByteString* output) {
	ByteString payload;
	if (!message.Serialize(&payload)) {
	LOG(ERROR) << "Failed to serialzie dhcp message";
	return false;
	}
	const size_t header_len = sizeof(struct iphdr) + sizeof(struct udphdr);
	const size_t payload_len = payload.GetLength();

	char buffer[header_len + payload_len];
	memset(buffer, 0, header_len + payload_len);
	struct iphdr* ip = reinterpret_cast<struct iphdr*>(buffer);
	struct udphdr* udp = reinterpret_cast<struct udphdr>(buffer + sizeof(ip));

	if (!payload.CopyData(payload_len, buffer + header_len)) {
	LOG(ERROR) << "Failed to copy data from payload";
	return false;
	}
	udp->uh_sport = htons(kDHCPClientPort);
	udp->uh_dport = htons(kDHCPServerPort);
	udp->uh_ulen =
	htons(static_cast<uint16_t>(sizeof(*udp) + payload.GetLength()));

	// Fill pseudo header (for UDP checksum computing):
	// Protocol.
	ip->protocol = IPPROTO_UDP;
	// Source IP address.
	ip->saddr = htonl(from_);
	// Destination IP address.
	ip->daddr = htonl(to_);
	// Total length, use udp packet length for pseudo header.
	ip->tot_len = udp->uh_ulen;
	// Calculate udp checksum based on:
	// IPV4 pseudo header, UDP header, and payload.
	udp->uh_sum = htons(DHCPMessage::ComputeChecksum(
	reinterpret_cast<const uint8_t*>(buffer),
	header_len + payload_len));

	// IP version.
	ip->version = IPVERSION;
	// IP header length.
	ip->ihl = sizeof(*ip) >> 2;
	// Fragment offset field.
	// The DHCP packet is always smaller than MTU,
	// so fragmentation is not needed.
	ip->frag_off = 0;
	// Identification.
	ip->id = static_cast<uint16_t>(
	std::uniform_int_distribution<unsigned int>()(
	random_engine_) % UINT16_MAX + 1);
	// Time to live.
	ip->ttl = IPDEFTTL;
	// Total length.
	ip->tot_len = htons(static_cast<uint16_t>(header_len+ payload.GetLength()));
	// Calculate IP Checksum only based on IP header.
	ip->check = htons(DHCPMessage::ComputeChecksum(
	reinterpret_cast<const uint8_t*>(ip),
	sizeof(*ip)));

	*output = ByteString(buffer, header_len + payload_len);
	return true;
	}

	bool DHCPV4::SendRawPacket(const ByteString& packet) {
	struct sockaddr_ll remote;
	memset(&remote, 0, sizeof(remote));
	remote.sll_family = AF_PACKET;
	remote.sll_protocol = htons(ETHERTYPE_IP);
	remote.sll_ifindex = interface_index_;
	remote.sll_hatype = htons(ARPHRD_ETHER);
	// Use broadcast hardware address.
	remote.sll_halen = IFHWADDRLEN;
	memset(remote.sll_addr, 0xff, IFHWADDRLEN);

	size_t result = sockets_->SendTo(socket_,
	packet.GetConstData(),
	packet.GetLength(),
	0,
	reinterpret_cast<struct sockaddr *>(&remote),
	sizeof(remote));

	if (result != packet.GetLength()) {
	PLOG(ERROR) << "Socket sento failed";
	return false;
	}
	return true;
	}

	int DHCPV4::ValidatePacketHeader(const unsigned char* buffer, size_t len) {
	const struct iphdr* ip =
	reinterpret_cast<const struct iphdr*>(buffer);
	const size_t ip_header_len = static_cast<size_t>(ip->ihl) << 2;
	if (ip_header_len < kIPHeaderMinLength \|\|
	ip_header_len > kIPHeaderMaxLength) {
	LOG(ERROR) << "Invalid Internet Header Length: "
	<< ip_header_len << " bytes";
	return -1;
	}
	if (ip->tot_len != len) {
	LOG(ERROR) << "Invalid IP total length";
	return -1;
	}
	// TODO(nywang): Validate other ip header fields.

	const struct udphdr* udp =
	reinterpret_cast<const struct udphdr*>(buffer + ip_header_len);
	if (udp->uh_sport != htons(kDHCPServerPort) \|\|
	udp->uh_dport != htons(kDHCPClientPort)) {
	LOG(ERROR) << "Invlaid UDP ports";
	return -1;
	}
	if (udp->uh_ulen != len - ip_header_len) {
	LOG(ERROR) << "Invalid UDP total length";
	return -1;
	}
	// TODO(nywang): Validate UDP checksum.

	return ip_header_len + sizeof(*udp);
	}

	} // namespace dhcp_client