dhcp4_srv_unittest.cc 40 KB
Newer Older
Tomek Mrugalski's avatar
Tomek Mrugalski committed
1
// Copyright (C) 2011-2013  Internet Systems Consortium, Inc. ("ISC")
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#include <config.h>
#include <sstream>

18
#include <asiolink/io_address.h>
19 20
#include <dhcp/dhcp4.h>
#include <dhcp/option.h>
21 22
#include <dhcp/option4_addrlst.h>
#include <dhcp/option_int_array.h>
23
#include <dhcp4/dhcp4_srv.h>
Tomek Mrugalski's avatar
Tomek Mrugalski committed
24
#include <dhcp4/dhcp4_log.h>
25 26 27 28
#include <dhcpsrv/cfgmgr.h>
#include <dhcpsrv/lease_mgr.h>
#include <dhcpsrv/lease_mgr_factory.h>
#include <dhcpsrv/utils.h>
29 30 31 32 33 34
#include <gtest/gtest.h>

#include <fstream>
#include <iostream>

#include <arpa/inet.h>
35 36 37 38

using namespace std;
using namespace isc;
using namespace isc::dhcp;
39
using namespace isc::asiolink;
40 41 42 43

namespace {

class NakedDhcpv4Srv: public Dhcpv4Srv {
44
    // "Naked" DHCPv4 server, exposes internal fields
45
public:
46 47 48 49 50 51 52 53 54
    NakedDhcpv4Srv(uint16_t port = 0):Dhcpv4Srv(port) { }

    using Dhcpv4Srv::processDiscover;
    using Dhcpv4Srv::processRequest;
    using Dhcpv4Srv::processRelease;
    using Dhcpv4Srv::processDecline;
    using Dhcpv4Srv::processInform;
    using Dhcpv4Srv::getServerID;
    using Dhcpv4Srv::sanityCheck;
55 56 57 58
};

class Dhcpv4SrvTest : public ::testing::Test {
public:
59 60 61 62 63

    /// @brief Constructor
    ///
    /// Initializes common objects used in many tests.
    /// Also sets up initial configuration in CfgMgr.
64
    Dhcpv4SrvTest() {
65 66 67 68 69 70 71
        subnet_ = Subnet4Ptr(new Subnet4(IOAddress("192.0.2.0"), 24, 1000,
                                         2000, 3000));
        pool_ = Pool4Ptr(new Pool4(IOAddress("192.0.2.100"), IOAddress("192.0.2.110")));
        subnet_->addPool(pool_);

        CfgMgr::instance().deleteSubnets4();
        CfgMgr::instance().addSubnet4(subnet_);
72
    }
73

74 75 76
    /// @brief checks that the response matches request
    /// @param q query (client's message)
    /// @param a answer (server's message)
77
    void messageCheck(const boost::shared_ptr<Pkt4>& q,
78 79 80 81 82 83 84 85 86
                      const boost::shared_ptr<Pkt4>& a) {
        ASSERT_TRUE(q);
        ASSERT_TRUE(a);

        EXPECT_EQ(q->getHops(),   a->getHops());
        EXPECT_EQ(q->getIface(),  a->getIface());
        EXPECT_EQ(q->getIndex(),  a->getIndex());
        EXPECT_EQ(q->getGiaddr(), a->getGiaddr());

87
        // Check that bare minimum of required options are there
88 89 90 91 92 93 94 95 96
        EXPECT_TRUE(a->getOption(DHO_SUBNET_MASK));
        EXPECT_TRUE(a->getOption(DHO_ROUTERS));
        EXPECT_TRUE(a->getOption(DHO_DHCP_SERVER_IDENTIFIER));
        EXPECT_TRUE(a->getOption(DHO_DHCP_LEASE_TIME));
        EXPECT_TRUE(a->getOption(DHO_SUBNET_MASK));
        EXPECT_TRUE(a->getOption(DHO_ROUTERS));
        EXPECT_TRUE(a->getOption(DHO_DOMAIN_NAME));
        EXPECT_TRUE(a->getOption(DHO_DOMAIN_NAME_SERVERS));

97
        // Check that something is offered
98 99 100
        EXPECT_TRUE(a->getYiaddr().toText() != "0.0.0.0");
    }

101 102 103 104 105 106 107 108
    /// @brief generates client-id option
    ///
    /// Generate client-id option of specified length
    /// Ids with different lengths are sufficent to generate
    /// unique ids. If more fine grained control is required,
    /// tests generate client-ids on their own.
    /// Sets client_id_ field.
    /// @param size size of the client-id to be generated
109 110 111 112 113 114 115 116 117 118 119 120 121 122
    OptionPtr generateClientId(size_t size = 4) {

        OptionBuffer clnt_id(size);
        for (int i = 0; i < size; i++) {
            clnt_id[i] = 100 + i;
        }

        client_id_ = ClientIdPtr(new ClientId(clnt_id));

        return (OptionPtr(new Option(Option::V4, DHO_DHCP_CLIENT_IDENTIFIER,
                                     clnt_id.begin(),
                                     clnt_id.begin() + size)));
    }

123 124 125 126
    /// @brief generate hardware address
    ///
    /// @param size size of the generated MAC address
    /// @param pointer to Hardware Address object
Tomek Mrugalski's avatar
Tomek Mrugalski committed
127
    HWAddrPtr generateHWAddr(size_t size = 6) {
128
        const uint8_t hw_type = 123; // Just a fake number (typically 6=HTYPE_ETHER, see dhcp4.h)
Tomek Mrugalski's avatar
Tomek Mrugalski committed
129 130 131 132 133 134 135
        OptionBuffer mac(size);
        for (int i = 0; i < size; ++i) {
            mac[i] = 50 + i;
        }
        return (HWAddrPtr(new HWAddr(mac, hw_type)));
    }

136 137 138 139 140 141
    /// Check that address was returned from proper range, that its lease
    /// lifetime is correct, that T1 and T2 are returned properly
    /// @param rsp response to be checked
    /// @param subnet subnet that should be used to verify assigned address and options
    /// @param t1_mandatory is T1 mandatory?
    /// @param t2_mandatory is T2 mandatory?
142 143 144 145 146 147 148 149 150
    void checkAddressParams(const Pkt4Ptr& rsp, const SubnetPtr subnet,
                            bool t1_mandatory = false, bool t2_mandatory = false) {

        // Technically inPool implies inRange, but let's be on the safe
        // side and check both.
        EXPECT_TRUE(subnet->inRange(rsp->getYiaddr()));
        EXPECT_TRUE(subnet->inPool(rsp->getYiaddr()));

        // Check lease time
151 152
        OptionPtr opt = rsp->getOption(DHO_DHCP_LEASE_TIME);
        if (!opt) {
153 154
            ADD_FAILURE() << "Lease time option missing in response";
        } else {
155
            EXPECT_EQ(opt->getUint32(), subnet->getValid());
156 157 158
        }

        // Check T1 timer
159 160 161
        opt = rsp->getOption(DHO_DHCP_RENEWAL_TIME);
        if (opt) {
            EXPECT_EQ(opt->getUint32(), subnet->getT1());
162 163 164 165 166 167 168
        } else {
            if (t1_mandatory) {
                ADD_FAILURE() << "Required T1 option missing";
            }
        }

        // Check T2 timer
169 170 171
        opt = rsp->getOption(DHO_DHCP_REBINDING_TIME);
        if (opt) {
            EXPECT_EQ(opt->getUint32(), subnet->getT2());
172 173 174 175 176 177 178
        } else {
            if (t1_mandatory) {
                ADD_FAILURE() << "Required T2 option missing";
            }
        }
    }

179 180 181 182 183
    /// @brief Basic checks for generated response (message type and trans-id).
    ///
    /// @param rsp response packet to be validated
    /// @param expected_message_type expected message type
    /// @param expected_transid expected transaction-id
184 185 186 187 188 189 190
    void checkResponse(const Pkt4Ptr& rsp, uint8_t expected_message_type,
                       uint32_t expected_transid) {
        ASSERT_TRUE(rsp);
        EXPECT_EQ(expected_message_type, rsp->getType());
        EXPECT_EQ(expected_transid, rsp->getTransid());
    }

191 192 193 194 195 196
    /// @brief Checks if the lease sent to client is present in the database
    ///
    /// @param rsp response packet to be validated
    /// @param client_id expected client-identifier (or NULL)
    /// @param HWAddr expected hardware address (not used now)
    /// @param expected_addr expected address
197
    Lease4Ptr checkLease(const Pkt4Ptr& rsp, const OptionPtr& client_id,
198
                         const HWAddrPtr&, const IOAddress& expected_addr) {
199 200 201 202 203 204 205 206 207 208 209 210 211 212

        ClientIdPtr id;
        if (client_id) {
            OptionBuffer data = client_id->getData();
            id.reset(new ClientId(data));
        }

        Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(expected_addr);
        if (!lease) {
            cout << "Lease for " << expected_addr.toText()
                 << " not found in the database backend.";
            return (Lease4Ptr());
        }

213 214
        EXPECT_EQ(rsp->getYiaddr().toText(), expected_addr.toText());

215 216 217 218 219 220 221 222 223
        EXPECT_EQ(expected_addr.toText(), lease->addr_.toText());
        if (client_id) {
            EXPECT_TRUE(*lease->client_id_ == *id);
        }
        EXPECT_EQ(subnet_->getID(), lease->subnet_id_);

        return (lease);
    }

224 225 226
    /// @brief Checks if server response (OFFER, ACK, NAK) includes proper server-id
    /// @param rsp response packet to be validated
    /// @param expected_srvid expected value of server-id
227
    void checkServerId(const Pkt4Ptr& rsp, const OptionPtr& expected_srvid) {
228 229 230 231 232 233
        // Check that server included its server-id
        OptionPtr opt = rsp->getOption(DHO_DHCP_SERVER_IDENTIFIER);
        ASSERT_TRUE(opt);
        EXPECT_EQ(opt->getType(), expected_srvid->getType() );
        EXPECT_EQ(opt->len(), expected_srvid->len() );
        EXPECT_TRUE(opt->getData() == expected_srvid->getData());
234 235
    }

236 237 238
    /// @brief Checks if server response (OFFER, ACK, NAK) includes proper client-id
    /// @param rsp response packet to be validated
    /// @param expected_clientid expected value of client-id
239 240
    void checkClientId(const Pkt4Ptr& rsp, const OptionPtr& expected_clientid) {
        // check that server included our own client-id
241 242 243 244 245
        OptionPtr opt = rsp->getOption(DHO_DHCP_CLIENT_IDENTIFIER);
        ASSERT_TRUE(opt);
        EXPECT_EQ(expected_clientid->getType(), opt->getType());
        EXPECT_EQ(expected_clientid->len(), opt->len());
        EXPECT_TRUE(expected_clientid->getData() == opt->getData());
246 247
    }

248
    ~Dhcpv4SrvTest() {
249
        CfgMgr::instance().deleteSubnets4();
250
    };
251

252
    /// @brief A subnet used in most tests
253 254
    Subnet4Ptr subnet_;

255
    /// @brief A pool used in most tests
256 257
    Pool4Ptr pool_;

258
    /// @brief A client-id used in most tests
259
    ClientIdPtr client_id_;
260 261
};

Tomek Mrugalski's avatar
Tomek Mrugalski committed
262 263
// Sanity check. Verifies that both Dhcpv4Srv and its derived
// class NakedDhcpv4Srv can be instantiated and destroyed.
264 265
TEST_F(Dhcpv4SrvTest, basic) {

266
    // Check that the base class can be instantiated
267
    Dhcpv4Srv* srv = NULL;
268
    ASSERT_NO_THROW({
Tomek Mrugalski's avatar
Tomek Mrugalski committed
269
        srv = new Dhcpv4Srv(DHCP4_SERVER_PORT + 10000);
270
    });
271 272
    delete srv;

273
    // Check that the derived class can be instantiated
274 275 276 277 278
    NakedDhcpv4Srv* naked_srv = NULL;
    ASSERT_NO_THROW({
        naked_srv = new NakedDhcpv4Srv(DHCP4_SERVER_PORT + 10000);
    });
    EXPECT_TRUE(naked_srv->getServerID());
279
    delete naked_srv;
280 281 282 283 284

    ASSERT_NO_THROW({
        naked_srv = new NakedDhcpv4Srv(0);
    });
    EXPECT_TRUE(naked_srv->getServerID());
285

Tomek Mrugalski's avatar
Tomek Mrugalski committed
286
    delete naked_srv;
287 288
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
289 290 291 292 293 294 295 296
// Verifies that received DISCOVER can be processed correctly,
// that the OFFER message generated in response is valid and
// contains necessary options.
//
// Note: this test focuses on the packet correctness. There
// are other tests that verify correctness of the allocation
// engine. See DiscoverBasic, DiscoverHint, DiscoverNoClientId
// and DiscoverInvalidHint.
297
TEST_F(Dhcpv4SrvTest, processDiscover) {
298
    NakedDhcpv4Srv* srv = new NakedDhcpv4Srv(0);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
299
    vector<uint8_t> mac(6);
300 301 302
    for (int i = 0; i < 6; i++) {
        mac[i] = 255 - i;
    }
303 304

    boost::shared_ptr<Pkt4> pkt(new Pkt4(DHCPDISCOVER, 1234));
305 306 307 308 309 310 311 312
    boost::shared_ptr<Pkt4> offer;

    pkt->setIface("eth0");
    pkt->setIndex(17);
    pkt->setHWAddr(1, 6, mac);
    pkt->setRemoteAddr(IOAddress("192.0.2.56"));
    pkt->setGiaddr(IOAddress("192.0.2.67"));

Tomek Mrugalski's avatar
Tomek Mrugalski committed
313
    // Let's make it a relayed message
314 315
    pkt->setHops(3);
    pkt->setRemotePort(DHCP4_SERVER_PORT);
316

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
    // We are going to test that certain options are returned
    // in the OFFER message when requested using 'Parameter
    // Request List' option. Let's configure those options that
    // are returned when requested.
    OptionPtr option_log_servers(new Option4AddrLst(DHO_LOG_SERVERS));
    ASSERT_NO_THROW(subnet_->addOption(option_log_servers, false, "dhcp4"));
    OptionPtr option_cookie_servers(new Option4AddrLst(DHO_COOKIE_SERVERS));
    ASSERT_NO_THROW(subnet_->addOption(option_cookie_servers, false, "dhcp4"));

    // Add 'Parameter Request List' option. In this option we are going
    // specify which options we request to be retured in the OFFER
    // message.
    OptionUint8ArrayPtr option_prl =
        OptionUint8ArrayPtr(new OptionUint8Array(Option::V4,
                                                 DHO_DHCP_PARAMETER_REQUEST_LIST));

    std::vector<uint8_t> opts;
    // Let's request options that have been configured for the subnet.
    opts.push_back(DHO_LOG_SERVERS);
    opts.push_back(DHO_COOKIE_SERVERS);
    // Let's also request the option that hasn't been configured. In such
    // case server should ignore request for this particular option.
    opts.push_back(DHO_LPR_SERVERS);
    // Put the requested option codes into the 'Parameter Request List'.
    option_prl->setValues(opts);
    // And add 'Parameter Request List' option into the DISCOVER packet.
    pkt->addOption(option_prl);

Tomek Mrugalski's avatar
Tomek Mrugalski committed
345
    // Should not throw
346
    EXPECT_NO_THROW(
347
        offer = srv->processDiscover(pkt);
348 349
    );

Tomek Mrugalski's avatar
Tomek Mrugalski committed
350
    // Should return something
351 352 353 354
    ASSERT_TRUE(offer);

    EXPECT_EQ(DHCPOFFER, offer->getType());

Tomek Mrugalski's avatar
Tomek Mrugalski committed
355
    // This is relayed message. It should be sent back to relay address.
356 357
    EXPECT_EQ(pkt->getGiaddr(), offer->getRemoteAddr());

358
    messageCheck(pkt, offer);
359

Tomek Mrugalski's avatar
Tomek Mrugalski committed
360
    // Now repeat the test for directly sent message
361 362 363 364 365 366 367 368
    pkt->setHops(0);
    pkt->setGiaddr(IOAddress("0.0.0.0"));
    pkt->setRemotePort(DHCP4_CLIENT_PORT);

    EXPECT_NO_THROW(
        offer = srv->processDiscover(pkt);
    );

Tomek Mrugalski's avatar
Tomek Mrugalski committed
369
    // Should return something
370 371 372 373
    ASSERT_TRUE(offer);

    EXPECT_EQ(DHCPOFFER, offer->getType());

Tomek Mrugalski's avatar
Tomek Mrugalski committed
374
    // This is direct message. It should be sent back to origin, not
375 376 377
    // to relay.
    EXPECT_EQ(pkt->getRemoteAddr(), offer->getRemoteAddr());

378 379 380 381 382 383 384 385 386
    messageCheck(pkt, offer);

    // Check that the requested and configured options are returned
    // in the OFFER message.
    EXPECT_TRUE(offer->getOption(DHO_LOG_SERVERS));
    EXPECT_TRUE(offer->getOption(DHO_COOKIE_SERVERS));
    // Check that the requested but not configured options are not
    // returned in the OFFER message.
    EXPECT_FALSE(offer->getOption(DHO_LPR_SERVERS));
387 388 389 390

    delete srv;
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
391 392 393 394 395 396 397
// Verifies that received REQUEST can be processed correctly,
// that the ACK message generated in response is valid and
// contains necessary options.
//
// Note: this test focuses on the packet correctness. There
// are other tests that verify correctness of the allocation
// engine. See RequestBasic.
398
TEST_F(Dhcpv4SrvTest, processRequest) {
399
    NakedDhcpv4Srv* srv = new NakedDhcpv4Srv(0);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
400
    vector<uint8_t> mac(6);
401 402 403 404 405 406
    for (int i = 0; i < 6; i++) {
        mac[i] = i*10;
    }

    boost::shared_ptr<Pkt4> req(new Pkt4(DHCPREQUEST, 1234));
    boost::shared_ptr<Pkt4> ack;
407

408 409 410 411 412
    req->setIface("eth0");
    req->setIndex(17);
    req->setHWAddr(1, 6, mac);
    req->setRemoteAddr(IOAddress("192.0.2.56"));
    req->setGiaddr(IOAddress("192.0.2.67"));
413

414
    // Should not throw
415 416 417 418
    ASSERT_NO_THROW(
        ack = srv->processRequest(req);
    );

419
    // Should return something
420 421 422 423
    ASSERT_TRUE(ack);

    EXPECT_EQ(DHCPACK, ack->getType());

424
    // This is relayed message. It should be sent back to relay address.
425 426
    EXPECT_EQ(req->getGiaddr(), ack->getRemoteAddr());

427
    messageCheck(req, ack);
428

429
    // Now repeat the test for directly sent message
430 431 432 433
    req->setHops(0);
    req->setGiaddr(IOAddress("0.0.0.0"));
    req->setRemotePort(DHCP4_CLIENT_PORT);

434
    EXPECT_NO_THROW(
435
        ack = srv->processDiscover(req);
436 437
    );

438
    // Should return something
439 440 441 442
    ASSERT_TRUE(ack);

    EXPECT_EQ(DHCPOFFER, ack->getType());

443
    // This is direct message. It should be sent back to origin, not
444 445 446
    // to relay.
    EXPECT_EQ(ack->getRemoteAddr(), req->getRemoteAddr());

447
    messageCheck(req, ack);
448 449 450 451 452 453 454 455 456

    delete srv;
}

TEST_F(Dhcpv4SrvTest, processRelease) {
    NakedDhcpv4Srv* srv = new NakedDhcpv4Srv();

    boost::shared_ptr<Pkt4> pkt(new Pkt4(DHCPRELEASE, 1234));

457
    // Should not throw
458 459 460 461 462 463 464 465 466 467 468 469
    EXPECT_NO_THROW(
        srv->processRelease(pkt);
    );

    delete srv;
}

TEST_F(Dhcpv4SrvTest, processDecline) {
    NakedDhcpv4Srv* srv = new NakedDhcpv4Srv();

    boost::shared_ptr<Pkt4> pkt(new Pkt4(DHCPDECLINE, 1234));

470
    // Should not throw
471 472 473 474 475 476 477 478 479 480 481 482
    EXPECT_NO_THROW(
        srv->processDecline(pkt);
    );

    delete srv;
}

TEST_F(Dhcpv4SrvTest, processInform) {
    NakedDhcpv4Srv* srv = new NakedDhcpv4Srv();

    boost::shared_ptr<Pkt4> pkt(new Pkt4(DHCPINFORM, 1234));

483
    // Should not throw
484 485 486 487
    EXPECT_NO_THROW(
        srv->processInform(pkt);
    );

488
    // Should return something
489 490
    EXPECT_TRUE(srv->processInform(pkt));

491
    // @todo Implement more reasonable tests before starting
492
    // work on processSomething() method.
493

494
    delete srv;
495 496
}

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
TEST_F(Dhcpv4SrvTest, serverReceivedPacketName) {
    // Check all possible packet types
    for (int itype = 0; itype < 256; ++itype) {
        uint8_t type = itype;

        switch (type) {
        case DHCPDECLINE:
            EXPECT_STREQ("DECLINE", Dhcpv4Srv::serverReceivedPacketName(type));
            break;

        case DHCPDISCOVER:
            EXPECT_STREQ("DISCOVER", Dhcpv4Srv::serverReceivedPacketName(type));
            break;

        case DHCPINFORM:
            EXPECT_STREQ("INFORM", Dhcpv4Srv::serverReceivedPacketName(type));
            break;

        case DHCPRELEASE:
            EXPECT_STREQ("RELEASE", Dhcpv4Srv::serverReceivedPacketName(type));
            break;

        case DHCPREQUEST:
            EXPECT_STREQ("REQUEST", Dhcpv4Srv::serverReceivedPacketName(type));
            break;

        default:
            EXPECT_STREQ("UNKNOWN", Dhcpv4Srv::serverReceivedPacketName(type));
        }
    }
}

529 530 531 532 533 534 535 536 537 538 539 540 541
// This test verifies that incoming DISCOVER can be handled properly, that an
// OFFER is generated, that the response has an address and that address
// really belongs to the configured pool.
//
// constructed very simple DISCOVER message with:
// - client-id option
//
// expected returned OFFER message:
// - copy of client-id
// - server-id
// - offered address
TEST_F(Dhcpv4SrvTest, DiscoverBasic) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
542
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
543 544 545 546 547 548

    Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234));
    dis->setRemoteAddr(IOAddress("192.0.2.1"));
    OptionPtr clientid = generateClientId();
    dis->addOption(clientid);

549
    // Pass it to the server and get an offer
550 551
    Pkt4Ptr offer = srv->processDiscover(dis);

552
    // Check if we get response at all
553 554
    checkResponse(offer, DHCPOFFER, 1234);

555
    // Check that address was returned from proper range, that its lease
556 557 558
    // lifetime is correct, that T1 and T2 are returned properly
    checkAddressParams(offer, subnet_);

559
    // Check identifiers
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
    checkServerId(offer, srv->getServerID());
    checkClientId(offer, clientid);
}


// This test verifies that incoming DISCOVER can be handled properly, that an
// OFFER is generated, that the response has an address and that address
// really belongs to the configured pool.
//
// constructed very simple DISCOVER message with:
// - client-id option
// - address set to specific value as hint
//
// expected returned OFFER message:
// - copy of client-id
// - server-id
// - offered address
TEST_F(Dhcpv4SrvTest, DiscoverHint) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
579
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
580 581 582 583 584 585 586 587
    IOAddress hint("192.0.2.107");

    Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234));
    dis->setRemoteAddr(IOAddress("192.0.2.1"));
    OptionPtr clientid = generateClientId();
    dis->addOption(clientid);
    dis->setYiaddr(hint);

588
    // Pass it to the server and get an offer
589 590
    Pkt4Ptr offer = srv->processDiscover(dis);

591
    // Check if we get response at all
592 593
    checkResponse(offer, DHCPOFFER, 1234);

594
    // Check that address was returned from proper range, that its lease
595 596 597 598 599
    // lifetime is correct, that T1 and T2 are returned properly
    checkAddressParams(offer, subnet_);

    EXPECT_EQ(offer->getYiaddr().toText(), hint.toText());

600
    // Check identifiers
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
    checkServerId(offer, srv->getServerID());
    checkClientId(offer, clientid);
}


// This test verifies that incoming DISCOVER can be handled properly, that an
// OFFER is generated, that the response has an address and that address
// really belongs to the configured pool.
//
// constructed very simple DISCOVER message with:
// - address set to specific value as hint
//
// expected returned OFFER message:
// - copy of client-id
// - server-id
// - offered address
TEST_F(Dhcpv4SrvTest, DiscoverNoClientId) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
619
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
620 621 622 623 624 625
    IOAddress hint("192.0.2.107");

    Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234));
    dis->setRemoteAddr(IOAddress("192.0.2.1"));
    dis->setYiaddr(hint);

626
    // Pass it to the server and get an offer
627 628
    Pkt4Ptr offer = srv->processDiscover(dis);

629
    // Check if we get response at all
630 631
    checkResponse(offer, DHCPOFFER, 1234);

632
    // Check that address was returned from proper range, that its lease
633 634 635 636 637
    // lifetime is correct, that T1 and T2 are returned properly
    checkAddressParams(offer, subnet_);

    EXPECT_EQ(offer->getYiaddr().toText(), hint.toText());

638
    // Check identifiers
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
    checkServerId(offer, srv->getServerID());
}

// This test verifies that incoming DISCOVER can be handled properly, that an
// OFFER is generated, that the response has an address and that address
// really belongs to the configured pool.
//
// constructed very simple DISCOVER message with:
// - client-id option
// - address set to specific value as hint, but that hint is invalid
//
// expected returned OFFER message:
// - copy of client-id
// - server-id
// - offered address (!= hint)
TEST_F(Dhcpv4SrvTest, DiscoverInvalidHint) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
656
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
657 658 659 660 661 662 663 664
    IOAddress hint("10.1.2.3");

    Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234));
    dis->setRemoteAddr(IOAddress("192.0.2.107"));
    OptionPtr clientid = generateClientId();
    dis->addOption(clientid);
    dis->setYiaddr(hint);

665
    // Pass it to the server and get an offer
666 667
    Pkt4Ptr offer = srv->processDiscover(dis);

668
    // Check if we get response at all
669 670
    checkResponse(offer, DHCPOFFER, 1234);

671
    // Check that address was returned from proper range, that its lease
672 673 674 675 676
    // lifetime is correct, that T1 and T2 are returned properly
    checkAddressParams(offer, subnet_);

    EXPECT_NE(offer->getYiaddr().toText(), hint.toText());

677
    // Check identifiers
678 679 680 681 682 683 684 685
    checkServerId(offer, srv->getServerID());
    checkClientId(offer, clientid);
}

/// @todo: Add a test that client sends hint that is in pool, but currently
/// being used by a different client.

// This test checks that the server is offering different addresses to different
Tomek Mrugalski's avatar
Tomek Mrugalski committed
686 687
// clients in OFFERs. Please note that OFFER is not a guarantee that such
// an address will be assigned. Had the pool was very small and contained only
688
// 2 addresses, the third client would get the same offer as the first one
689
// and this is a correct behavior. It is REQUEST that will fail for the third
Tomek Mrugalski's avatar
Tomek Mrugalski committed
690
// client. OFFER is basically saying "if you send me a request, you will
691 692 693
// probably get an address like this" (there are no guarantees).
TEST_F(Dhcpv4SrvTest, ManyDiscovers) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
694
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
695 696 697 698 699 700 701 702 703

    Pkt4Ptr dis1 = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234));
    Pkt4Ptr dis2 = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 2345));
    Pkt4Ptr dis3 = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 3456));

    dis1->setRemoteAddr(IOAddress("192.0.2.1"));
    dis2->setRemoteAddr(IOAddress("192.0.2.2"));
    dis3->setRemoteAddr(IOAddress("192.0.2.3"));

704
    // Different client-id sizes
705 706 707 708 709 710 711 712
    OptionPtr clientid1 = generateClientId(4); // length 4
    OptionPtr clientid2 = generateClientId(5); // length 5
    OptionPtr clientid3 = generateClientId(6); // length 6

    dis1->addOption(clientid1);
    dis2->addOption(clientid2);
    dis3->addOption(clientid3);

713 714 715 716
    // Pass it to the server and get an offer
    Pkt4Ptr offer1 = srv->processDiscover(dis1);
    Pkt4Ptr offer2 = srv->processDiscover(dis2);
    Pkt4Ptr offer3 = srv->processDiscover(dis3);
717

718 719 720 721
    // Check if we get response at all
    checkResponse(offer1, DHCPOFFER, 1234);
    checkResponse(offer2, DHCPOFFER, 2345);
    checkResponse(offer3, DHCPOFFER, 3456);
722

723 724 725
    IOAddress addr1 = offer1->getYiaddr();
    IOAddress addr2 = offer2->getYiaddr();
    IOAddress addr3 = offer3->getYiaddr();
726 727

    // Check that the assigned address is indeed from the configured pool
728 729 730 731 732 733 734 735 736 737 738
    checkAddressParams(offer1, subnet_);
    checkAddressParams(offer2, subnet_);
    checkAddressParams(offer3, subnet_);

    // Check DUIDs
    checkServerId(offer1, srv->getServerID());
    checkServerId(offer2, srv->getServerID());
    checkServerId(offer3, srv->getServerID());
    checkClientId(offer1, clientid1);
    checkClientId(offer2, clientid2);
    checkClientId(offer3, clientid3);
739 740 741 742 743 744 745 746 747 748

    // Finally check that the addresses offered are different
    EXPECT_NE(addr1.toText(), addr2.toText());
    EXPECT_NE(addr2.toText(), addr3.toText());
    EXPECT_NE(addr3.toText(), addr1.toText());
    cout << "Offered address to client1=" << addr1.toText() << endl;
    cout << "Offered address to client2=" << addr2.toText() << endl;
    cout << "Offered address to client3=" << addr3.toText() << endl;
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
749 750
// This test verifies that incoming REQUEST can be handled properly, that an
// ACK is generated, that the response has an address and that address
751 752
// really belongs to the configured pool.
//
Tomek Mrugalski's avatar
Tomek Mrugalski committed
753
// constructed a single REQUEST message with:
754
// - client-id option
Tomek Mrugalski's avatar
Tomek Mrugalski committed
755 756
// - hwaddr information
// - requested address (that the client received in DISCOVER/OFFER exchange)
757
//
Tomek Mrugalski's avatar
Tomek Mrugalski committed
758
// expected returned ACK message:
759 760
// - copy of client-id
// - server-id
Tomek Mrugalski's avatar
Tomek Mrugalski committed
761 762 763
// - assigned address
//
// Test verifies that the lease is actually in the database.
764 765
TEST_F(Dhcpv4SrvTest, RequestBasic) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
766
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
767 768 769 770 771 772 773 774 775 776 777

    IOAddress hint("192.0.2.107");
    Pkt4Ptr req = Pkt4Ptr(new Pkt4(DHCPREQUEST, 1234));
    req->setRemoteAddr(IOAddress("192.0.2.1"));
    OptionPtr clientid = generateClientId();
    req->addOption(clientid);
    req->setYiaddr(hint);

    // Pass it to the server and get an advertise
    Pkt4Ptr ack = srv->processRequest(req);

778
    // Check if we get response at all
779 780 781
    checkResponse(ack, DHCPACK, 1234);
    EXPECT_EQ(hint.toText(), ack->getYiaddr().toText());

782
    // Check that address was returned from proper range, that its lease
783 784 785
    // lifetime is correct, that T1 and T2 are returned properly
    checkAddressParams(ack, subnet_);

786
    // Check identifiers
787 788 789
    checkServerId(ack, srv->getServerID());
    checkClientId(ack, clientid);

790
    // Check that the lease is really in the database
791 792 793 794 795 796
    Lease4Ptr l = checkLease(ack, clientid, req->getHWAddr(), hint);

    ASSERT_TRUE(l);
    LeaseMgrFactory::instance().deleteLease(l->addr_);
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
// This test verifies that incoming REQUEST can be handled properly, that an
// ACK is generated, that the response has an address and that address
// really belongs to the configured pool.
//
// constructed 3 REQUEST messages with:
// - client-id option (differs between messages)
// - hwaddr information (differs between messages)
//
// expected returned ACK message:
// - copy of client-id
// - server-id
// - assigned address (different for each client)
TEST_F(Dhcpv4SrvTest, ManyRequests) {

    boost::scoped_ptr<NakedDhcpv4Srv> srv;
812
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
Tomek Mrugalski's avatar
Tomek Mrugalski committed
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834

    const IOAddress req_addr1("192.0.2.105");
    const IOAddress req_addr2("192.0.2.101");
    const IOAddress req_addr3("192.0.2.109");
    const IOAddress relay("192.0.2.1");

    Pkt4Ptr req1 = Pkt4Ptr(new Pkt4(DHCPOFFER, 1234));
    Pkt4Ptr req2 = Pkt4Ptr(new Pkt4(DHCPOFFER, 2345));
    Pkt4Ptr req3 = Pkt4Ptr(new Pkt4(DHCPOFFER, 3456));

    req1->setRemoteAddr(relay);
    req2->setRemoteAddr(relay);
    req3->setRemoteAddr(relay);

    req1->setYiaddr(req_addr1);
    req2->setYiaddr(req_addr2);
    req3->setYiaddr(req_addr3);

    req1->setHWAddr(generateHWAddr(6));
    req2->setHWAddr(generateHWAddr(7));
    req3->setHWAddr(generateHWAddr(8));

835
    // Different client-id sizes
Tomek Mrugalski's avatar
Tomek Mrugalski committed
836 837 838 839 840 841 842 843 844 845 846 847 848
    OptionPtr clientid1 = generateClientId(4); // length 4
    OptionPtr clientid2 = generateClientId(5); // length 5
    OptionPtr clientid3 = generateClientId(6); // length 6

    req1->addOption(clientid1);
    req2->addOption(clientid2);
    req3->addOption(clientid3);

    // Pass it to the server and get an advertise
    Pkt4Ptr ack1 = srv->processRequest(req1);
    Pkt4Ptr ack2 = srv->processRequest(req2);
    Pkt4Ptr ack3 = srv->processRequest(req3);

849
    // Check if we get response at all
Tomek Mrugalski's avatar
Tomek Mrugalski committed
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
    checkResponse(ack1, DHCPACK, 1234);
    checkResponse(ack2, DHCPACK, 2345);
    checkResponse(ack3, DHCPACK, 3456);

    IOAddress addr1 = ack1->getYiaddr();
    IOAddress addr2 = ack2->getYiaddr();
    IOAddress addr3 = ack3->getYiaddr();

    // Check that every client received the address it requested
    EXPECT_EQ(req_addr1.toText(), addr1.toText());
    EXPECT_EQ(req_addr2.toText(), addr2.toText());
    EXPECT_EQ(req_addr3.toText(), addr3.toText());

    // Check that the assigned address is indeed from the configured pool
    checkAddressParams(ack1, subnet_);
    checkAddressParams(ack2, subnet_);
    checkAddressParams(ack3, subnet_);

868
    // Check DUIDs
Tomek Mrugalski's avatar
Tomek Mrugalski committed
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
    checkServerId(ack1, srv->getServerID());
    checkServerId(ack2, srv->getServerID());
    checkServerId(ack3, srv->getServerID());
    checkClientId(ack1, clientid1);
    checkClientId(ack2, clientid2);
    checkClientId(ack3, clientid3);

    // Check that leases are in the database
    Lease4Ptr l = checkLease(ack1, clientid1, req1->getHWAddr(), addr1);
    EXPECT_TRUE(l);
    l = checkLease(ack2, clientid2, req2->getHWAddr(), addr2);
    l = checkLease(ack3, clientid3, req3->getHWAddr(), addr3);

    // Finally check that the addresses offered are different
    EXPECT_NE(addr1.toText(), addr2.toText());
    EXPECT_NE(addr2.toText(), addr3.toText());
    EXPECT_NE(addr3.toText(), addr1.toText());
    cout << "Offered address to client1=" << addr1.toText() << endl;
    cout << "Offered address to client2=" << addr2.toText() << endl;
    cout << "Offered address to client3=" << addr3.toText() << endl;
}


// This test verifies that incoming (positive) REQUEST/Renewing can be handled properly, that a
893 894 895 896 897 898 899 900 901 902
// REPLY is generated, that the response has an address and that address
// really belongs to the configured pool and that lease is actually renewed.
//
// expected:
// - returned REPLY message has copy of client-id
// - returned REPLY message has server-id
// - returned REPLY message has IA that includes IAADDR
// - lease is actually renewed in LeaseMgr
TEST_F(Dhcpv4SrvTest, RenewBasic) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
903
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
904 905

    const IOAddress addr("192.0.2.106");
906 907 908 909
    const uint32_t temp_t1 = 50;
    const uint32_t temp_t2 = 75;
    const uint32_t temp_valid = 100;
    const time_t temp_timestamp = time(NULL) - 10;
910

911
    // Generate client-id also sets client_id_ member
912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
    OptionPtr clientid = generateClientId();

    // Check that the address we are about to use is indeed in pool
    ASSERT_TRUE(subnet_->inPool(addr));

    // let's create a lease and put it in the LeaseMgr
    uint8_t hwaddr2[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
    uint8_t clientid2[] = { 8, 7, 6, 5, 4, 3, 2, 1 };
    Lease4Ptr used(new Lease4(IOAddress("192.0.2.106"), hwaddr2, sizeof(hwaddr2),
                              &client_id_->getDuid()[0], client_id_->getDuid().size(),
                              temp_valid, temp_t1, temp_t2, temp_timestamp,
                              subnet_->getID()));
    ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used));

    // Check that the lease is really in the database
    Lease4Ptr l = LeaseMgrFactory::instance().getLease4(addr);
    ASSERT_TRUE(l);

    // Check that T1, T2, preferred, valid and cltt really set.
    // Constructed lease looks as if it was assigned 10 seconds ago
    // EXPECT_EQ(l->t1_, temp_t1);
    // EXPECT_EQ(l->t2_, temp_t2);
    EXPECT_EQ(l->valid_lft_, temp_valid);
    EXPECT_EQ(l->cltt_, temp_timestamp);

    // Let's create a RENEW
    Pkt4Ptr req = Pkt4Ptr(new Pkt4(DHCPREQUEST, 1234));
    req->setRemoteAddr(IOAddress(addr));
    req->setYiaddr(addr);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
941
    req->setCiaddr(addr); // client's address
942 943 944 945 946 947 948 949 950 951 952

    req->addOption(clientid);
    req->addOption(srv->getServerID());

    // Pass it to the server and hope for a REPLY
    Pkt4Ptr ack = srv->processRequest(req);

    // Check if we get response at all
    checkResponse(ack, DHCPACK, 1234);
    EXPECT_EQ(addr.toText(), ack->getYiaddr().toText());

953
    // Check that address was returned from proper range, that its lease
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
    // lifetime is correct, that T1 and T2 are returned properly
    checkAddressParams(ack, subnet_);

    // Check identifiers
    checkServerId(ack, srv->getServerID());
    checkClientId(ack, clientid);

    // Check that the lease is really in the database
    l = checkLease(ack, clientid, req->getHWAddr(), addr);
    ASSERT_TRUE(l);

    // Check that T1, T2, preferred, valid and cltt were really updated
    EXPECT_EQ(l->t1_, subnet_->getT1());
    EXPECT_EQ(l->t2_, subnet_->getT2());
    EXPECT_EQ(l->valid_lft_, subnet_->getValid());

    // Checking for CLTT is a bit tricky if we want to avoid off by 1 errors
    int32_t cltt = static_cast<int32_t>(l->cltt_);
    int32_t expected = static_cast<int32_t>(time(NULL));
973
    // Equality or difference by 1 between cltt and expected is ok.
974 975 976 977 978 979 980 981 982 983
    EXPECT_GE(1, abs(cltt - expected));

    EXPECT_TRUE(LeaseMgrFactory::instance().deleteLease(addr));
}

// @todo: Implement tests for rejecting renewals

// This test verifies if the sanityCheck() really checks options presence.
TEST_F(Dhcpv4SrvTest, sanityCheck) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
984
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
985 986 987

    Pkt4Ptr pkt = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234));

988
    // Client-id is optional for information-request, so
989 990
    EXPECT_NO_THROW(srv->sanityCheck(pkt, Dhcpv4Srv::OPTIONAL));

991
    // Empty packet, no server-id
992 993 994 995
    EXPECT_THROW(srv->sanityCheck(pkt, Dhcpv4Srv::MANDATORY), RFCViolation);

    pkt->addOption(srv->getServerID());

996
    // Server-id is mandatory and present = no exception
997 998
    EXPECT_NO_THROW(srv->sanityCheck(pkt, Dhcpv4Srv::MANDATORY));

999
    // Server-id is forbidden, but present => exception
1000 1001 1002 1003
    EXPECT_THROW(srv->sanityCheck(pkt, Dhcpv4Srv::FORBIDDEN),
                 RFCViolation);
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
1004 1005 1006
// This test verifies that incoming (positive) RELEASE can be handled properly.
// As there is no REPLY in DHCPv4, the only thing to verify here is that
// the lease is indeed removed from the database.
1007 1008
TEST_F(Dhcpv4SrvTest, ReleaseBasic) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
1009
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022

    const IOAddress addr("192.0.2.106");
    const uint32_t temp_t1 = 50;
    const uint32_t temp_t2 = 75;
    const uint32_t temp_valid = 100;
    const time_t temp_timestamp = time(NULL) - 10;

    // Generate client-id also duid_
    OptionPtr clientid = generateClientId();

    // Check that the address we are about to use is indeed in pool
    ASSERT_TRUE(subnet_->inPool(addr));

1023
    // Let's create a lease and put it in the LeaseMgr
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
    uint8_t mac_addr[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
    HWAddrPtr hw(new HWAddr(mac_addr, sizeof(mac_addr), HTYPE_ETHER));
    Lease4Ptr used(new Lease4(addr, mac_addr, sizeof(mac_addr),
                              &client_id_->getDuid()[0], client_id_->getDuid().size(),
                              temp_valid, temp_t1, temp_t2, temp_timestamp,
                              subnet_->getID()));
    ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used));

    // Check that the lease is really in the database
    Lease4Ptr l = LeaseMgrFactory::instance().getLease4(addr);
    ASSERT_TRUE(l);

    // Let's create a RELEASE
    // Generate client-id also duid_
    Pkt4Ptr rel = Pkt4Ptr(new Pkt4(DHCPRELEASE, 1234));
    rel->setRemoteAddr(addr);
    rel->setYiaddr(addr);
    rel->addOption(clientid);
    rel->addOption(srv->getServerID());
    rel->setHWAddr(hw);

    // Pass it to the server and hope for a REPLY
    // Note: this is no response to RELEASE in DHCPv4
    EXPECT_NO_THROW(srv->processRelease(rel));

    // The lease should be gone from LeaseMgr
    l = LeaseMgrFactory::instance().getLease4(addr);
    EXPECT_FALSE(l);

    // Try to get the lease by hardware address
    // @todo: Uncomment this once trac2592 is implemented
    // Lease4Collection leases = LeaseMgrFactory::instance().getLease4(hw->hwaddr_);
    // EXPECT_EQ(leases.size(), 0);

1058
    // Try to get it by hw/subnet_id combination
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
    l = LeaseMgrFactory::instance().getLease4(hw->hwaddr_, subnet_->getID());
    EXPECT_FALSE(l);

    // Try by client-id
    // @todo: Uncomment this once trac2592 is implemented
    //Lease4Collection leases = LeaseMgrFactory::instance().getLease4(*client_id_);
    //EXPECT_EQ(leases.size(), 0);

    // Try by client-id/subnet-id
    l = LeaseMgrFactory::instance().getLease4(*client_id_, subnet_->getID());
    EXPECT_FALSE(l);

    // Ok, the lease is *really* not there.
}

// This test verifies that incoming (invalid) RELEASE can be handled properly.
//
// This test checks 3 scenarios:
// 1. there is no such lease at all
// 2. there is such a lease, but it is assigned to a different IAID
// 3. there is such a lease, but it belongs to a different client
TEST_F(Dhcpv4SrvTest, ReleaseReject) {
    boost::scoped_ptr<NakedDhcpv4Srv> srv;
1082
    ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0)));
1083 1084 1085 1086 1087 1088 1089

    const IOAddress addr("192.0.2.106");
    const uint32_t t1 = 50;
    const uint32_t t2 = 75;
    const uint32_t valid = 100;
    const time_t timestamp = time(NULL) - 10;

1090
    // Let's create a lease and put it in the LeaseMgr
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
    uint8_t bogus_mac_addr[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
    HWAddrPtr bogus_hw(new HWAddr(bogus_mac_addr, sizeof(bogus_mac_addr), HTYPE_ETHER));
    OptionPtr bogus_clientid = generateClientId(7); // different length

    // Generate client-id also duid_
    OptionPtr clientid = generateClientId();

    // Check that the address we are about to use is indeed in pool
    ASSERT_TRUE(subnet_->inPool(addr));

    // Let's create a RELEASE
    // Generate client-id also duid_
    Pkt4Ptr rel = Pkt4Ptr(new Pkt4(DHCPRELEASE, 1234));
    rel->setRemoteAddr(addr);
    rel->setYiaddr(addr);
    rel->addOption(clientid);
    rel->addOption(srv->getServerID());
    rel->setHWAddr(bogus_hw);

    // Case 1: No lease known to server
    SCOPED_TRACE("CASE 1: Lease is not known to the server");

    // There is nothing to check here. The lease is not there and server does
    // not send anything back. This case is enumerated here just for keeping
    // parity with similar test in DHCPv6.
    EXPECT_NO_THROW(srv->processRelease(rel));

Tomek Mrugalski's avatar
Tomek Mrugalski committed
1118
    // CASE 2: Lease is known and belongs to this client, but to a different hardware
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
    SCOPED_TRACE("CASE 2: Lease is known and belongs to this client, but uses different HW addr");

    // Let's create a lease and put it in the LeaseMgr
    uint8_t mac_addr[] = { 0, 0x1, 0x2, 0x3, 0x4, 0x5};
    HWAddrPtr hw(new HWAddr(mac_addr, sizeof(mac_addr), HTYPE_ETHER));
    Lease4Ptr used(new Lease4(addr, mac_addr, sizeof(mac_addr),
                              &client_id_->getDuid()[0], client_id_->getDuid().size(),
                              valid, t1, t2, timestamp, subnet_->getID()));
    ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used));
    // Check that the lease is really in the database
    Lease4Ptr l = LeaseMgrFactory::instance().getLease4(addr);
    ASSERT_TRUE(l);

    rel->setHWAddr(bogus_hw);

    EXPECT_NO_THROW(srv->processRelease(rel));

    // Check that the lease was not removed (due to hardware address mis-match)
    l = LeaseMgrFactory::instance().getLease4(addr);
    ASSERT_TRUE(l);

    // CASE 3: Lease belongs to a client with different client-id
    SCOPED_TRACE("CASE 3: Lease belongs to a client with different client-id");

    rel->setHWAddr(hw); // proper HW address this time
    rel->delOption(DHO_DHCP_CLIENT_IDENTIFIER);
    rel->addOption(bogus_clientid); // but invalid client-id

    OptionPtr x = rel->getOption(DHO_DHCP_CLIENT_IDENTIFIER);

    EXPECT_NO_THROW(srv->processRelease(rel));

    // Check that the lease is still there
    l = LeaseMgrFactory::instance().getLease4(addr);
    ASSERT_TRUE(l);

Tomek Mrugalski's avatar
Tomek Mrugalski committed
1155
    // Final sanity check. Verify that with valid hw and client-id release is successful
1156 1157 1158
    rel->delOption(DHO_DHCP_CLIENT_IDENTIFIER);
    rel->addOption(clientid);

Tomek Mrugalski's avatar
Tomek Mrugalski committed
1159
    // It should work this time
1160 1161
    EXPECT_NO_THROW(srv->processRelease(rel));

Tomek Mrugalski's avatar
Tomek Mrugalski committed
1162
    // Check that the lease is not there
1163 1164 1165
    l = LeaseMgrFactory::instance().getLease4(addr);
    EXPECT_FALSE(l);
}
1166

1167
} // end of anonymous namespace