Kea 1.9.11
test_control.cc
Go to the documentation of this file.
1// Copyright (C) 2012-2021 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8
10#include <perfdhcp/receiver.h>
12#include <perfdhcp/perf_pkt4.h>
13#include <perfdhcp/perf_pkt6.h>
14
16#include <dhcp/libdhcp++.h>
17#include <dhcp/iface_mgr.h>
18#include <dhcp/dhcp4.h>
19#include <dhcp/option6_ia.h>
20#include <dhcp/option6_iaaddr.h>
22#include <dhcp/option_int.h>
24
25#include <boost/date_time/posix_time/posix_time.hpp>
26#include <algorithm>
27#include <fstream>
28#include <stdio.h>
29#include <stdlib.h>
30#include <stdint.h>
31#include <unistd.h>
32#include <signal.h>
33#include <sstream>
34#include <sys/wait.h>
35
36using namespace std;
37using namespace boost::posix_time;
38using namespace isc;
39using namespace isc::dhcp;
40using namespace isc::asiolink;
41
42namespace isc {
43namespace perfdhcp {
44
45bool TestControl::interrupted_ = false;
46
47bool
49 uint32_t const wait_time = options_.getExitWaitTime();
50
51 // If we care and not all packets are in yet
52 if (wait_time && !haveAllPacketsBeenReceived()) {
53 const ptime now = microsec_clock::universal_time();
54
55 // Init the end time if it hasn't started yet
56 if (exit_time_.is_not_a_date_time()) {
57 exit_time_ = now + time_duration(microseconds(wait_time));
58 }
59
60 // If we're not at end time yet, return true
61 return (now < exit_time_);
62 }
63
64 // No need to wait, return false;
65 return (false);
66}
67
68bool
70 const uint8_t& ipversion = options_.getIpVersion();
71 const std::vector<int>& num_request = options_.getNumRequests();
72 const size_t& num_request_size = num_request.size();
73
74 if (num_request_size == 0) {
75 return false;
76 }
77
78 uint32_t responses = 0;
79 uint32_t requests = num_request[0];
80 if (num_request_size >= 2) {
81 requests += num_request[1];
82 }
83
84 if (ipversion == 4) {
87 } else {
90 }
91
92 return (responses == requests);
93}
94
95void
97 // When Renews are not sent, Reply packets are not cached so there
98 // is nothing to do.
99 if (options_.getRenewRate() == 0) {
100 return;
101 }
102
103 static boost::posix_time::ptime last_clean =
104 microsec_clock::universal_time();
105
106 // Check how much time has passed since last cleanup.
107 time_period time_since_clean(last_clean,
108 microsec_clock::universal_time());
109 // Cleanup every 1 second.
110 if (time_since_clean.length().total_seconds() >= 1) {
111 // Calculate how many cached packets to remove. Actually we could
112 // just leave enough packets to handle Renews for 1 second but
113 // since we want to randomize leases to be renewed so leave 5
114 // times more packets to randomize from.
116 if (reply_storage_.size() > 5 * options_.getRenewRate()) {
117 reply_storage_.clear(reply_storage_.size() -
118 5 * options_.getRenewRate());
119 }
120 // Remember when we performed a cleanup for the last time.
121 // We want to do the next cleanup not earlier than in one second.
122 last_clean = microsec_clock::universal_time();
123 }
124}
125
126void
127TestControl::copyIaOptions(const Pkt6Ptr& pkt_from, Pkt6Ptr& pkt_to) {
128 if (!pkt_from || !pkt_to) {
129 isc_throw(BadValue, "NULL pointers must not be specified as arguments"
130 " for the copyIaOptions function");
131 }
132 // IA_NA
135 OptionPtr option = pkt_from->getOption(D6O_IA_NA);
136 if (!option) {
137 isc_throw(NotFound, "IA_NA option not found in the"
138 " server's response");
139 }
140 pkt_to->addOption(option);
141 }
142 // IA_PD
145 OptionPtr option = pkt_from->getOption(D6O_IA_PD);
146 if (!option) {
147 isc_throw(NotFound, "IA_PD option not found in the"
148 " server's response");
149 }
150 pkt_to->addOption(option);
151 }
152}
153
154std::string
155TestControl::byte2Hex(const uint8_t b) {
156 const int b1 = b / 16;
157 const int b0 = b % 16;
158 ostringstream stream;
159 stream << std::hex << b1 << b0 << std::dec;
160 return (stream.str());
161}
162
164TestControl::createMessageFromAck(const uint16_t msg_type,
165 const dhcp::Pkt4Ptr& ack) {
166 // Restrict messages to Release and Renew.
167 if (msg_type != DHCPREQUEST && msg_type != DHCPRELEASE) {
168 isc_throw(isc::BadValue, "invalid message type " << msg_type
169 << " to be created from Reply, expected DHCPREQUEST or"
170 " DHCPRELEASE");
171 }
172
173 // Get the string representation of the message - to be used for error
174 // logging purposes.
175 auto msg_type_str = [=]() -> const char* {
176 return (msg_type == DHCPREQUEST ? "Request" : "Release");
177 };
178
179 if (!ack) {
180 isc_throw(isc::BadValue, "Unable to create "
181 << msg_type_str()
182 << " from a null DHCPACK message");
183 } else if (ack->getYiaddr().isV4Zero()) {
185 "Unable to create "
186 << msg_type_str()
187 << " from a DHCPACK message containing yiaddr of 0");
188 }
189 Pkt4Ptr msg(new Pkt4(msg_type, generateTransid()));
190 msg->setCiaddr(ack->getYiaddr());
191 msg->setHWAddr(ack->getHWAddr());
192 msg->addOption(generateClientId(msg->getHWAddr()));
193 if (msg_type == DHCPRELEASE) {
194 // RFC 2132: DHCPRELEASE MUST include server ID.
195 if (options_.isUseFirst()) {
196 // Honor the '-1' flag if it exists.
197 if (first_packet_serverid_.empty()) {
199 "Unable to create "
200 << msg_type_str()
201 << "from the first packet which lacks the server "
202 "identifier option");
203 }
204 msg->addOption(Option::factory(Option::V4,
207 } else {
208 // Otherwise take it from the DHCPACK message.
209 OptionPtr server_identifier(
210 ack->getOption(DHO_DHCP_SERVER_IDENTIFIER));
211 if (!server_identifier) {
213 "Unable to create "
214 << msg_type_str()
215 << "from a DHCPACK message without the server "
216 "identifier option");
217 }
218 msg->addOption(server_identifier);
219 }
220 }
221 return (msg);
222}
223
226 const dhcp::Pkt6Ptr& reply) {
227 // Restrict messages to Release and Renew.
228 if (msg_type != DHCPV6_RENEW && msg_type != DHCPV6_RELEASE) {
229 isc_throw(isc::BadValue, "invalid message type " << msg_type
230 << " to be created from Reply, expected DHCPV6_RENEW or"
231 " DHCPV6_RELEASE");
232 }
233
234 // Get the string representation of the message - to be used for error
235 // logging purposes.
236 auto msg_type_str = [=]() -> const char* {
237 return (msg_type == DHCPV6_RENEW ? "Renew" : "Release");
238 };
239
240 // Reply message must be specified.
241 if (!reply) {
242 isc_throw(isc::BadValue, "Unable to create " << msg_type_str()
243 << " message from the Reply message because the instance of"
244 " the Reply message is NULL");
245 }
246
247 Pkt6Ptr msg(new Pkt6(msg_type, generateTransid()));
248 // Client id.
249 OptionPtr opt_clientid = reply->getOption(D6O_CLIENTID);
250 if (!opt_clientid) {
251 isc_throw(isc::Unexpected, "failed to create " << msg_type_str()
252 << " message because client id option has not been found"
253 " in the Reply message");
254 }
255 msg->addOption(opt_clientid);
256 // Server id.
257 OptionPtr opt_serverid = reply->getOption(D6O_SERVERID);
258 if (!opt_serverid) {
259 isc_throw(isc::Unexpected, "failed to create " << msg_type_str()
260 << " because server id option has not been found in the"
261 " Reply message");
262 }
263 msg->addOption(opt_serverid);
264 copyIaOptions(reply, msg);
265 return (msg);
266}
267
270 const OptionBuffer& buf) {
271 if (buf.size() == 2) {
272 return (OptionPtr(new Option(Option::V6, D6O_ELAPSED_TIME, buf)));
273 } else if (buf.size() == 0) {
274 return (OptionPtr(new Option(Option::V6, D6O_ELAPSED_TIME,
275 OptionBuffer(2, 0))));
276 }
278 "elapsed time option buffer size has to be 0 or 2");
279}
280
283 const OptionBuffer& buf) {
284 OptionPtr opt(new Option(u, type, buf));
285 return (opt);
286}
287
290 const OptionBuffer& buf) {
292 const uint8_t buf_array[] = {
293 0, 0, 0, 1, // IAID = 1
294 0, 0, 3600 >> 8, 3600 & 0xff, // T1 = 3600
295 0, 0, 5400 >> 8, 5400 & 0xff, // T2 = 5400
296 };
297 OptionBuffer buf_ia_na(buf_array, buf_array + sizeof(buf_array));
298 for (size_t i = 0; i < buf.size(); ++i) {
299 buf_ia_na.push_back(buf[i]);
300 }
301 return (OptionPtr(new Option(Option::V6, D6O_IA_NA, buf_ia_na)));
302}
303
306 const OptionBuffer& buf) {
308 static const uint8_t buf_array[] = {
309 0, 0, 0, 1, // IAID = 1
310 0, 0, 3600 >> 8, 3600 & 0xff, // T1 = 3600
311 0, 0, 5400 >> 8, 5400 & 0xff, // T2 = 5400
312 };
313 OptionBuffer buf_ia_pd(buf_array, buf_array + sizeof(buf_array));
314 // Append sub-options to IA_PD.
315 buf_ia_pd.insert(buf_ia_pd.end(), buf.begin(), buf.end());
316 return (OptionPtr(new Option(Option::V6, D6O_IA_PD, buf_ia_pd)));
317}
318
319
322 const OptionBuffer&) {
323 return (OptionPtr(new Option(Option::V6, D6O_RAPID_COMMIT, OptionBuffer())));
324}
325
328 uint16_t,
329 const OptionBuffer&) {
330 const uint8_t buf_array[] = {
333 };
334 OptionBuffer buf_with_options(buf_array, buf_array + sizeof(buf_array));
335 return (OptionPtr(new Option(Option::V6, D6O_ORO, buf_with_options)));
336}
337
338
341 uint16_t type,
342 const OptionBuffer& buf) {
343 const uint8_t buf_array[] = {
351 };
352
353 OptionBuffer buf_with_options(buf_array, buf_array + sizeof(buf_array));
354 OptionPtr opt(new Option(u, type, buf));
355 opt->setData(buf_with_options.begin(), buf_with_options.end());
356 return (opt);
357}
358
359std::vector<uint8_t>
362 // if we are using the -M option return a random one from the list...
363 if (macs.size() > 0) {
364 uint16_t r = number_generator_();
365 if (r >= macs.size()) {
366 r = 0;
367 }
368 return macs[r];
369
370 } else {
371 // ... otherwise use the standard behavior
372 uint32_t clients_num = options_.getClientsNum();
373 if (clients_num < 2) {
374 return (options_.getMacTemplate());
375 }
376 // Get the base MAC address. We are going to randomize part of it.
377 std::vector<uint8_t> mac_addr(options_.getMacTemplate());
378 if (mac_addr.size() != HW_ETHER_LEN) {
379 isc_throw(BadValue, "invalid MAC address template specified");
380 }
381 uint32_t r = macaddr_gen_->generate();
382 randomized = 0;
383 // Randomize MAC address octets.
384 for (std::vector<uint8_t>::iterator it = mac_addr.end() - 1;
385 it >= mac_addr.begin();
386 --it) {
387 // Add the random value to the current octet.
388 (*it) += r;
389 ++randomized;
390 if (r < 256) {
391 // If we are here it means that there is no sense
392 // to randomize the remaining octets of MAC address
393 // because the following bytes of random value
394 // are zero and it will have no effect.
395 break;
396 }
397 // Randomize the next octet with the following
398 // byte of random value.
399 r >>= 8;
400 }
401 return (mac_addr);
402 }
403}
404
407 std::vector<uint8_t> client_id(1, static_cast<uint8_t>(hwaddr->htype_));
408 client_id.insert(client_id.end(), hwaddr->hwaddr_.begin(),
409 hwaddr->hwaddr_.end());
410 return (OptionPtr(new Option(Option::V4, DHO_DHCP_CLIENT_IDENTIFIER,
411 client_id)));
412}
413
414std::vector<uint8_t>
415TestControl::generateDuid(uint8_t& randomized) {
416 std::vector<uint8_t> mac_addr(generateMacAddress(randomized));
418 // pick a random mac address if we are using option -M..
419 if (macs.size() > 0) {
420 uint16_t r = number_generator_();
421 if (r >= macs.size()) {
422 r = 0;
423 }
424 std::vector<uint8_t> mac = macs[r];
425 // DUID_LL is in this format
426 // 0 1 2 3
427 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
428 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
429 // | 3 | hardware type (16 bits) |
430 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
431 // . .
432 // . link-layer address (variable length) .
433 // . .
434 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
435
436 // No C++11 so initializer list support, building a vector<uint8_t> is a
437 // pain...
438 uint8_t duid_ll[] = {0, 3, 0, 1, 0, 0, 0, 0, 0, 0};
439 // copy duid_ll array into the vector
440 std::vector<uint8_t> duid(duid_ll,
441 duid_ll + sizeof(duid_ll) / sizeof(duid_ll[0]));
442 // put the mac address bytes at the end
443 std::copy(mac.begin(), mac.end(), duid.begin() + 4);
444 return (duid);
445 } else {
446 uint32_t clients_num = options_.getClientsNum();
447 if ((clients_num == 0) || (clients_num == 1)) {
448 return (options_.getDuidTemplate());
449 }
450 // Get the base DUID. We are going to randomize part of it.
451 std::vector<uint8_t> duid(options_.getDuidTemplate());
453 duid.resize(duid.size());
454 std::copy(mac_addr.begin(), mac_addr.end(),
455 duid.begin() + duid.size() - mac_addr.size());
456 return (duid);
457 }
458}
459
460int
462 int elp_offset = options_.getIpVersion() == 4 ?
463 DHCPV4_ELAPSED_TIME_OFFSET : DHCPV6_ELAPSED_TIME_OFFSET;
464 if (options_.getElapsedTimeOffset() > 0) {
465 elp_offset = options_.getElapsedTimeOffset();
466 }
467 return (elp_offset);
468}
469
470template<class T>
471uint32_t
472TestControl::getElapsedTime(const T& pkt1, const T& pkt2) {
473 using namespace boost::posix_time;
474 ptime pkt1_time = pkt1->getTimestamp();
475 ptime pkt2_time = pkt2->getTimestamp();
476 if (pkt1_time.is_not_a_date_time() ||
477 pkt2_time.is_not_a_date_time()) {
478 isc_throw(InvalidOperation, "packet timestamp not set");;
479 }
480 time_period elapsed_period(pkt1_time, pkt2_time);
481 return (elapsed_period.is_null() ? 0 :
482 elapsed_period.length().total_milliseconds());
483}
484
485int
486TestControl::getRandomOffset(const int arg_idx) const {
487 int rand_offset = options_.getIpVersion() == 4 ?
488 DHCPV4_RANDOMIZATION_OFFSET : DHCPV6_RANDOMIZATION_OFFSET;
489 if (options_.getRandomOffset().size() > arg_idx) {
490 rand_offset = options_.getRandomOffset()[arg_idx];
491 }
492 return (rand_offset);
493}
494
495int
497 int rip_offset = options_.getIpVersion() == 4 ?
498 DHCPV4_REQUESTED_IP_OFFSET : DHCPV6_IA_NA_OFFSET;
499 if (options_.getRequestedIpOffset() > 0) {
500 rip_offset = options_.getRequestedIpOffset();
501 }
502 return (rip_offset);
503}
504
505int
507 int srvid_offset = options_.getIpVersion() == 4 ?
508 DHCPV4_SERVERID_OFFSET : DHCPV6_SERVERID_OFFSET;
509 if (options_.getServerIdOffset() > 0) {
510 srvid_offset = options_.getServerIdOffset();
511 }
512 return (srvid_offset);
513}
514
516TestControl::getTemplateBuffer(const size_t idx) const {
517 if (template_buffers_.size() > idx) {
518 return (template_buffers_[idx]);
519 }
520 isc_throw(OutOfRange, "invalid buffer index");
521}
522
523int
524TestControl::getTransactionIdOffset(const int arg_idx) const {
525 int xid_offset = options_.getIpVersion() == 4 ?
526 DHCPV4_TRANSID_OFFSET : DHCPV6_TRANSID_OFFSET;
527 if (options_.getTransactionIdOffset().size() > arg_idx) {
528 xid_offset = options_.getTransactionIdOffset()[arg_idx];
529 }
530 return (xid_offset);
531}
532
533void
535 int status = 0;
536 while (wait3(&status, WNOHANG, NULL) > 0) {
537 // continue
538 }
539}
540
541void
543 interrupted_ = true;
544}
545
546void
548 template_packets_v4_.clear();
549 template_packets_v6_.clear();
550 template_buffers_.clear();
551 std::vector<std::string> template_files = options_.getTemplateFiles();
552 for (std::vector<std::string>::const_iterator it = template_files.begin();
553 it != template_files.end(); ++it) {
555 }
556}
557
558void
559TestControl::sendPackets(const uint64_t packets_num,
560 const bool preload /* = false */) {
561 for (uint64_t i = packets_num; i > 0; --i) {
562 if (options_.getIpVersion() == 4) {
563 // No template packets means that no -T option was specified.
564 // We have to build packets ourselves.
565 if (template_buffers_.empty()) {
566 sendDiscover4(preload);
567 } else {
570 sendDiscover4(template_buffers_[0], preload);
571 }
572 } else {
573 // No template packets means that no -T option was specified.
574 // We have to build packets ourselves.
575 if (template_buffers_.empty()) {
576 sendSolicit6(preload);
577 } else {
580 sendSolicit6(template_buffers_[0], preload);
581 }
582 }
583 }
584}
585
586uint64_t
588 const uint64_t msg_num) {
589 for (uint64_t i = 0; i < msg_num; ++i) {
590 if (!sendMessageFromAck(msg_type)) {
591 return (i);
592 }
593 }
594 return (msg_num);
595}
596
597uint64_t
599 const uint64_t msg_num) {
600 for (uint64_t i = 0; i < msg_num; ++i) {
601 if (!sendMessageFromReply(msg_type)) {
602 return (i);
603 }
604 }
605 return (msg_num);
606}
607
608void
610 if (options_.testDiags('a')) {
611 // Print all command line parameters.
613 // Print MAC and DUID.
614 std::cout << "Set MAC to " << vector2Hex(options_.getMacTemplate(), "::")
615 << std::endl;
616 if (options_.getDuidTemplate().size() > 0) {
617 std::cout << "Set DUID to " << vector2Hex(options_.getDuidTemplate()) << std::endl;
618 }
619 }
620}
621
622void
623TestControl::printTemplate(const uint8_t packet_type) const {
624 std::string hex_buf;
625 int arg_idx = 0;
626 if (options_.getIpVersion() == 4) {
627 if (packet_type == DHCPREQUEST) {
628 arg_idx = 1;
629 }
630 std::map<uint8_t, dhcp::Pkt4Ptr>::const_iterator pkt_it =
631 template_packets_v4_.find(packet_type);
632 if ((pkt_it != template_packets_v4_.end()) &&
633 pkt_it->second) {
634 const util::OutputBuffer& out_buf(pkt_it->second->getBuffer());
635 const char* out_buf_data =
636 static_cast<const char*>(out_buf.getData());
637 std::vector<uint8_t> buf(out_buf_data, out_buf_data + out_buf.getLength());
638 hex_buf = vector2Hex(buf);
639 }
640 } else if (options_.getIpVersion() == 6) {
641 if (packet_type == DHCPV6_REQUEST) {
642 arg_idx = 1;
643 }
644 std::map<uint8_t, dhcp::Pkt6Ptr>::const_iterator pkt_it =
645 template_packets_v6_.find(packet_type);
646 if (pkt_it != template_packets_v6_.end() &&
647 pkt_it->second) {
648 const util::OutputBuffer& out_buf(pkt_it->second->getBuffer());
649 const char* out_buf_data =
650 static_cast<const char*>(out_buf.getData());
651 std::vector<uint8_t> buf(out_buf_data, out_buf_data + out_buf.getLength());
652 hex_buf = vector2Hex(buf);
653 }
654 }
655 std::cout << "xid-offset=" << getTransactionIdOffset(arg_idx) << std::endl;
656 std::cout << "random-offset=" << getRandomOffset(arg_idx) << std::endl;
657 if (arg_idx > 0) {
658 std::cout << "srvid-offset=" << getServerIdOffset() << std::endl;
659 std::cout << "time-offset=" << getElapsedTimeOffset() << std::endl;
660 std::cout << "ip-offset=" << getRequestedIpOffset() << std::endl;
661 }
662
663 std::cout << "contents: " << std::endl;
664 int line_len = 32;
665 int i = 0;
666 while (line_len == 32) {
667 if (hex_buf.length() - i < 32) {
668 line_len = hex_buf.length() - i;
669 };
670 if (line_len > 0) {
671 std::cout << setfill('0') << setw(4) << std::hex << i << std::dec
672 << " " << hex_buf.substr(i, line_len) << std::endl;
673 }
674 i += 32;
675 }
676 std::cout << std::endl;
677}
678
679void
681 if (options_.getIpVersion() == 4) {
684 } else if (options_.getIpVersion() == 6) {
687 }
688}
689
690void
692 double rate = 0;
693 std::string exchange_name = "4-way exchanges";
694 ExchangeType xchg_type = ExchangeType::DO;
695 if (options_.getIpVersion() == 4) {
696 xchg_type =
699 if (xchg_type == ExchangeType::DO) {
700 exchange_name = "DISCOVER-OFFER";
701 }
702 } else if (options_.getIpVersion() == 6) {
703 xchg_type =
706 if (xchg_type == ExchangeType::SA) {
707 exchange_name = options_.isRapidCommit() ? "Solicit-Reply" :
708 "Solicit-Advertise";
709 }
710 }
711 double duration =
712 stats_mgr_.getTestPeriod().length().total_nanoseconds() / 1e9;
713 rate = stats_mgr_.getRcvdPacketsNum(xchg_type) / duration;
714 std::ostringstream s;
715 s << "***Rate statistics***" << std::endl;
716 s << "Rate: " << rate << " " << exchange_name << "/second";
717 if (options_.getRate() > 0) {
718 s << ", expected rate: " << options_.getRate() << std::endl;
719 }
720
721 std::cout << s.str() << std::endl;
722
723 std::cout <<"***Malformed Packets***" << std::endl
724 << "Malformed packets: " << ExchangeStats::malformed_pkts_
725 << std::endl;
726}
727
728void
730 int delay = options_.getReportDelay();
731 ptime now = microsec_clock::universal_time();
732 time_period time_since_report(last_report_, now);
733 if (time_since_report.length().total_seconds() >= delay) {
736 last_report_ = now;
737 }
738}
739
740void
742 printRate();
744 if (options_.testDiags('i')) {
746 }
747}
748
749std::string
750TestControl::vector2Hex(const std::vector<uint8_t>& vec,
751 const std::string& separator /* = "" */) {
752 std::ostringstream stream;
753 for (std::vector<uint8_t>::const_iterator it = vec.begin();
754 it != vec.end();
755 ++it) {
756 if (it == vec.begin()) {
757 stream << byte2Hex(*it);
758 } else {
759 stream << separator << byte2Hex(*it);
760 }
761 }
762 return (stream.str());
763}
764
765void
766TestControl::readPacketTemplate(const std::string& file_name) {
767 std::ifstream temp_file;
768 temp_file.open(file_name.c_str(), ios::in | ios::binary | ios::ate);
769 if (!temp_file.is_open()) {
770 isc_throw(BadValue, "unable to open template file " << file_name);
771 }
772 // Read template file contents.
773 std::streampos temp_size = temp_file.tellg();
774 if (temp_size == std::streampos(0)) {
775 temp_file.close();
776 isc_throw(OutOfRange, "the template file " << file_name << " is empty");
777 }
778 temp_file.seekg(0, ios::beg);
779 std::vector<char> file_contents(temp_size);
780 temp_file.read(&file_contents[0], temp_size);
781 temp_file.close();
782 // Spaces are allowed so we have to strip the contents
783 // from them. In the same time we want to make sure that
784 // apart from spaces the file contains hexadecimal digits
785 // only.
786 std::vector<char> hex_digits;
787 for (size_t i = 0; i < file_contents.size(); ++i) {
788 if (isxdigit(file_contents[i])) {
789 hex_digits.push_back(file_contents[i]);
790 } else if (!isxdigit(file_contents[i]) &&
791 !isspace(file_contents[i])) {
792 isc_throw(BadValue, "'" << file_contents[i] << "' is not a"
793 " hexadecimal digit");
794 }
795 }
796 // Expect even number of digits.
797 if (hex_digits.size() % 2 != 0) {
798 isc_throw(OutOfRange, "odd number of digits in template file");
799 } else if (hex_digits.empty()) {
800 isc_throw(OutOfRange, "template file " << file_name << " is empty");
801 }
802 std::vector<uint8_t> binary_stream;
803 for (size_t i = 0; i < hex_digits.size(); i += 2) {
804 stringstream s;
805 s << "0x" << hex_digits[i] << hex_digits[i+1];
806 int b;
807 s >> std::hex >> b;
808 binary_stream.push_back(static_cast<uint8_t>(b));
809 }
810 template_buffers_.push_back(binary_stream);
811}
812
813void
815 if (pkt4->getType() == DHCPOFFER) {
818 Pkt4Ptr discover_pkt4(boost::dynamic_pointer_cast<Pkt4>(pkt));
820 if ((xchg_mode == CommandOptions::DORA_SARR) && discover_pkt4) {
821 if (template_buffers_.size() < 2) {
822 sendRequest4(discover_pkt4, pkt4);
823 } else {
826 sendRequest4(template_buffers_[1], discover_pkt4, pkt4);
827 }
828 }
829 } else if (pkt4->getType() == DHCPACK) {
830 // If received message is DHCPACK, we have to check if this is
831 // a response to 4-way exchange. We'll match this packet with
832 // a DHCPREQUEST sent as part of the 4-way exchanges.
835 // The DHCPACK belongs to DHCPREQUEST-DHCPACK exchange type.
836 // So, we may need to keep this DHCPACK in the storage if renews.
837 // Note that, DHCPACK messages hold the information about
838 // leases assigned. We use this information to renew.
841 // Renew or release messages are sent, because StatsMgr has the
842 // specific exchange type specified. Let's append the DHCPACK
843 // message to a storage.
844 ack_storage_.append(pkt4);
845 }
846 // The DHCPACK message is not a server's response to the DHCPREQUEST
847 // message sent within the 4-way exchange. It may be a response to a
848 // renewal. In this case we first check if StatsMgr has exchange type
849 // for renew specified, and if it has, if there is a corresponding
850 // renew message for the received DHCPACK.
853 }
854 }
855}
856
857void
859 // check if received address is unique
860 if (options_.getAddrUnique()) {
861 std::set<std::string> current;
862 // addresses were already checked in validateIA
863 // we can safely assume that those are correct
864 for (OptionCollection::iterator opt = pkt6->options_.begin();
865 opt != pkt6->options_.end(); ++opt) {
866 switch (opt->second->getType()) {
867 case D6O_IA_PD: {
868 // add address and check if it has not been already assigned
869 // addresses should be unique cross options of the packet
870 auto ret = current.emplace(boost::dynamic_pointer_cast<
871 Option6IAPrefix>(opt->second->getOption(D6O_IAPREFIX))->getAddress().toText());
872 if (!ret.second) {
874 }
875 break;
876 }
877 case D6O_IA_NA: {
878 // add address and check if it has not been already assigned
879 // addresses should be unique cross options of the packet
880 auto ret = current.emplace(boost::dynamic_pointer_cast<
881 Option6IAAddr>(opt->second->getOption(D6O_IAADDR))->getAddress().toText());
882 if (!ret.second) {
884 }
885 break;
886 }
887 default:
888 break;
889 }
890 }
891 // addresses should be unique cross packets
892 addUniqeAddr(current, xchg_type);
893 }
894}
895
896void
898 // check if received address is unique
899 if (options_.getAddrUnique()) {
900 // addresses were already checked in validateIA
901 // we can safely assume that those are correct
902 std::set<std::string> current;
903 current.insert(pkt4->getYiaddr().toText());
904 // addresses should be unique cross packets
905 addUniqeAddr(current, xchg_type);
906 }
907}
908
909bool
911 // check if iaaddr exists - if it does, we can continue sending request
912 // if not we will update statistics about rejected leases
913 // @todo it's checking just one iaaddress option for now it's ok
914 // but when perfdhcp will be extended to create message with multiple IA
915 // this will have to be iterate on:
916 // OptionCollection ias = pkt6->getOptions(D6O_IA_NA);
917 Option6IAPrefixPtr iapref;
918 Option6IAAddrPtr iaaddr;
919 if (pkt6->getOption(D6O_IA_PD)) {
920 iapref = boost::dynamic_pointer_cast<
921 Option6IAPrefix>(pkt6->getOption(D6O_IA_PD)->getOption(D6O_IAPREFIX));
922 }
923 if (pkt6->getOption(D6O_IA_NA)) {
924 iaaddr = boost::dynamic_pointer_cast<
925 Option6IAAddr>(pkt6->getOption(D6O_IA_NA)->getOption(D6O_IAADDR));
926 }
927
928 bool address_and_prefix = options_.getLeaseType().includes(
930 bool prefix_only = options_.getLeaseType().includes(
932 bool address_only = options_.getLeaseType().includes(
934 if ((address_and_prefix && iapref && iaaddr) ||
935 (prefix_only && iapref && !address_and_prefix) ||
936 (address_only && iaaddr && !address_and_prefix)) {
937 return true;
938 } else {
939 return false;
940 }
941}
942
943void
945 uint8_t packet_type = pkt6->getType();
946 if (packet_type == DHCPV6_ADVERTISE) {
948 Pkt6Ptr solicit_pkt6(boost::dynamic_pointer_cast<Pkt6>(pkt));
950 if ((xchg_mode == CommandOptions::DORA_SARR) && solicit_pkt6) {
951 if (validateIA(pkt6)) {
952 // if address is correct - check uniqueness
954 if (template_buffers_.size() < 2) {
955 sendRequest6(pkt6);
956 } else {
960 }
961 } else {
963 }
964 }
965 } else if (packet_type == DHCPV6_REPLY) {
966 // If the received message is Reply, we have to find out which exchange
967 // type the Reply message belongs to. It is doable by matching the Reply
968 // transaction id with the transaction id of the sent Request, Renew
969 // or Release. First we start with the Request.
971 // The Reply belongs to Request-Reply exchange type. So, we may need
972 // to keep this Reply in the storage if Renews or/and Releases are
973 // being sent. Note that, Reply messages hold the information about
974 // leases assigned. We use this information to construct Renew and
975 // Release messages.
976 if (validateIA(pkt6)) {
977 // if address is correct - check uniqueness
979 // check if there is correct IA to continue with Renew/Release
982 // Renew or Release messages are sent, because StatsMgr has the
983 // specific exchange type specified. Let's append the Reply
984 // message to a storage.
985 reply_storage_.append(pkt6);
986 }
987 } else {
989 }
990 // The Reply message is not a server's response to the Request message
991 // sent within the 4-way exchange. It may be a response to the Renew
992 // or Release message. In the if clause we first check if StatsMgr
993 // has exchange type for Renew specified, and if it has, if there is
994 // a corresponding Renew message for the received Reply. If not,
995 // we check that StatsMgr has exchange type for Release specified,
996 // as possibly the Reply has been sent in response to Release.
1000 // At this point, it is only possible that the Reply has been sent
1001 // in response to a Release. Try to match the Reply with Release.
1003 }
1004 }
1005}
1006
1007unsigned int
1009 unsigned int pkt_count = 0;
1010 PktPtr pkt;
1011 while ((pkt = receiver_.getPkt())) {
1012 pkt_count += 1;
1013 if (options_.getIpVersion() == 4) {
1014 Pkt4Ptr pkt4 = boost::dynamic_pointer_cast<Pkt4>(pkt);
1016 } else {
1017 Pkt6Ptr pkt6 = boost::dynamic_pointer_cast<Pkt6>(pkt);
1019 }
1020 }
1021 return pkt_count;
1022}
1023void
1025 static bool factories_registered = false;
1026 if (!factories_registered) {
1027 // DHCP_MESSAGE_TYPE option factory.
1028 LibDHCP::OptionFactoryRegister(Option::V4,
1031 // DHCP_SERVER_IDENTIFIER option factory.
1032 LibDHCP::OptionFactoryRegister(Option::V4,
1035 // DHCP_PARAMETER_REQUEST_LIST option factory.
1036 LibDHCP::OptionFactoryRegister(Option::V4,
1039 }
1040 factories_registered = true;
1041}
1042
1043void
1045 static bool factories_registered = false;
1046 if (!factories_registered) {
1047 // D6O_ELAPSED_TIME
1048 LibDHCP::OptionFactoryRegister(Option::V6,
1051 // D6O_RAPID_COMMIT
1052 LibDHCP::OptionFactoryRegister(Option::V6,
1055 // D6O_ORO (option request option) factory.
1056 LibDHCP::OptionFactoryRegister(Option::V6,
1057 D6O_ORO,
1059 // D6O_CLIENTID option factory.
1060 LibDHCP::OptionFactoryRegister(Option::V6,
1063 // D6O_SERVERID option factory.
1064 LibDHCP::OptionFactoryRegister(Option::V6,
1067 // D6O_IA_NA option factory.
1068 LibDHCP::OptionFactoryRegister(Option::V6,
1069 D6O_IA_NA,
1071
1072 // D6O_IA_PD option factory.
1073 LibDHCP::OptionFactoryRegister(Option::V6,
1074 D6O_IA_PD,
1076
1077
1078 }
1079 factories_registered = true;
1080}
1081
1082void
1084 switch(options_.getIpVersion()) {
1085 case 4:
1087 break;
1088 case 6:
1090 break;
1091 default:
1092 isc_throw(InvalidOperation, "command line options have to be parsed "
1093 "before DHCP option factories can be registered");
1094 }
1095}
1096
1097void
1099 transid_gen_.reset();
1100 last_report_ = microsec_clock::universal_time();
1101 // Actual generators will have to be set later on because we need to
1102 // get command line parameters first.
1105 first_packet_serverid_.clear();
1106 interrupted_ = false;
1107}
1108
1110 exit_time_(not_a_date_time),
1111 number_generator_(0, options.getMacsFromFile().size()),
1112 socket_(socket),
1113 receiver_(socket, options.isSingleThreaded(), options.getIpVersion()),
1114 stats_mgr_(options),
1115 options_(options)
1116{
1117 // Reset singleton state before test starts.
1118 reset();
1119
1120 // Ip version is not set ONLY in case the command options
1121 // were not parsed. This surely means that parse() function
1122 // was not called prior to starting the test. This is fatal
1123 // error.
1124 if (options_.getIpVersion() == 0) {
1126 "command options must be parsed before running a test");
1127 } else if (options_.getIpVersion() == 4) {
1128 // Turn off packet queueing.
1129 IfaceMgr::instance().configureDHCPPacketQueue(AF_INET, data::ElementPtr());
1131 } else {
1132 // Turn off packet queueing.
1133 IfaceMgr::instance().configureDHCPPacketQueue(AF_INET6, data::ElementPtr());
1135 }
1136
1137 uint32_t clients_num = options_.getClientsNum() == 0 ?
1138 1 : options_.getClientsNum();
1140
1141 // Diagnostics are command line options mainly.
1143 // Option factories have to be registered.
1145 // Initialize packet templates.
1147 // Initialize randomization seed.
1148 if (options_.isSeeded()) {
1149 srandom(options_.getSeed());
1150 } else {
1151 // Seed with current time.
1152 time_period duration(from_iso_string("20111231T235959"),
1153 microsec_clock::universal_time());
1154 srandom(duration.length().total_seconds()
1155 + duration.length().fractional_seconds());
1156 }
1157 // If user interrupts the program we will exit gracefully.
1158 signal(SIGINT, TestControl::handleInterrupt);
1159}
1160
1161void
1162TestControl::runWrapped(bool do_stop /*= false */) const {
1163 if (!options_.getWrapped().empty()) {
1164 pid_t pid = 0;
1165 signal(SIGCHLD, handleChild);
1166 pid = fork();
1167 if (pid < 0) {
1168 isc_throw(Unexpected, "unable to fork");
1169 } else if (pid == 0) {
1170 execlp(options_.getWrapped().c_str(), do_stop ? "stop" : "start", (void*)0);
1171 }
1172 }
1173}
1174
1175void
1177 if (options_.testDiags('T')) {
1178 if (template_packets_v4_.find(pkt->getType()) == template_packets_v4_.end()) {
1179 template_packets_v4_[pkt->getType()] = pkt;
1180 }
1181 }
1182}
1183
1184void
1186 if (options_.testDiags('T')) {
1187 if (template_packets_v6_.find(pkt->getType()) == template_packets_v6_.end()) {
1188 template_packets_v6_[pkt->getType()] = pkt;
1189 }
1190 }
1191}
1192
1193void
1194TestControl::sendDiscover4(const bool preload /*= false*/) {
1195 // Generate the MAC address to be passed in the packet.
1196 uint8_t randomized = 0;
1197 std::vector<uint8_t> mac_address = generateMacAddress(randomized);
1198 // Generate transaction id to be set for the new exchange.
1199 const uint32_t transid = generateTransid();
1200 Pkt4Ptr pkt4(new Pkt4(DHCPDISCOVER, transid));
1201 if (!pkt4) {
1202 isc_throw(Unexpected, "failed to create DISCOVER packet");
1203 }
1204
1205 // Delete the default Message Type option set by Pkt4
1206 pkt4->delOption(DHO_DHCP_MESSAGE_TYPE);
1207
1208 // Set options: DHCP_MESSAGE_TYPE and DHCP_PARAMETER_REQUEST_LIST
1209 OptionBuffer buf_msg_type;
1210 buf_msg_type.push_back(DHCPDISCOVER);
1211 pkt4->addOption(Option::factory(Option::V4, DHO_DHCP_MESSAGE_TYPE,
1212 buf_msg_type));
1213 pkt4->addOption(Option::factory(Option::V4,
1215
1216
1217 // Set client's and server's ports as well as server's address,
1218 // and local (relay) address.
1219 setDefaults4(pkt4);
1220
1221 // Set hardware address
1222 pkt4->setHWAddr(HTYPE_ETHER, mac_address.size(), mac_address);
1223
1224 // Set client identifier
1225 pkt4->addOption(generateClientId(pkt4->getHWAddr()));
1226
1227 // Check if we need to simulate HA failures by pretending no responses were received.
1228 // The DHCP protocol signals that by increasing secs field (seconds since the configuration attempt started).
1230 stats_mgr_.getTestPeriod().length().total_seconds() >= options_.getWaitForElapsedTime() &&
1231 stats_mgr_.getTestPeriod().length().total_seconds() < options_.getWaitForElapsedTime() +
1233
1234 // Keep increasing elapsed time. The value should start increasing steadily.
1235 uint32_t val = stats_mgr_.getTestPeriod().length().total_seconds() - options_.getWaitForElapsedTime() + 1;
1236 if (val > 65535) {
1237 val = 65535;
1238 }
1239 pkt4->setSecs(static_cast<uint16_t>(val));
1240 }
1241
1242 // Add any extra options that user may have specified.
1243 addExtraOpts(pkt4);
1244
1245 pkt4->pack();
1246 socket_.send(pkt4);
1247 if (!preload) {
1249 }
1250
1251 saveFirstPacket(pkt4);
1252}
1253
1254void
1255TestControl::sendDiscover4(const std::vector<uint8_t>& template_buf,
1256 const bool preload /* = false */) {
1257 // Get the first argument if multiple the same arguments specified
1258 // in the command line. First one refers to DISCOVER packets.
1259 const uint8_t arg_idx = 0;
1260 // Generate the MAC address to be passed in the packet.
1261 uint8_t randomized = 0;
1262 std::vector<uint8_t> mac_address = generateMacAddress(randomized);
1263 // Generate transaction id to be set for the new exchange.
1264 const uint32_t transid = generateTransid();
1265 // Get transaction id offset.
1266 size_t transid_offset = getTransactionIdOffset(arg_idx);
1267 // Get randomization offset.
1268 // We need to go back by HW_ETHER_LEN (MAC address length)
1269 // because this offset points to last octet of MAC address.
1270 size_t rand_offset = getRandomOffset(arg_idx) - HW_ETHER_LEN + 1;
1271 // Create temporary buffer with template contents. We will
1272 // modify this temporary buffer but we don't want to modify
1273 // the original template.
1274 std::vector<uint8_t> in_buf(template_buf.begin(),
1275 template_buf.end());
1276 // Check if we are not going out of bounds.
1277 if (rand_offset + HW_ETHER_LEN > in_buf.size()) {
1278 isc_throw(OutOfRange, "randomization offset is out of bounds");
1279 }
1280 PerfPkt4Ptr pkt4(new PerfPkt4(&in_buf[0], in_buf.size(),
1281 transid_offset,
1282 transid));
1283
1284 // Replace MAC address in the template with actual MAC address.
1285 pkt4->writeAt(rand_offset, mac_address.begin(), mac_address.end());
1286 // Create a packet from the temporary buffer.
1287 setDefaults4(boost::static_pointer_cast<Pkt4>(pkt4));
1288 // Pack the input packet buffer to output buffer so as it can
1289 // be sent to server.
1290 pkt4->rawPack();
1291 socket_.send(boost::static_pointer_cast<Pkt4>(pkt4));
1292 if (!preload) {
1293 // Update packet stats.
1295 boost::static_pointer_cast<Pkt4>(pkt4));
1296 }
1297 saveFirstPacket(pkt4);
1298}
1299
1300bool
1301TestControl::sendMessageFromAck(const uint16_t msg_type) {
1302 // We only permit Request or Release messages to be sent using this
1303 // function.
1304 if (msg_type != DHCPREQUEST && msg_type != DHCPRELEASE) {
1306 "invalid message type "
1307 << msg_type
1308 << " to be sent, expected DHCPREQUEST or DHCPRELEASE");
1309 }
1310
1311 // Get one of the recorded DHCPACK messages.
1312 Pkt4Ptr ack = ack_storage_.getRandom();
1313 if (!ack) {
1314 return (false);
1315 }
1316
1317 // Create message of the specified type.
1318 Pkt4Ptr msg = createMessageFromAck(msg_type, ack);
1319 setDefaults4(msg);
1320
1321 // Override relay address
1322 msg->setGiaddr(ack->getGiaddr());
1323
1324 // Add any extra options that user may have specified.
1325 addExtraOpts(msg);
1326
1327 // Pack it.
1328 msg->pack();
1329
1330 // And send it.
1331 socket_.send(msg);
1335 msg);
1336 return (true);
1337}
1338
1339
1340bool
1341TestControl::sendMessageFromReply(const uint16_t msg_type) {
1342 // We only permit Release or Renew messages to be sent using this function.
1343 if (msg_type != DHCPV6_RENEW && msg_type != DHCPV6_RELEASE) {
1344 isc_throw(isc::BadValue, "invalid message type " << msg_type
1345 << " to be sent, expected DHCPV6_RENEW or DHCPV6_RELEASE");
1346 }
1347
1348 // Get one of the recorded DHCPV6_OFFER messages.
1349 Pkt6Ptr reply = reply_storage_.getRandom();
1350 if (!reply) {
1351 return (false);
1352 }
1353 // Prepare the message of the specified type.
1354 Pkt6Ptr msg = createMessageFromReply(msg_type, reply);
1355 setDefaults6(msg);
1356
1357 // Add any extra options that user may have specified.
1358 addExtraOpts(msg);
1359
1360 // Pack it.
1361 msg->pack();
1362
1363 // And send it.
1364 socket_.send(msg);
1367 : ExchangeType::RL), msg);
1368 return (true);
1369}
1370
1371void
1373 const dhcp::Pkt4Ptr& offer_pkt4) {
1374 // Use the same transaction id as the one used in the discovery packet.
1375 const uint32_t transid = discover_pkt4->getTransid();
1376 Pkt4Ptr pkt4(new Pkt4(DHCPREQUEST, transid));
1377
1378 // Use first flags indicates that we want to use the server
1379 // id captured in first packet.
1380 if (options_.isUseFirst() &&
1381 (first_packet_serverid_.size() > 0)) {
1382 pkt4->addOption(Option::factory(Option::V4, DHO_DHCP_SERVER_IDENTIFIER,
1384 } else {
1385 OptionPtr opt_serverid =
1386 offer_pkt4->getOption(DHO_DHCP_SERVER_IDENTIFIER);
1387 if (!opt_serverid) {
1388 isc_throw(BadValue, "there is no SERVER_IDENTIFIER option "
1389 << "in OFFER message");
1390 }
1392 first_packet_serverid_ = opt_serverid->getData();
1393 }
1394 pkt4->addOption(opt_serverid);
1395 }
1396
1398 asiolink::IOAddress yiaddr = offer_pkt4->getYiaddr();
1399 if (!yiaddr.isV4()) {
1400 isc_throw(BadValue, "the YIADDR returned in OFFER packet is not "
1401 " IPv4 address");
1402 }
1403 OptionPtr opt_requested_address =
1405 OptionBuffer()));
1406 opt_requested_address->setUint32(yiaddr.toUint32());
1407 pkt4->addOption(opt_requested_address);
1408 OptionPtr opt_parameter_list =
1409 Option::factory(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST);
1410 pkt4->addOption(opt_parameter_list);
1411 // Set client's and server's ports as well as server's address
1412 setDefaults4(pkt4);
1413 // Override relay address
1414 pkt4->setGiaddr(offer_pkt4->getGiaddr());
1415 // Add any extra options that user may have specified.
1416 addExtraOpts(pkt4);
1417
1418 // Set hardware address
1419 pkt4->setHWAddr(offer_pkt4->getHWAddr());
1420 // Set client id.
1421 pkt4->addOption(generateClientId(pkt4->getHWAddr()));
1422 // Set elapsed time.
1423 uint32_t elapsed_time = getElapsedTime<Pkt4Ptr>(discover_pkt4, offer_pkt4);
1424 pkt4->setSecs(static_cast<uint16_t>(elapsed_time / 1000));
1425 // Prepare on wire data to send.
1426 pkt4->pack();
1427 socket_.send(pkt4);
1429 saveFirstPacket(pkt4);
1430}
1431
1432void
1433TestControl::sendRequest4(const std::vector<uint8_t>& template_buf,
1434 const dhcp::Pkt4Ptr& discover_pkt4,
1435 const dhcp::Pkt4Ptr& offer_pkt4) {
1436 // Get the second argument if multiple the same arguments specified
1437 // in the command line. Second one refers to REQUEST packets.
1438 const uint8_t arg_idx = 1;
1439 // Use the same transaction id as the one used in the discovery packet.
1440 const uint32_t transid = discover_pkt4->getTransid();
1441 // Get transaction id offset.
1442 size_t transid_offset = getTransactionIdOffset(arg_idx);
1443 // Get the offset of MAC's last octet.
1444 // We need to go back by HW_ETHER_LEN (MAC address length)
1445 // because this offset points to last octet of MAC address.
1446 size_t rand_offset = getRandomOffset(arg_idx) - HW_ETHER_LEN + 1;
1447 // Create temporary buffer from the template.
1448 std::vector<uint8_t> in_buf(template_buf.begin(),
1449 template_buf.end());
1450 // Check if given randomization offset is not out of bounds.
1451 if (rand_offset + HW_ETHER_LEN > in_buf.size()) {
1452 isc_throw(OutOfRange, "randomization offset is out of bounds");
1453 }
1454
1455 // Create packet from the temporary buffer.
1456 PerfPkt4Ptr pkt4(new PerfPkt4(&in_buf[0], in_buf.size(),
1457 transid_offset,
1458 transid));
1459
1460 // Set hardware address from OFFER packet received.
1461 HWAddrPtr hwaddr = offer_pkt4->getHWAddr();
1462 std::vector<uint8_t> mac_address(HW_ETHER_LEN, 0);
1463 uint8_t hw_len = hwaddr->hwaddr_.size();
1464 if (hw_len != 0) {
1465 memcpy(&mac_address[0], &hwaddr->hwaddr_[0],
1466 hw_len > HW_ETHER_LEN ? HW_ETHER_LEN : hw_len);
1467 }
1468 pkt4->writeAt(rand_offset, mac_address.begin(), mac_address.end());
1469
1470 // Set elapsed time.
1471 size_t elp_offset = getElapsedTimeOffset();
1472 uint32_t elapsed_time = getElapsedTime<Pkt4Ptr>(discover_pkt4, offer_pkt4);
1473 pkt4->writeValueAt<uint16_t>(elp_offset,
1474 static_cast<uint16_t>(elapsed_time / 1000));
1475
1476 // Get the actual server id offset.
1477 size_t sid_offset = getServerIdOffset();
1478 // Use first flags indicates that we want to use the server
1479 // id captured in first packet.
1480 if (options_.isUseFirst() &&
1481 (first_packet_serverid_.size() > 0)) {
1482 boost::shared_ptr<LocalizedOption>
1483 opt_serverid(new LocalizedOption(Option::V4,
1486 sid_offset));
1487 pkt4->addOption(opt_serverid);
1488 } else {
1489 // Copy the contents of server identifier received in
1490 // OFFER packet to put this into REQUEST.
1491 OptionPtr opt_serverid_offer =
1492 offer_pkt4->getOption(DHO_DHCP_SERVER_IDENTIFIER);
1493 if (!opt_serverid_offer) {
1494 isc_throw(BadValue, "there is no SERVER_IDENTIFIER option "
1495 << "in OFFER message");
1496 }
1497 boost::shared_ptr<LocalizedOption>
1498 opt_serverid(new LocalizedOption(Option::V4,
1500 opt_serverid_offer->getData(),
1501 sid_offset));
1502 pkt4->addOption(opt_serverid);
1504 first_packet_serverid_ = opt_serverid_offer->getData();
1505 }
1506 }
1507
1509 asiolink::IOAddress yiaddr = offer_pkt4->getYiaddr();
1510 if (!yiaddr.isV4()) {
1511 isc_throw(BadValue, "the YIADDR returned in OFFER packet is not "
1512 " IPv4 address");
1513 }
1514
1515 // Get the actual offset of requested ip.
1516 size_t rip_offset = getRequestedIpOffset();
1517 // Place requested IP option at specified position (rip_offset).
1518 boost::shared_ptr<LocalizedOption>
1519 opt_requested_ip(new LocalizedOption(Option::V4,
1521 OptionBuffer(),
1522 rip_offset));
1523 // The IOAddress is convertible to uint32_t and returns exactly what we need.
1524 opt_requested_ip->setUint32(yiaddr.toUint32());
1525 pkt4->addOption(opt_requested_ip);
1526
1527 setDefaults4(boost::static_pointer_cast<Pkt4>(pkt4));
1528
1529 // Add any extra options that user may have specified.
1530 addExtraOpts(pkt4);
1531
1532 // Prepare on-wire data.
1533 pkt4->rawPack();
1534 socket_.send(boost::static_pointer_cast<Pkt4>(pkt4));
1535 // Update packet stats.
1537 boost::static_pointer_cast<Pkt4>(pkt4));
1538 saveFirstPacket(pkt4);
1539}
1540
1541void
1542TestControl::sendRequest6(const Pkt6Ptr& advertise_pkt6) {
1543 const uint32_t transid = generateTransid();
1544 Pkt6Ptr pkt6(new Pkt6(DHCPV6_REQUEST, transid));
1545 // Set elapsed time.
1546 OptionPtr opt_elapsed_time =
1547 Option::factory(Option::V6, D6O_ELAPSED_TIME);
1548 pkt6->addOption(opt_elapsed_time);
1549 // Set client id.
1550 OptionPtr opt_clientid = advertise_pkt6->getOption(D6O_CLIENTID);
1551 if (!opt_clientid) {
1552 isc_throw(Unexpected, "client id not found in received packet");
1553 }
1554 pkt6->addOption(opt_clientid);
1555
1556 // Use first flags indicates that we want to use the server
1557 // id captured in first packet.
1558 if (options_.isUseFirst() &&
1559 (first_packet_serverid_.size() > 0)) {
1560 pkt6->addOption(Option::factory(Option::V6, D6O_SERVERID,
1562 } else {
1563 OptionPtr opt_serverid = advertise_pkt6->getOption(D6O_SERVERID);
1564 if (!opt_serverid) {
1565 isc_throw(Unexpected, "server id not found in received packet");
1566 }
1568 first_packet_serverid_ = opt_serverid->getData();
1569 }
1570 pkt6->addOption(opt_serverid);
1571 }
1572
1573 // Copy IA_NA or IA_PD option from the Advertise message to the Request
1574 // message being sent to the server. This will throw exception if the
1575 // option to be copied is not found. Note that this function will copy
1576 // one of IA_NA or IA_PD options, depending on the lease-type value
1577 // specified in the command line.
1578 copyIaOptions(advertise_pkt6, pkt6);
1579
1580 // Set default packet data.
1581 setDefaults6(pkt6);
1582
1583 // Add any extra options that user may have specified.
1584 addExtraOpts(pkt6);
1585
1586 // Prepare on-wire data.
1587 pkt6->pack();
1588 socket_.send(pkt6);
1590 saveFirstPacket(pkt6);
1591}
1592
1593void
1594TestControl::sendRequest6(const std::vector<uint8_t>& template_buf,
1595 const Pkt6Ptr& advertise_pkt6) {
1596 // Get the second argument if multiple the same arguments specified
1597 // in the command line. Second one refers to REQUEST packets.
1598 const uint8_t arg_idx = 1;
1599 // Generate transaction id.
1600 const uint32_t transid = generateTransid();
1601 // Get transaction id offset.
1602 size_t transid_offset = getTransactionIdOffset(arg_idx);
1603 PerfPkt6Ptr pkt6(new PerfPkt6(&template_buf[0], template_buf.size(),
1604 transid_offset, transid));
1605 // Set elapsed time.
1606 size_t elp_offset = getElapsedTimeOffset();
1607 boost::shared_ptr<LocalizedOption>
1608 opt_elapsed_time(new LocalizedOption(Option::V6, D6O_ELAPSED_TIME,
1609 OptionBuffer(), elp_offset));
1610 pkt6->addOption(opt_elapsed_time);
1611
1612 // Get the actual server id offset.
1613 size_t sid_offset = getServerIdOffset();
1614 // Use first flags indicates that we want to use the server
1615 // id captured in first packet.
1616 if (options_.isUseFirst() &&
1617 (first_packet_serverid_.size() > 0)) {
1618 boost::shared_ptr<LocalizedOption>
1619 opt_serverid(new LocalizedOption(Option::V6,
1622 sid_offset));
1623 pkt6->addOption(opt_serverid);
1624
1625 } else {
1626 // Copy the contents of server identifier received in
1627 // ADVERTISE packet to put this into REQUEST.
1628 OptionPtr opt_serverid_advertise =
1629 advertise_pkt6->getOption(D6O_SERVERID);
1630 if (!opt_serverid_advertise) {
1631 isc_throw(BadValue, "there is no SERVERID option "
1632 << "in ADVERTISE message");
1633 }
1634 boost::shared_ptr<LocalizedOption>
1635 opt_serverid(new LocalizedOption(Option::V6,
1637 opt_serverid_advertise->getData(),
1638 sid_offset));
1639 pkt6->addOption(opt_serverid);
1641 first_packet_serverid_ = opt_serverid_advertise->getData();
1642 }
1643 }
1644 // Set IA_NA
1645 boost::shared_ptr<Option6IA> opt_ia_na_advertise =
1646 boost::static_pointer_cast<Option6IA>(advertise_pkt6->getOption(D6O_IA_NA));
1647 if (!opt_ia_na_advertise) {
1648 isc_throw(Unexpected, "DHCPv6 IA_NA option not found in received "
1649 "packet");
1650 }
1651 size_t addr_offset = getRequestedIpOffset();
1652 boost::shared_ptr<LocalizedOption>
1653 opt_ia_na(new LocalizedOption(opt_ia_na_advertise, addr_offset));
1654 if (!opt_ia_na->valid()) {
1655 isc_throw(BadValue, "Option IA_NA in advertise packet is invalid");
1656 }
1657 pkt6->addOption(opt_ia_na);
1658 // Set server id.
1659 OptionPtr opt_serverid_advertise = advertise_pkt6->getOption(D6O_SERVERID);
1660 if (!opt_serverid_advertise) {
1661 isc_throw(Unexpected, "DHCPV6 SERVERID option not found in received "
1662 "packet");
1663 }
1664 size_t srvid_offset = getServerIdOffset();
1665 boost::shared_ptr<LocalizedOption>
1666 opt_serverid(new LocalizedOption(Option::V6, D6O_SERVERID,
1667 opt_serverid_advertise->getData(),
1668 srvid_offset));
1669 pkt6->addOption(opt_serverid);
1670 // Get randomization offset.
1671 size_t rand_offset = getRandomOffset(arg_idx);
1672 OptionPtr opt_clientid_advertise = advertise_pkt6->getOption(D6O_CLIENTID);
1673 if (!opt_clientid_advertise) {
1674 isc_throw(Unexpected, "DHCPV6 CLIENTID option not found in received packet");
1675 }
1676 rand_offset -= (opt_clientid_advertise->len() - 1);
1677 // Set client id.
1678 boost::shared_ptr<LocalizedOption>
1679 opt_clientid(new LocalizedOption(Option::V6, D6O_CLIENTID,
1680 opt_clientid_advertise->getData(),
1681 rand_offset));
1682 pkt6->addOption(opt_clientid);
1683 // Set default packet data.
1684 setDefaults6(pkt6);
1685
1686 // Add any extra options that user may have specified.
1687 addExtraOpts(pkt6);
1688
1689 // Prepare on wire data.
1690 pkt6->rawPack();
1691 // Send packet.
1692 socket_.send(pkt6);
1693 // Update packet stats.
1695
1696 // When 'T' diagnostics flag is specified it means that user requested
1697 // printing packet contents. It will be just one (first) packet which
1698 // contents will be printed. Here we check if this packet has been already
1699 // collected. If it hasn't we save this packet so as we can print its
1700 // contents when test is finished.
1701 if (options_.testDiags('T') &&
1704 }
1705}
1706
1707void
1708TestControl::sendSolicit6(const bool preload /*= false*/) {
1709 // Generate DUID to be passed to the packet
1710 uint8_t randomized = 0;
1711 std::vector<uint8_t> duid = generateDuid(randomized);
1712 // Generate transaction id to be set for the new exchange.
1713 const uint32_t transid = generateTransid();
1714 Pkt6Ptr pkt6(new Pkt6(DHCPV6_SOLICIT, transid));
1715 if (!pkt6) {
1716 isc_throw(Unexpected, "failed to create SOLICIT packet");
1717 }
1718
1719 // Check if we need to simulate HA failures by pretending no responses were received.
1720 // The DHCPv6 protocol signals that by increasing the elapsed option field. Note it is in 1/100 of a second.
1722 stats_mgr_.getTestPeriod().length().total_seconds() >= options_.getWaitForElapsedTime() &&
1723 stats_mgr_.getTestPeriod().length().total_seconds() < options_.getWaitForElapsedTime() +
1725
1726
1727 // Keep increasing elapsed time. The value should start increasing steadily.
1728 uint32_t val = (stats_mgr_.getTestPeriod().length().total_seconds() - options_.getWaitForElapsedTime() + 1)*100;
1729 if (val > 65535) {
1730 val = 65535;
1731 }
1732 OptionPtr elapsed(new OptionInt<uint16_t>(Option::V6, D6O_ELAPSED_TIME, val));
1733 pkt6->addOption(elapsed);
1734 } else {
1735 pkt6->addOption(Option::factory(Option::V6, D6O_ELAPSED_TIME));
1736 }
1737
1738 if (options_.isRapidCommit()) {
1739 pkt6->addOption(Option::factory(Option::V6, D6O_RAPID_COMMIT));
1740 }
1741 pkt6->addOption(Option::factory(Option::V6, D6O_CLIENTID, duid));
1742 pkt6->addOption(Option::factory(Option::V6, D6O_ORO));
1743
1744
1745 // Depending on the lease-type option specified, we should request
1746 // IPv6 address (with IA_NA) or IPv6 prefix (IA_PD) or both.
1747
1748 // IA_NA
1750 pkt6->addOption(Option::factory(Option::V6, D6O_IA_NA));
1751 }
1752 // IA_PD
1754 pkt6->addOption(Option::factory(Option::V6, D6O_IA_PD));
1755 }
1756
1757 setDefaults6(pkt6);
1758
1759 // Add any extra options that user may have specified.
1760 addExtraOpts(pkt6);
1761
1762 pkt6->pack();
1763 socket_.send(pkt6);
1764 if (!preload) {
1766 }
1767
1768 saveFirstPacket(pkt6);
1769}
1770
1771void
1772TestControl::sendSolicit6(const std::vector<uint8_t>& template_buf,
1773 const bool preload /*= false*/) {
1774 const int arg_idx = 0;
1775 // Get transaction id offset.
1776 size_t transid_offset = getTransactionIdOffset(arg_idx);
1777 // Generate transaction id to be set for the new exchange.
1778 const uint32_t transid = generateTransid();
1779 // Create packet.
1780 PerfPkt6Ptr pkt6(new PerfPkt6(&template_buf[0], template_buf.size(),
1781 transid_offset, transid));
1782 if (!pkt6) {
1783 isc_throw(Unexpected, "failed to create SOLICIT packet");
1784 }
1785 size_t rand_offset = getRandomOffset(arg_idx);
1786 // randomized will pick number of bytes randomized so we can
1787 // just use part of the generated duid and substitute a few bytes
1789 uint8_t randomized = 0;
1790 std::vector<uint8_t> duid = generateDuid(randomized);
1791 if (rand_offset > template_buf.size()) {
1792 isc_throw(OutOfRange, "randomization offset is out of bounds");
1793 }
1794 // Store random part of the DUID into the packet.
1795 pkt6->writeAt(rand_offset - randomized + 1,
1796 duid.end() - randomized, duid.end());
1797
1798 // Prepare on-wire data.
1799 pkt6->rawPack();
1800 setDefaults6(pkt6);
1801
1802 // Add any extra options that user may have specified.
1803 addExtraOpts(pkt6);
1804
1805 // Send solicit packet.
1806 socket_.send(pkt6);
1807 if (!preload) {
1808 // Update packet stats.
1810 }
1811 saveFirstPacket(pkt6);
1812}
1813
1814
1815void
1817 // Interface name.
1818 IfacePtr iface = socket_.getIface();
1819 if (iface == NULL) {
1820 isc_throw(BadValue, "unable to find interface with given index");
1821 }
1822 pkt->setIface(iface->getName());
1823 // Interface index.
1824 pkt->setIndex(socket_.ifindex_);
1825 // Local client's port (68)
1826 pkt->setLocalPort(DHCP4_CLIENT_PORT);
1827 // Server's port (67)
1828 if (options_.getRemotePort()) {
1829 pkt->setRemotePort(options_.getRemotePort());
1830 } else {
1831 pkt->setRemotePort(DHCP4_SERVER_PORT);
1832 }
1833 // The remote server's name or IP.
1834 pkt->setRemoteAddr(IOAddress(options_.getServerName()));
1835 // Set local address.
1836 pkt->setLocalAddr(IOAddress(socket_.addr_));
1837 // Set relay (GIADDR) address to local address if multiple
1838 // subnet mode is not enabled
1839 if (!options_.checkMultiSubnet()) {
1840 pkt->setGiaddr(IOAddress(socket_.addr_));
1841 } else {
1842 pkt->setGiaddr(IOAddress(options_.getRandRelayAddr()));
1843 }
1844 // Pretend that we have one relay (which is us).
1845 pkt->setHops(1);
1846}
1847
1848void
1850 // Interface name.
1851 IfacePtr iface = socket_.getIface();
1852 if (iface == NULL) {
1853 isc_throw(BadValue, "unable to find interface with given index");
1854 }
1855 pkt->setIface(iface->getName());
1856 // Interface index.
1857 pkt->setIndex(socket_.ifindex_);
1858 // Local client's port (547)
1859 pkt->setLocalPort(DHCP6_CLIENT_PORT);
1860 // Server's port (548)
1861 if (options_.getRemotePort()) {
1862 pkt->setRemotePort(options_.getRemotePort());
1863 } else {
1864 pkt->setRemotePort(DHCP6_SERVER_PORT);
1865 }
1866 // Set local address.
1867 pkt->setLocalAddr(socket_.addr_);
1868 // The remote server's name or IP.
1869 pkt->setRemoteAddr(IOAddress(options_.getServerName()));
1870
1871 // only act as a relay agent when told so.
1874 if (options_.isUseRelayedV6()) {
1875 Pkt6::RelayInfo relay_info;
1876 relay_info.msg_type_ = DHCPV6_RELAY_FORW;
1877 relay_info.hop_count_ = 0;
1878 if (options_.checkMultiSubnet()) {
1880 } else {
1881 relay_info.linkaddr_ = IOAddress(socket_.addr_);
1882 }
1883 relay_info.peeraddr_ = IOAddress(socket_.addr_);
1884 pkt->addRelayInfo(relay_info);
1885 }
1886}
1887
1888namespace {
1889
1890static OptionBuffer const concatenateBuffers(OptionBuffer const& a,
1891 OptionBuffer const& b) {
1892 OptionBuffer result;
1893 result.insert(result.end(), a.begin(), a.end());
1894 result.insert(result.end(), b.begin(), b.end());
1895 return result;
1896}
1897
1898static void mergeOptionIntoPacket(Pkt4Ptr const& packet,
1899 OptionPtr const& extra_option) {
1900 uint16_t const code(extra_option->getType());
1901 // If option already exists...
1902 OptionPtr const& option(packet->getOption(code));
1903 if (option) {
1904 switch (code) {
1905 // List here all the options for which we want to concatenate buffers.
1907 packet->delOption(code);
1908 packet->addOption(boost::make_shared<Option>(
1909 Option::V4, code,
1910 concatenateBuffers(option->getData(),
1911 extra_option->getData())));
1912 return;
1913 default:
1914 // For all others, add option as usual, it will result in "Option
1915 // already present in this message" error.
1916 break;
1917 }
1918 }
1919 packet->addOption(extra_option);
1920}
1921
1922} // namespace
1923
1924void
1926 // Add all extra options that the user may have specified.
1927 const dhcp::OptionCollection& extra_opts = options_.getExtraOpts();
1928 for (auto entry : extra_opts) {
1929 mergeOptionIntoPacket(pkt, entry.second);
1930 }
1931}
1932
1933void
1935 // Add all extra options that the user may have specified.
1936 const dhcp::OptionCollection& extra_opts = options_.getExtraOpts();
1937 for (auto entry : extra_opts) {
1938 pkt->addOption(entry.second);
1939 }
1940}
1941
1942} // namespace perfdhcp
1943} // namespace isc
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
A generic exception that is thrown if a function is called in a prohibited way.
A generic exception that is thrown when an object can not be found.
A generic exception that is thrown if a parameter given to a method would refer to or modify out-of-r...
A generic exception that is thrown when an unexpected error condition occurs.
isc::asiolink::IOAddress getAddress() const
Returns address contained within this option.
Class that represents IAPREFIX option in DHCPv6.
Forward declaration to OptionInt.
Definition: option_int.h:49
Universe
defines option universe DHCPv4 or DHCPv6
Definition: option.h:82
Represents DHCPv4 packet.
Definition: pkt4.h:37
Represents a DHCPv6 packet.
Definition: pkt6.h:44
Socket wrapper structure.
Definition: perf_socket.h:26
virtual dhcp::IfacePtr getIface()=0
See description of this method in PerfSocket class below.
uint16_t ifindex_
Interface index.
Definition: perf_socket.h:29
virtual bool send(const dhcp::Pkt4Ptr &pkt)=0
See description of this method in PerfSocket class below.
bool includes(const Type lease_type) const
Checks if lease type implies request for the address, prefix (or both) as specified by the function a...
bool testDiags(const char diag)
Find if diagnostic flag has been set.
std::string getRandRelayAddr()
Returns random relay address.
int getIncreaseElapsedTime() const
Returns increased elapsed time.
int getServerIdOffset() const
Returns template offset for server-ID.
std::string getWrapped() const
Returns wrapped command.
int getRenewRate() const
Returns a rate at which DHCPv6 Renew messages are sent.
uint8_t getIpVersion() const
Returns IP version.
std::vector< uint8_t > getDuidTemplate() const
Returns DUID template.
bool getAddrUnique() const
Returns address uniqueness value.
int getRate() const
Returns exchange rate.
std::string getCleanReportSeparator() const
Returns clean report separator.
bool isRapidCommit() const
Check if rapid commit option used.
bool checkMultiSubnet()
Check if multi subnet mode is enabled.
const isc::dhcp::OptionCollection & getExtraOpts() const
Returns extra options to be inserted.
bool isUseFirst() const
Check if server-ID to be taken from first package.
int getReportDelay() const
Returns delay between two performance reports.
std::vector< int > getRandomOffset() const
Returns template offsets for rnd.
int getRemotePort() const
Returns remote port number.
int getWaitForElapsedTime() const
Returns time to wait for elapsed time increase.
ExchangeMode
2-way (cmd line param -i) or 4-way exchanges
const MacAddrsVector & getMacsFromFile() const
Returns reference to a vector of MAC addresses read from a file.
std::vector< std::string > getTemplateFiles() const
Returns template file names.
std::vector< int > getTransactionIdOffset() const
brief Returns template offsets for xid.
std::vector< std::vector< uint8_t > > MacAddrsVector
A vector holding MAC addresses.
int getElapsedTimeOffset() const
Returns template offset for elapsed time.
std::string getServerName() const
Returns server name.
std::vector< int > getNumRequests() const
Returns maximum number of exchanges.
LeaseType getLeaseType() const
\ brief Returns the type of lease being requested.
bool isUseRelayedV6() const
Check if generated DHCPv6 messages should appear as relayed.
int getExitWaitTime() const
Returns the time in microseconds to delay the program by.
uint32_t getClientsNum() const
Returns number of simulated clients.
bool isSeeded() const
Checks if seed provided.
uint32_t getSeed() const
Returns random seed.
ExchangeMode getExchangeMode() const
Returns packet exchange mode.
void printCommandLine() const
Print command line arguments.
int getCleanReport() const
Returns clean report mode.
std::vector< uint8_t > getMacTemplate() const
Returns MAC address template.
int getRequestedIpOffset() const
Returns template offset for requested IP.
DHCP option at specific offset.
PerfPkt4 (DHCPv4 packet)
Definition: perf_pkt4.h:42
PerfPkt6 (DHCPv6 packet)
Definition: perf_pkt6.h:41
dhcp::PktPtr getPkt()
Get DHCP packet.
Definition: receiver.cc:58
void updateRejLeases(const ExchangeType xchg_type)
Increase total number of rejected leases.
void printStats() const
Print statistics counters for all exchange types.
void printCustomCounters() const
Print names and values of custom counters.
void updateNonUniqueAddrNum(const ExchangeType xchg_type)
Increase total number of non unique addresses.
uint64_t getRcvdPacketsNum(const ExchangeType xchg_type) const
Return total number of received packets.
bool hasExchangeStats(const ExchangeType xchg_type) const
Check if the exchange type has been specified.
void printIntermediateStats(bool clean_report, std::string clean_sep) const
Print intermediate statistics.
boost::posix_time::time_period getTestPeriod() const
Get time period since the start of test.
void passSentPacket(const ExchangeType xchg_type, const dhcp::PktPtr &packet)
Adds new packet to the sent packets list.
dhcp::PktPtr passRcvdPacket(const ExchangeType xchg_type, const dhcp::PktPtr &packet)
Add new received packet and match with sent packet.
Sequential numbers generator class.
Definition: test_control.h:158
void saveFirstPacket(const dhcp::Pkt4Ptr &pkt)
Save the first DHCPv4 sent packet of the specified type.
void address6Uniqueness(const dhcp::Pkt6Ptr &pkt6, ExchangeType xchg_type)
Process received v6 addresses uniqueness.
static const uint8_t HW_ETHER_LEN
Length of the Ethernet HW address (MAC) in bytes.
Definition: test_control.h:190
bool waitToExit()
Delay the exit by a fixed given time to catch up to all exchanges that were already started.
Definition: test_control.cc:48
std::map< uint8_t, dhcp::Pkt4Ptr > template_packets_v4_
First packets send.
bool sendMessageFromReply(const uint16_t msg_type)
Send DHCPv6 Renew or Release message.
void addExtraOpts(const dhcp::Pkt4Ptr &pkt4)
Inserts extra options specified by user.
void printDiagnostics() const
Print main diagnostics data.
static void handleChild(int sig)
Handle child signal.
void registerOptionFactories4() const
Register option factory functions for DHCPv4.
NumberGeneratorPtr transid_gen_
Transaction id generator.
NumberGeneratorPtr macaddr_gen_
Numbers generator for MAC address.
int getRequestedIpOffset() const
Return requested ip offset in a packet.
boost::shared_ptr< NumberGenerator > NumberGeneratorPtr
The default generator pointer.
Definition: test_control.h:155
uint64_t sendMultipleMessages4(const uint32_t msg_type, const uint64_t msg_num)
Send number of DHCPREQUEST (renew) messages to a server.
bool validateIA(const dhcp::Pkt6Ptr &pkt6)
Process IA in received DHCPv6 packet.
dhcp::Pkt4Ptr createMessageFromAck(const uint16_t msg_type, const dhcp::Pkt4Ptr &ack)
Creates DHCPREQUEST from a DHCPACK message.
static bool interrupted_
Program interrupted flag.
void readPacketTemplate(const std::string &file_name)
Read DHCP message template from file.
TemplateBuffer getTemplateBuffer(const size_t idx) const
Return template buffer.
std::vector< uint8_t > generateMacAddress(uint8_t &randomized)
Generate MAC address.
void setDefaults4(const dhcp::Pkt4Ptr &pkt)
Set default DHCPv4 packet parameters.
boost::posix_time::ptime exit_time_
Initialized at first exit condition with the time perfdhcp should exit.
Definition: test_control.h:343
CommandOptions & options_
Command options.
Receiver receiver_
Receiver used to receive DHCP traffic.
static std::string vector2Hex(const std::vector< uint8_t > &vec, const std::string &separator="")
Convert vector in hexadecimal string.
uint64_t sendMultipleMessages6(const uint32_t msg_type, const uint64_t msg_num)
Send number of DHCPv6 Renew or Release messages to the server.
void setMacAddrGenerator(const NumberGeneratorPtr &generator)
Set new MAC address generator.
Definition: test_control.h:206
void setDefaults6(const dhcp::Pkt6Ptr &pkt)
Set default DHCPv6 packet parameters.
boost::posix_time::ptime last_report_
Last intermediate report time.
bool haveAllPacketsBeenReceived() const
Checks if all expected packets were already received.
Definition: test_control.cc:69
void cleanCachedPackets()
Removes cached DHCPv6 Reply packets every second.
Definition: test_control.cc:96
void processReceivedPacket4(const dhcp::Pkt4Ptr &pkt4)
Process received DHCPv4 packet.
void sendRequest6(const dhcp::Pkt6Ptr &advertise_pkt6)
Send DHCPv6 REQUEST message.
TestControl(CommandOptions &options, BasePerfSocket &socket)
Default constructor.
static dhcp::OptionPtr factoryOptionRequestOption6(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create DHCPv6 ORO option.
void sendSolicit6(const bool preload=false)
Send DHCPv6 SOLICIT message.
static dhcp::OptionPtr factoryIapd6(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create IA_PD option.
std::map< uint8_t, dhcp::Pkt6Ptr > template_packets_v6_
Template for v6.
static dhcp::OptionPtr factoryRapidCommit6(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create DHCPv6 RAPID_COMMIT option instance.
PacketStorage< dhcp::Pkt6 > reply_storage_
Storage for reply messages.
void registerOptionFactories6() const
Register option factory functions for DHCPv6.
void sendPackets(const uint64_t packets_num, const bool preload=false)
Send number of packets to initiate new exchanges.
void registerOptionFactories() const
Register option factory functions for DHCPv4 or DHCPv6.
UniformRandomIntegerGenerator number_generator_
Generate uniformly distributed integers in range of [min, max].
Definition: test_control.h:351
std::vector< uint8_t > TemplateBuffer
Packet template buffer.
Definition: test_control.h:124
bool sendMessageFromAck(const uint16_t msg_type)
Send DHCPv4 renew (DHCPREQUEST).
void runWrapped(bool do_stop=false) const
Run wrapped command.
void processReceivedPacket6(const dhcp::Pkt6Ptr &pkt6)
Process received DHCPv6 packet.
uint32_t getElapsedTime(const T &pkt1, const T &pkt2)
Calculate elapsed time between two packets.
BasePerfSocket & socket_
Socket used for DHCP traffic.
void reset()
Resets internal state of the object.
void addUniqeAddr(const std::set< std::string > &current, ExchangeType xchg_type)
add unique address to already assigned list.
Definition: test_control.h:614
void address4Uniqueness(const dhcp::Pkt4Ptr &pkt4, ExchangeType xchg_type)
Process received v4 addresses uniqueness.
int getRandomOffset(const int arg_idx) const
Return randomization offset in a packet.
dhcp::Pkt6Ptr createMessageFromReply(const uint16_t msg_type, const dhcp::Pkt6Ptr &reply)
Creates DHCPv6 message from the Reply packet.
int getElapsedTimeOffset() const
Return elapsed time offset in a packet.
static std::string byte2Hex(const uint8_t b)
Convert binary value to hex string.
void printTemplates() const
Print templates information.
void sendRequest4(const dhcp::Pkt4Ptr &discover_pkt4, const dhcp::Pkt4Ptr &offer_pkt4)
Send DHCPv4 REQUEST message.
unsigned int consumeReceivedPackets()
Pull packets from receiver and process them.
TemplateBufferCollection template_buffers_
Packet template buffers.
StatsMgr stats_mgr_
Statistics Manager.
void printStats() const
Print performance statistics.
PacketStorage< dhcp::Pkt4 > ack_storage_
Storage for DHCPACK messages.
void copyIaOptions(const dhcp::Pkt6Ptr &pkt_from, dhcp::Pkt6Ptr &pkt_to)
Copies IA_NA or IA_PD option from one packet to another.
void setTransidGenerator(const NumberGeneratorPtr &generator)
Set new transaction id generator.
Definition: test_control.h:195
static dhcp::OptionPtr factoryGeneric(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create generic option.
static dhcp::OptionPtr factoryRequestList4(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create DHCPv4 Request List option.
static dhcp::OptionPtr factoryElapsedTime6(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create DHCPv6 ELAPSED_TIME option.
static void handleInterrupt(int sig)
Handle interrupt signal.
int getTransactionIdOffset(const int arg_idx) const
Return transaction id offset in a packet.
void initPacketTemplates()
Reads packet templates from files.
void printRate() const
Print rate statistics.
void printIntermediateStats()
Print intermediate statistics.
void printTemplate(const uint8_t packet_type) const
Print template information.
int getServerIdOffset() const
Return server id offset in a packet.
std::vector< uint8_t > generateDuid(uint8_t &randomized)
Generate DUID.
void sendDiscover4(const bool preload=false)
Send DHCPv4 DISCOVER message.
dhcp::OptionPtr generateClientId(const dhcp::HWAddrPtr &hwaddr) const
Generate DHCPv4 client identifier from HW address.
dhcp::OptionBuffer first_packet_serverid_
Buffer holding server id received in first packet.
uint32_t generateTransid()
generate transaction id.
Definition: test_control.h:537
static dhcp::OptionPtr factoryIana6(dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)
Factory function to create IA_NA option.
The OutputBuffer class is a buffer abstraction for manipulating mutable data.
Definition: buffer.h:294
size_t getLength() const
Return the length of data written in the buffer.
Definition: buffer.h:403
const void * getData() const
Return a pointer to the head of the data stored in the buffer.
Definition: buffer.h:401
@ D6O_SERVERID
Definition: dhcp6.h:22
@ D6O_CLIENTID
Definition: dhcp6.h:21
@ D6O_NAME_SERVERS
Definition: dhcp6.h:43
@ D6O_RAPID_COMMIT
Definition: dhcp6.h:34
@ D6O_IA_NA
Definition: dhcp6.h:23
@ D6O_ORO
Definition: dhcp6.h:26
@ D6O_IA_PD
Definition: dhcp6.h:45
@ D6O_DOMAIN_SEARCH
Definition: dhcp6.h:44
@ D6O_IAADDR
Definition: dhcp6.h:25
@ D6O_ELAPSED_TIME
Definition: dhcp6.h:28
@ D6O_IAPREFIX
Definition: dhcp6.h:46
@ DHCPV6_ADVERTISE
Definition: dhcp6.h:205
@ DHCPV6_REQUEST
Definition: dhcp6.h:206
@ DHCPV6_RENEW
Definition: dhcp6.h:208
@ DHCPV6_REPLY
Definition: dhcp6.h:210
@ DHCPV6_SOLICIT
Definition: dhcp6.h:204
@ DHCPV6_RELEASE
Definition: dhcp6.h:211
@ DHCPV6_RELAY_FORW
Definition: dhcp6.h:215
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
ElementPtr copy(ConstElementPtr from, int level)
Copy the data up to a nesting level.
Definition: data.cc:1152
boost::shared_ptr< Element > ElementPtr
Definition: data.h:24
boost::shared_ptr< isc::dhcp::Pkt > PktPtr
A pointer to either Pkt4 or Pkt6 packet.
Definition: pkt.h:797
@ DHO_SUBNET_MASK
Definition: dhcp4.h:70
@ DHO_ROUTERS
Definition: dhcp4.h:72
@ DHO_DOMAIN_NAME
Definition: dhcp4.h:84
@ DHO_DOMAIN_NAME_SERVERS
Definition: dhcp4.h:75
@ DHO_DHCP_MESSAGE_TYPE
Definition: dhcp4.h:122
@ DHO_DHCP_SERVER_IDENTIFIER
Definition: dhcp4.h:123
@ DHO_HOST_NAME
Definition: dhcp4.h:81
@ DHO_DHCP_CLIENT_IDENTIFIER
Definition: dhcp4.h:130
@ DHO_DHCP_REQUESTED_ADDRESS
Definition: dhcp4.h:119
@ DHO_TIME_OFFSET
Definition: dhcp4.h:71
@ DHO_DHCP_PARAMETER_REQUEST_LIST
Definition: dhcp4.h:124
@ DHO_BROADCAST_ADDRESS
Definition: dhcp4.h:97
boost::shared_ptr< Pkt4 > Pkt4Ptr
A pointer to Pkt4 object.
Definition: pkt4.h:544
boost::shared_ptr< Iface > IfacePtr
Type definition for the pointer to an Iface object.
Definition: iface_mgr.h:463
std::multimap< unsigned int, OptionPtr > OptionCollection
A collection of DHCP (v4 or v6) options.
Definition: option.h:40
boost::shared_ptr< Option6IAPrefix > Option6IAPrefixPtr
Pointer to the Option6IAPrefix object.
boost::shared_ptr< HWAddr > HWAddrPtr
Shared pointer to a hardware address structure.
Definition: hwaddr.h:154
boost::shared_ptr< Option6IAAddr > Option6IAAddrPtr
A pointer to the isc::dhcp::Option6IAAddr object.
@ DHCPREQUEST
Definition: dhcp4.h:232
@ DHCPOFFER
Definition: dhcp4.h:231
@ DHCPRELEASE
Definition: dhcp4.h:236
@ DHCPDISCOVER
Definition: dhcp4.h:230
@ DHCPACK
Definition: dhcp4.h:234
boost::shared_ptr< Pkt6 > Pkt6Ptr
A pointer to Pkt6 packet.
Definition: pkt6.h:28
std::vector< uint8_t > OptionBuffer
buffer types used in DHCP code.
Definition: option.h:24
@ HTYPE_ETHER
Ethernet 10Mbps.
Definition: dhcp4.h:56
boost::shared_ptr< Option > OptionPtr
Definition: option.h:36
boost::shared_ptr< PerfPkt4 > PerfPkt4Ptr
Definition: perf_pkt4.h:128
ExchangeType
DHCP packet exchange types.
@ RA
DHCPv4 REQUEST-ACK.
@ SA
DHCPv6 SOLICIT-ADVERTISE.
@ RNA
DHCPv4 REQUEST-ACK (renewal)
@ RL
DHCPv6 RELEASE-REPLY.
@ RN
DHCPv6 RENEW-REPLY.
@ DO
DHCPv4 DISCOVER-OFFER.
@ RR
DHCPv6 REQUEST-REPLY.
boost::shared_ptr< PerfPkt6 > PerfPkt6Ptr
Definition: perf_pkt6.h:127
Defines the logger used by the top-level component of kea-lfc.
structure that describes a single relay information
Definition: pkt6.h:85
uint8_t msg_type_
message type (RELAY-FORW oro RELAY-REPL)
Definition: pkt6.h:94
isc::asiolink::IOAddress linkaddr_
fixed field in relay-forw/relay-reply
Definition: pkt6.h:96
uint8_t hop_count_
number of traversed relays (up to 32)
Definition: pkt6.h:95
isc::asiolink::IOAddress peeraddr_
fixed field in relay-forw/relay-reply
Definition: pkt6.h:97
isc::asiolink::IOAddress addr_
Definition: socket_info.h:21