dhcp client: support unicast for renewing and release
RFC 2131 requires the DHCP client to send unicast packet
to DHCP server upon renewing and release.
This create a new udp socket for sending unicast packet.
In this way kernel can fill the destination mac address
for us.
This also renames the old socket name to raw_socket.
This also fix the condition for sending dhcp release and
clearing sockets.
Bug: 25642025
TEST=compile, and test using python scripts
Change-Id: I2a984ebe8f4e3870426deaa149fe4c8abe79c9e7
diff --git a/dhcpv4.cc b/dhcpv4.cc
index 90d73a5..2b0a7b4 100644
--- a/dhcpv4.cc
+++ b/dhcpv4.cc
@@ -56,7 +56,7 @@
const uint32_t kRenewalTimePercentage = 50;
// Rebinding time in terms of lease duration percentage.
const uint32_t kRebindTimePercentage = 87;
-const int kInvalidSocketDescriptor = -1;
+const int kInvalidSocketDescriptor = shill::Sockets::kInvalidFileDescriptor;
// RFC 791: the minimum value for a correct header is 20 octets.
// The maximum value is 60 octets.
const size_t kIPHeaderMinLength = 20;
@@ -73,8 +73,7 @@
kDHCPOptionRenewalTime,
kDHCPOptionRebindingTime
};
-const uint8_t kZeroHardwareAddress[] =
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+const uint8_t kZeroHardwareAddress[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
const int kArpProbeReplyTimeoutSeconds = 1;
// Socket filter for dhcp packet.
@@ -140,16 +139,15 @@
IOHandlerFactoryContainer::GetInstance()->GetIOHandlerFactory()),
weak_ptr_factory_(this),
state_(State::INIT),
- socket_(kInvalidSocketDescriptor),
+ raw_socket_(kInvalidSocketDescriptor),
+ udp_socket_(kInvalidSocketDescriptor),
sockets_(new shill::Sockets()),
random_engine_(time(nullptr)) {
ResetState();
}
DHCPV4::~DHCPV4() {
- if (socket_ != kInvalidSocketDescriptor) {
Stop();
- }
}
void DHCPV4::ResetState() {
@@ -231,7 +229,7 @@
return false;
}
input_handler_.reset(io_handler_factory_->CreateIOInputHandler(
- socket_,
+ raw_socket_,
Bind(&DHCPV4::ParseRawPacket, Unretained(this)),
Bind(&DHCPV4::OnReadError, Unretained(this))));
if (!network_id_.empty() && ReadLease()) {
@@ -272,12 +270,19 @@
void DHCPV4::Stop() {
input_handler_.reset();
- if (!SendRelease()) {
- LOG(ERROR) << "Failed to send DHCP release message";
+ if (HasALease()) {
+ if (!SendRelease()) {
+ LOG(ERROR) << "Failed to send DHCP release message";
+ }
+ ResetState();
}
- if (socket_ != kInvalidSocketDescriptor) {
- sockets_->Close(socket_);
- socket_ = kInvalidSocketDescriptor;
+ if (raw_socket_ != kInvalidSocketDescriptor) {
+ sockets_->Close(raw_socket_);
+ raw_socket_ = kInvalidSocketDescriptor;
+ }
+ if (udp_socket_ != kInvalidSocketDescriptor) {
+ sockets_->Close(udp_socket_);
+ udp_socket_ = kInvalidSocketDescriptor;
}
arp_client_->Stop();
}
@@ -326,7 +331,53 @@
return false;
}
- socket_ = socket_closer.Release();
+ raw_socket_ = socket_closer.Release();
+ return true;
+}
+
+bool DHCPV4::CreateUdpSocket() {
+ // Close previous Udp Socket.
+ if (udp_socket_ != kInvalidSocketDescriptor) {
+ sockets_->Close(udp_socket_);
+ udp_socket_ = kInvalidSocketDescriptor;
+ }
+
+ int fd = sockets_->Socket(PF_INET,
+ SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+ IPPROTO_IP);
+ if (fd == kInvalidSocketDescriptor) {
+ PLOG(ERROR) << "Failed to create socket";
+ return false;
+ }
+ shill::ScopedSocketCloser socket_closer(sockets_.get(), fd);
+
+ 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_in local;
+ memset(&local, 0, sizeof(local));
+ local.sin_family = PF_INET;
+ // We do not receive packet from this socket.
+ // At this time the ip address may not be setup by shill yet.
+ // It is a safe choice to use INADDR_ANY.
+ local.sin_addr.s_addr = htonl(INADDR_ANY);
+ local.sin_port = htons(kDHCPClientPort);
+
+ if (sockets_->Bind(fd,
+ reinterpret_cast<struct sockaddr*>(&local),
+ sizeof(local)) < 0) {
+ PLOG(ERROR) << "Failed to bind to address";
+ return false;
+ }
+
+ udp_socket_ = socket_closer.Release();
return true;
}
@@ -443,8 +494,7 @@
}
// Send the DHCP configuration to Shill.
EmitEvent(kReasonBound);
- // TODO(nywang): Setup a udp socket for future unicast, so that kernel can
- // fill the ethernet header with gateway mac address for us.
+ CreateUdpSocket();
}
void DHCPV4::HandleNak(const DHCPMessage& msg) {
@@ -501,7 +551,7 @@
LOG(ERROR) << "Failed to serialize a DHCP discover message";
return false;
}
- if (!SendRawPacket(packet)) {
+ if (!SendBroadcastPacket(packet)) {
LOG(ERROR) << "Failed to send a DHCP discover packet";
return false;
}
@@ -584,9 +634,7 @@
DHCPMessage::InitRequest(&message);
message.SetMessageType(kDHCPMessageTypeRequest);
message.SetClientHardwareAddress(hardware_address_);
- if (state_ == State::BOUND ||
- state_ == State::RENEW ||
- state_ == State::REBIND) {
+ if (HasALease()) {
message.SetClientIPAddress(client_ip_);
}
if (state_ == State::SELECT || state_ == State::INIT_REBOOT) {
@@ -601,14 +649,27 @@
kDefaultParameterRequestList +
sizeof(kDefaultParameterRequestList)));
ByteString packet;
- if (!MakeRawPacket(message, &packet)) {
- LOG(ERROR) << "Failed to serialize a DHCP request message";
- return false;
- }
- // TODO(nywang): Use unicast for renewal.
- if (!SendRawPacket(packet)) {
- LOG(ERROR) << "Failed to send a DHCP request packet";
- return false;
+
+ // Use unicast for renewal.
+ if (state_ == State::BOUND && udp_socket_ != kInvalidSocketDescriptor) {
+ if (!MakePacket(message, &packet)) {
+ LOG(ERROR) << "Failed to make a DHCP request packet";
+ return false;
+ }
+ if (!SendUnicastPacket(packet)) {
+ LOG(ERROR) << "Failed to send a DHCP request packet";
+ return false;
+ }
+ } else {
+ // Use broadcast for other cases.
+ if (!MakeRawPacket(message, &packet)) {
+ LOG(ERROR) << "Failed to make a DHCP request raw packet";
+ return false;
+ }
+ if (!SendBroadcastPacket(packet)) {
+ LOG(ERROR) << "Failed to send a DHCP request packet";
+ return false;
+ }
}
return true;
}
@@ -627,11 +688,17 @@
message.SetTransactionID(transaction_id);
message.SetServerIdentifier(server_identifier_);
ByteString packet;
- if (!MakeRawPacket(message, &packet)) {
- LOG(ERROR) << "Failed to serialize a DHCP release message";
+ if (!MakePacket(message, &packet)) {
+ LOG(ERROR) << "Failed to make a DHCP release packet";
return false;
}
- if (!SendRawPacket(packet)) {
+ // Use unicast for release.
+ if (udp_socket_ == kInvalidSocketDescriptor) {
+ LOG(ERROR) << "Failed to send a DHCP release message becasuse "
+ "there is no socket for unicast";
+ return false;
+ }
+ if (!SendUnicastPacket(packet)) {
LOG(ERROR) << "Failed to send a DHCP release packet";
return false;
}
@@ -640,6 +707,16 @@
return true;
}
+bool DHCPV4::MakePacket(const DHCPMessage& message, ByteString* output) {
+ ByteString payload;
+ if (!message.Serialize(&payload)) {
+ LOG(ERROR) << "Failed to serialzie dhcp message";
+ return false;
+ }
+ *output = payload;
+ return true;
+}
+
bool DHCPV4::MakeRawPacket(const DHCPMessage& message, ByteString* output) {
ByteString payload;
if (!message.Serialize(&payload)) {
@@ -703,7 +780,7 @@
return true;
}
-bool DHCPV4::SendRawPacket(const ByteString& packet) {
+bool DHCPV4::SendBroadcastPacket(const ByteString& packet) {
LOG(INFO) << __func__;
struct sockaddr_ll remote;
memset(&remote, 0, sizeof(remote));
@@ -715,7 +792,29 @@
remote.sll_halen = IFHWADDRLEN;
memset(remote.sll_addr, 0xff, IFHWADDRLEN);
- size_t result = sockets_->SendTo(socket_,
+ size_t result = sockets_->SendTo(raw_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;
+}
+
+bool DHCPV4::SendUnicastPacket(const ByteString& packet) {
+ LOG(INFO) << __func__;
+ struct sockaddr_in remote;
+ memset(&remote, 0, sizeof(remote));
+ remote.sin_family = AF_INET;
+ remote.sin_port = htons(kDHCPServerPort);
+ remote.sin_addr.s_addr = htonl(server_ip_);
+
+ size_t result = sockets_->SendTo(udp_socket_,
packet.GetConstData(),
packet.GetLength(),
0,
@@ -819,9 +918,7 @@
if (state_ != State::BOUND) {
LOG(ERROR) << "Ingore renewal task";
}
- if (!SendRequest()) {
- return;
- }
+ SendRequest();
state_ = State::RENEW;
}
@@ -830,9 +927,7 @@
if (state_ != State::RENEW) {
LOG(ERROR) << "Ingore rebind task";
}
- if (!SendRequest()) {
- return;
- }
+ SendRequest();
state_ = State::REBIND;
}
@@ -853,6 +948,15 @@
adaptor_->EmitEvent(reason, configs);
}
+bool DHCPV4::HasALease() {
+ if (state_ == State::BOUND ||
+ state_ == State::RENEW ||
+ state_ == State::REBIND) {
+ return true;
+ }
+ return false;
+}
+
uint32_t DHCPV4::MasktoCIDR(uint32_t subnet_mask) {
subnet_mask = ~subnet_mask;
uint32_t count = 0;
diff --git a/dhcpv4.h b/dhcpv4.h
index 411cf66..8631cc5 100644
--- a/dhcpv4.h
+++ b/dhcpv4.h
@@ -59,6 +59,9 @@
void ArpProbeReplyTimeoutTask();
void CheckIpCollision();
bool CreateRawSocket();
+ bool CreateUdpSocket();
+ bool HasALease();
+ bool MakePacket(const DHCPMessage& message, shill::ByteString* buffer);
bool MakeRawPacket(const DHCPMessage& message, shill::ByteString* buffer);
void OnReadError(const std::string& error_msg);
void ParseRawPacket(shill::InputData* data);
@@ -67,7 +70,8 @@
bool SendDiscover();
bool SendRequest();
bool SendRelease();
- bool SendRawPacket(const shill::ByteString& buffer);
+ bool SendBroadcastPacket(const shill::ByteString& buffer);
+ bool SendUnicastPacket(const shill::ByteString& buffer);
// Validate the IP and UDP header and return the total headers length.
// Return -1 if any header is invalid.
int ValidatePacketHeader(const unsigned char* buffer, size_t len);
@@ -148,7 +152,9 @@
base::CancelableClosure arp_probe_reply_timeout_task_callback_;
// Socket used for sending and receiving DHCP messages.
- int socket_;
+ int raw_socket_;
+ // Socket used for sending unicast DHCP messages.
+ int udp_socket_;
// Helper class with wrapped socket relavent functions.
std::unique_ptr<shill::Sockets> sockets_;
