merge in nyc-release history after reset to master
diff --git a/daemon.cc b/daemon.cc
index 195a5e2..ba3f1fd 100644
--- a/daemon.cc
+++ b/daemon.cc
@@ -19,7 +19,6 @@
#include <sysexits.h>
#include <base/logging.h>
-#include <base/message_loop/message_loop_proxy.h>
#include <base/run_loop.h>
namespace dhcp_client {
diff --git a/dhcp_message.cc b/dhcp_message.cc
index 5f585fd..b17dec6 100644
--- a/dhcp_message.cc
+++ b/dhcp_message.cc
@@ -67,7 +67,8 @@
} // namespace
DHCPMessage::DHCPMessage()
- : lease_time_(0),
+ : requested_ip_address_(0),
+ lease_time_(0),
message_type_(0),
server_identifier_(0),
renewal_time_(0),
@@ -92,6 +93,8 @@
ParserContext(new UInt32ListParser(), &router_)));
options_map_.insert(std::make_pair(kDHCPOptionDomainName,
ParserContext(new StringParser(), &domain_name_)));
+ options_map_.insert(std::make_pair(kDHCPOptionVendorSpecificInformation,
+ ParserContext(new ByteArrayParser(), &vendor_specific_info_)));
}
DHCPMessage::~DHCPMessage() {}
@@ -311,6 +314,14 @@
LOG(ERROR) << "Failed to write message type option";
return false;
}
+ if (requested_ip_address_ != 0) {
+ if (options_writer->WriteUInt32Option(data,
+ kDHCPOptionRequestedIPAddr,
+ requested_ip_address_) == -1) {
+ LOG(ERROR) << "Failed to write requested ip address option";
+ return false;
+ }
+ }
if (lease_time_ != 0) {
if (options_writer->WriteUInt32Option(data,
kDHCPOptionLeaseTime,
@@ -374,12 +385,6 @@
return ~static_cast<uint16_t>(sum);
}
-uint32_t DHCPMessage::GenerateTransactionID() {
- // TODO(nywang): use arc4 random number for better security.
- srand(time(NULL));
- return rand() % UINT32_MAX;
-}
-
void DHCPMessage::SetClientIdentifier(
const ByteString& client_identifier) {
client_identifier_ = client_identifier;
@@ -410,6 +415,11 @@
const std::vector<uint8_t>& parameter_request_list) {
parameter_request_list_ = parameter_request_list;
}
+
+void DHCPMessage::SetRequestedIpAddress(uint32_t requested_ip_address) {
+ requested_ip_address_ = requested_ip_address;
+}
+
void DHCPMessage::SetServerIdentifier(uint32_t server_identifier) {
server_identifier_ = server_identifier;
}
@@ -418,26 +428,29 @@
transaction_id_ = transaction_id;
}
-DHCPMessage DHCPMessage::InitRequest() {
- DHCPMessage msg;
- msg.opcode_ = kDHCPMessageBootRequest;
- msg.hardware_address_type_ = ARPHRD_ETHER;
- msg.hardware_address_length_ = IFHWADDRLEN;
- msg.relay_hops_ = 0;
+void DHCPMessage::SetVendorSpecificInfo(
+ const shill::ByteString& vendor_specific_info) {
+ vendor_specific_info_ = vendor_specific_info;
+}
+
+void DHCPMessage::InitRequest(DHCPMessage* message) {
+ message->opcode_ = kDHCPMessageBootRequest;
+ message->hardware_address_type_ = ARPHRD_ETHER;
+ message->hardware_address_length_ = IFHWADDRLEN;
+ message->relay_hops_ = 0;
// Seconds since DHCP process started.
// 0 is also valid according to RFC 2131.
- msg.seconds_ = 0;
+ message->seconds_ = 0;
// Only firewire (IEEE 1394) and InfiniBand interfaces
// require broadcast flag.
- msg.flags_ = 0;
+ message->flags_ = 0;
// Should be zero in client's messages.
- msg.your_ip_address_ = 0;
+ message->your_ip_address_ = 0;
// Should be zero in client's messages.
- msg.next_server_ip_address_ = 0;
+ message->next_server_ip_address_ = 0;
// Should be zero in client's messages.
- msg.agent_ip_address_ = 0;
- msg.cookie_ = kMagicCookie;
- return msg;
+ message->agent_ip_address_ = 0;
+ message->cookie_ = kMagicCookie;
}
} // namespace dhcp_client
diff --git a/dhcp_message.h b/dhcp_message.h
index dc492c9..9ffd8d3 100644
--- a/dhcp_message.h
+++ b/dhcp_message.h
@@ -58,9 +58,8 @@
static bool InitFromBuffer(const unsigned char* buffer,
size_t length,
DHCPMessage* message);
- static DHCPMessage InitRequest();
+ static void InitRequest(DHCPMessage* message);
static uint16_t ComputeChecksum(const uint8_t* data, size_t len);
- static uint32_t GenerateTransactionID();
// Initialize part of the data fields for outbound DHCP message.
// Serialize the message to a buffer
bool Serialize(shill::ByteString* data) const;
@@ -75,8 +74,10 @@
void SetMessageType(uint8_t message_type);
void SetParameterRequestList(
const std::vector<uint8_t>& parameter_request_list);
+ void SetRequestedIpAddress(uint32_t requested_ip_address);
void SetServerIdentifier(uint32_t server_identifier);
void SetTransactionID(uint32_t transaction_id);
+ void SetVendorSpecificInfo(const shill::ByteString& vendor_specific_info);
// DHCP option and field getters
const shill::ByteString& client_hardware_address() const {
@@ -86,6 +87,7 @@
return client_identifier_;
}
uint32_t client_ip_address() const { return client_ip_address_; }
+ const std::vector<uint32_t>& dns_server() const { return dns_server_; }
const std::string& domain_name() const { return domain_name_; }
const std::string& error_message() const { return error_message_; }
uint32_t lease_time() const { return lease_time_; }
@@ -96,8 +98,10 @@
uint32_t server_identifier() const { return server_identifier_; }
uint32_t subnet_mask() const { return subnet_mask_; }
uint32_t transaction_id() const { return transaction_id_; }
+ const shill::ByteString& vendor_specific_info() const {
+ return vendor_specific_info_;
+ }
uint32_t your_ip_address() const { return your_ip_address_; }
- const std::vector<uint32_t>& dns_server() const { return dns_server_; }
private:
bool ParseDHCPOptions(const uint8_t* options, size_t options_length);
@@ -150,6 +154,10 @@
std::vector<uint32_t> dns_server_;
// Option 15: Domain Name.
std::string domain_name_;
+ // Option 43: Vendor Specific Information.
+ shill::ByteString vendor_specific_info_;
+ // Option 50: Requested IP Address.
+ uint32_t requested_ip_address_;
// Option 51: IP address lease time in unit of seconds.
uint32_t lease_time_;
// Option 53: DHCP message type.
diff --git a/dhcp_options.h b/dhcp_options.h
index 8257585..c215253 100644
--- a/dhcp_options.h
+++ b/dhcp_options.h
@@ -24,6 +24,8 @@
const uint8_t kDHCPOptionRouter = 3;
const uint8_t kDHCPOptionDNSServer = 6;
const uint8_t kDHCPOptionDomainName = 15;
+const uint8_t kDHCPOptionVendorSpecificInformation = 43;
+const uint8_t kDHCPOptionRequestedIPAddr = 50;
const uint8_t kDHCPOptionLeaseTime = 51;
const uint8_t kDHCPOptionMessageType = 53;
const uint8_t kDHCPOptionServerIdentifier = 54;
diff --git a/dhcp_options_parser.cc b/dhcp_options_parser.cc
index 075a61e..8686871 100644
--- a/dhcp_options_parser.cc
+++ b/dhcp_options_parser.cc
@@ -24,6 +24,9 @@
#include <base/logging.h>
#include <base/macros.h>
+#include <shill/net/byte_string.h>
+
+using shill::ByteString;
namespace dhcp_client {
@@ -172,4 +175,17 @@
return true;
}
+bool ByteArrayParser::GetOption(const uint8_t* buffer,
+ uint8_t length,
+ void* value) {
+ if (length == 0) {
+ LOG(ERROR) << "Invalid option length field";
+ return false;
+ }
+ ByteString* byte_array =
+ static_cast<ByteString*>(value);
+ *byte_array = ByteString(buffer, length);
+ return true;
+}
+
} // namespace dhcp_client
diff --git a/dhcp_options_parser.h b/dhcp_options_parser.h
index f8e6786..3dbd909 100644
--- a/dhcp_options_parser.h
+++ b/dhcp_options_parser.h
@@ -101,6 +101,12 @@
void* value) override;
};
+class ByteArrayParser : public DHCPOptionsParser {
+ public:
+ bool GetOption(const uint8_t* buffer,
+ uint8_t length,
+ void* value) override;
+};
} // namespace dhcp_client
#endif // DHCP_CLIENT_PARSER_H_
diff --git a/dhcp_options_parser_unittest.cc b/dhcp_options_parser_unittest.cc
index c701099..88d37c0 100644
--- a/dhcp_options_parser_unittest.cc
+++ b/dhcp_options_parser_unittest.cc
@@ -24,6 +24,9 @@
#include <vector>
#include <gtest/gtest.h>
+#include <shill/net/byte_string.h>
+
+using shill::ByteString;
namespace {
const uint8_t kFakeUInt8Option[] = {0x02};
@@ -56,6 +59,9 @@
{'f', 'a', 'k', 'e', 's', 't', 'r', 'i', 'n', 'g'};
const uint8_t kFakeStringOptionLength = 10;
+const unsigned char kFakeByteArrayOption[] =
+ {'f', 'a', 'k', 'e', 'b', 'y', 't', 'e', 'a', 'r', 'r', 'a', 'y'};
+
const uint8_t kFakeBoolOptionEnable[] = {0x01};
const uint8_t kFakeBoolOptionDisable[] = {0x00};
const uint8_t kFakeBoolOptionLength = 1;
@@ -203,4 +209,15 @@
EXPECT_EQ(target_value, value);
}
+TEST_F(ParserTest, ParseByteArray) {
+ parser_.reset(new ByteArrayParser());
+ ByteString value;
+ ByteString target_value(reinterpret_cast<const char*>(kFakeByteArrayOption),
+ sizeof(kFakeByteArrayOption));
+ EXPECT_TRUE(parser_->GetOption(kFakeByteArrayOption,
+ sizeof(kFakeByteArrayOption),
+ &value));
+ EXPECT_TRUE(target_value.Equals(value));
+}
+
} // namespace dhcp_client
diff --git a/dhcpv4.cc b/dhcpv4.cc
index 016d75f..3ef58ed 100644
--- a/dhcpv4.cc
+++ b/dhcpv4.cc
@@ -24,6 +24,8 @@
#include <netinet/ip.h>
#include <netinet/udp.h>
+#include <random>
+
#include <base/bind.h>
#include <base/logging.h>
@@ -86,7 +88,8 @@
from_(INADDR_ANY),
to_(INADDR_BROADCAST),
socket_(kInvalidSocketDescriptor),
- sockets_(new shill::Sockets()) {
+ sockets_(new shill::Sockets()),
+ random_engine_(time(nullptr)) {
}
DHCPV4::~DHCPV4() {
@@ -266,8 +269,9 @@
// so fragmentation is not needed.
ip->frag_off = 0;
// Identification.
- // TODO(nywang) Use arc4 random number.
- ip->id = static_cast<uint16_t>(rand());
+ 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.
diff --git a/dhcpv4.h b/dhcpv4.h
index c1ea166..ebe2f5a 100644
--- a/dhcpv4.h
+++ b/dhcpv4.h
@@ -17,6 +17,7 @@
#ifndef DHCP_CLIENT_DHCPV4_H_
#define DHCP_CLIENT_DHCPV4_H_
+#include <random>
#include <string>
#include <base/macros.h>
@@ -94,6 +95,8 @@
// Helper class with wrapped socket relavent functions.
std::unique_ptr<shill::Sockets> sockets_;
+ std::default_random_engine random_engine_;
+
DISALLOW_COPY_AND_ASSIGN(DHCPV4);
};
diff --git a/message_loop_event_dispatcher.cc b/message_loop_event_dispatcher.cc
index 26fcced..095429e 100644
--- a/message_loop_event_dispatcher.cc
+++ b/message_loop_event_dispatcher.cc
@@ -17,7 +17,7 @@
#include "dhcp_client/message_loop_event_dispatcher.h"
#include <base/location.h>
-#include <base/message_loop/message_loop_proxy.h>
+#include <base/message_loop/message_loop.h>
#include <base/time/time.h>
namespace dhcp_client {
@@ -26,13 +26,19 @@
MessageLoopEventDispatcher::~MessageLoopEventDispatcher() {}
bool MessageLoopEventDispatcher::PostTask(const base::Closure& task) {
- return base::MessageLoopProxy::current()->PostTask(FROM_HERE, task);
+ if (!base::MessageLoop::current())
+ return false;
+ base::MessageLoop::current()->PostTask(FROM_HERE, task);
+ return true;
}
bool MessageLoopEventDispatcher::PostDelayedTask(const base::Closure& task,
int64_t delay_ms) {
- return base::MessageLoopProxy::current()->PostDelayedTask(
+ if (!base::MessageLoop::current())
+ return false;
+ base::MessageLoop::current()->PostDelayedTask(
FROM_HERE, task, base::TimeDelta::FromMilliseconds(delay_ms));
+ return true;
}
} // namespace dhcp_client
