dhcp4_srv.cc 80 KB
Newer Older
1
// Copyright (C) 2011-2015 Internet Systems Consortium, Inc. ("ISC")
2
3
4
5
6
7
8
9
10
11
12
13
14
//
// 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.

15
#include <asiolink/io_address.h>
16
#include <dhcp/dhcp4.h>
17
18
#include <dhcp/duid.h>
#include <dhcp/hwaddr.h>
19
#include <dhcp/iface_mgr.h>
20
#include <dhcp/option4_addrlst.h>
21
#include <dhcp/option_int.h>
22
#include <dhcp/option_int_array.h>
23
#include <dhcp/option_vendor.h>
24
#include <dhcp/option_string.h>
25
#include <dhcp/pkt4.h>
26
#include <dhcp/docsis3_option_defs.h>
27
28
#include <dhcp4/dhcp4_log.h>
#include <dhcp4/dhcp4_srv.h>
29
30
#include <dhcpsrv/addr_utilities.h>
#include <dhcpsrv/callout_handle_store.h>
31
#include <dhcpsrv/cfgmgr.h>
32
#include <dhcpsrv/cfg_subnets4.h>
33
34
35
#include <dhcpsrv/lease_mgr.h>
#include <dhcpsrv/lease_mgr_factory.h>
#include <dhcpsrv/subnet.h>
36
#include <dhcpsrv/subnet_selector.h>
37
#include <dhcpsrv/utils.h>
38
#include <dhcpsrv/utils.h>
39
#include <hooks/callout_handle.h>
40
#include <hooks/hooks_manager.h>
41
#include <util/strutil.h>
42

43
#include <boost/bind.hpp>
44
#include <boost/foreach.hpp>
45
46
47

#include <iomanip>

48
49
using namespace isc;
using namespace isc::asiolink;
50
using namespace isc::dhcp;
51
using namespace isc::dhcp_ddns;
52
using namespace isc::hooks;
53
54
using namespace isc::log;
using namespace std;
55

56
/// Structure that holds registered hook indexes
57
58
struct Dhcp4Hooks {
    int hook_index_buffer4_receive_;///< index for "buffer4_receive" hook point
59
60
    int hook_index_pkt4_receive_;   ///< index for "pkt4_receive" hook point
    int hook_index_subnet4_select_; ///< index for "subnet4_select" hook point
61
    int hook_index_lease4_release_; ///< index for "lease4_release" hook point
62
    int hook_index_pkt4_send_;      ///< index for "pkt4_send" hook point
63
    int hook_index_buffer4_send_;   ///< index for "buffer4_send" hook point
64

65
66
67
    /// Constructor that registers hook points for DHCPv4 engine
    Dhcp4Hooks() {
        hook_index_buffer4_receive_= HooksManager::registerHook("buffer4_receive");
68
69
70
        hook_index_pkt4_receive_   = HooksManager::registerHook("pkt4_receive");
        hook_index_subnet4_select_ = HooksManager::registerHook("subnet4_select");
        hook_index_pkt4_send_      = HooksManager::registerHook("pkt4_send");
71
72
        hook_index_lease4_release_ = HooksManager::registerHook("lease4_release");
        hook_index_buffer4_send_   = HooksManager::registerHook("buffer4_send");
73
74
75
76
77
78
79
    }
};

// Declare a Hooks object. As this is outside any function or method, it
// will be instantiated (and the constructor run) when the module is loaded.
// As a result, the hook indexes will be defined before any method in this
// module is called.
80
Dhcp4Hooks Hooks;
81

82
83
84
namespace isc {
namespace dhcp {

85
86
const std::string Dhcpv4Srv::VENDOR_CLASS_PREFIX("VENDOR_CLASS_");

87
Dhcpv4Srv::Dhcpv4Srv(uint16_t port, const bool use_bcast,
88
                     const bool direct_response_desired)
89
90
91
    : shutdown_(true), alloc_engine_(), port_(port),
      use_bcast_(use_bcast), hook_index_pkt4_receive_(-1),
      hook_index_subnet4_select_(-1), hook_index_pkt4_send_(-1) {
92

93
    LOG_DEBUG(dhcp4_logger, DBG_DHCP4_START, DHCP4_OPEN_SOCKET).arg(port);
94
    try {
95
96
97
        // Port 0 is used for testing purposes where we don't open broadcast
        // capable sockets. So, set the packet filter handling direct traffic
        // only if we are in non-test mode.
98
        if (port) {
99
100
101
102
103
104
105
106
            // First call to instance() will create IfaceMgr (it's a singleton)
            // it may throw something if things go wrong.
            // The 'true' value of the call to setMatchingPacketFilter imposes
            // that IfaceMgr will try to use the mechanism to respond directly
            // to the client which doesn't have address assigned. This capability
            // may be lacking on some OSes, so there is no guarantee that server
            // will be able to respond directly.
            IfaceMgr::instance().setMatchingPacketFilter(direct_response_desired);
107
        }
108

109
        // Instantiate allocation engine
110
111
        alloc_engine_.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100,
                                            false /* false = IPv4 */));
112

113
114
115
116
117
118
119
        // Register hook points
        hook_index_pkt4_receive_   = Hooks.hook_index_pkt4_receive_;
        hook_index_subnet4_select_ = Hooks.hook_index_subnet4_select_;
        hook_index_pkt4_send_      = Hooks.hook_index_pkt4_send_;

        /// @todo call loadLibraries() when handling configuration changes

120
    } catch (const std::exception &e) {
121
        LOG_ERROR(dhcp4_logger, DHCP4_SRV_CONSTRUCT_ERROR).arg(e.what());
122
123
124
        shutdown_ = true;
        return;
    }
125

Tomek Mrugalski's avatar
Tomek Mrugalski committed
126
    shutdown_ = false;
127
128
129
}

Dhcpv4Srv::~Dhcpv4Srv() {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
130
    IfaceMgr::instance().closeSockets();
131
132
}

133
134
void
Dhcpv4Srv::shutdown() {
135
    LOG_DEBUG(dhcp4_logger, DBG_DHCP4_BASIC, DHCP4_SHUTDOWN_REQUEST);
136
137
138
    shutdown_ = true;
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
139
140
Pkt4Ptr
Dhcpv4Srv::receivePacket(int timeout) {
141
142
143
    return (IfaceMgr::instance().receive4(timeout));
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
144
145
void
Dhcpv4Srv::sendPacket(const Pkt4Ptr& packet) {
146
147
148
    IfaceMgr::instance().send(packet);
}

149
150
bool
Dhcpv4Srv::run() {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
151
    while (!shutdown_) {
152
        /// @todo: calculate actual timeout once we have lease database
153
154
        //cppcheck-suppress variableScope This is temporary anyway
        const int timeout = 1000;
155

Tomek Mrugalski's avatar
Tomek Mrugalski committed
156
        // client's message and server's response
157
        Pkt4Ptr query;
Tomek Mrugalski's avatar
Tomek Mrugalski committed
158
        Pkt4Ptr rsp;
159

160
        try {
161
            query = receivePacket(timeout);
162
163
164
165
166
167
168

        } catch (const SignalInterruptOnSelect) {
            // Packet reception interrupted because a signal has been received.
            // This is not an error because we might have received a SIGTERM,
            // SIGINT or SIGHUP which are handled by the server. For signals
            // that are not handled by the server we rely on the default
            // behavior of the system, but there is nothing we should log here.
169
        } catch (const std::exception& e) {
170
            // Log all other errors.
171
172
173
            LOG_ERROR(dhcp4_logger, DHCP4_PACKET_RECEIVE_FAIL).arg(e.what());
        }

174
175
176
177
178
179
180
181
182
183
184
185
        // Handle next signal received by the process. It must be called after
        // an attempt to receive a packet to properly handle server shut down.
        // The SIGTERM or SIGINT will be received prior to, or during execution
        // of select() (select is invoked by recivePacket()). When that happens,
        // select will be interrupted. The signal handler will be invoked
        // immediately after select(). The handler will set the shutdown flag
        // and cause the process to terminate before the next select() function
        // is called. If the function was called before receivePacket the
        // process could wait up to the duration of timeout of select() to
        // terminate.
        handleSignal();

186
187
188
189
190
191
        // Timeout may be reached or signal received, which breaks select()
        // with no reception ocurred
        if (!query) {
            continue;
        }

192
193
194
195
196
197
198
199
200
        // In order to parse the DHCP options, the server needs to use some
        // configuration information such as: existing option spaces, option
        // definitions etc. This is the kind of information which is not
        // available in the libdhcp, so we need to supply our own implementation
        // of the option parsing function here, which would rely on the
        // configuration data.
        query->setCallback(boost::bind(&Dhcpv4Srv::unpackOptions, this,
                                       _1, _2, _3));

201
202
203
        bool skip_unpack = false;

        // The packet has just been received so contains the uninterpreted wire
204
        // data; execute callouts registered for buffer4_receive.
205
        if (HooksManager::calloutsPresent(Hooks.hook_index_buffer4_receive_)) {
206
207
208
209
210
211
212
213
214
            CalloutHandlePtr callout_handle = getCalloutHandle(query);

            // Delete previously set arguments
            callout_handle->deleteAllArguments();

            // Pass incoming packet as argument
            callout_handle->setArgument("query4", query);

            // Call callouts
Tomek Mrugalski's avatar
Tomek Mrugalski committed
215
216
            HooksManager::callCallouts(Hooks.hook_index_buffer4_receive_,
                                       *callout_handle);
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

            // Callouts decided to skip the next processing step. The next
            // processing step would to parse the packet, so skip at this
            // stage means that callouts did the parsing already, so server
            // should skip parsing.
            if (callout_handle->getSkip()) {
                LOG_DEBUG(dhcp4_logger, DBG_DHCP4_HOOKS, DHCP4_HOOK_BUFFER_RCVD_SKIP);
                skip_unpack = true;
            }

            callout_handle->getArgument("query4", query);
        }

        // Unpack the packet information unless the buffer4_receive callouts
        // indicated they did it
        if (!skip_unpack) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
233
234
235
            try {
                query->unpack();
            } catch (const std::exception& e) {
236
237
238
                // Failed to parse the packet.
                LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL,
                          DHCP4_PACKET_PARSE_FAIL).arg(e.what());
239
240
                continue;
            }
241
        }
242

Tomek Mrugalski's avatar
Tomek Mrugalski committed
243
244
245
        // Assign this packet to one or more classes if needed. We need to do
        // this before calling accept(), because getSubnet4() may need client
        // class information.
246
247
        classifyPacket(query);

248
249
250
        // Check whether the message should be further processed or discarded.
        // There is no need to log anything here. This function logs by itself.
        if (!accept(query)) {
251
            continue;
252
        }
253

254
        // We have sanity checked (in accept() that the Message Type option
255
256
        // exists, so we can safely get it here.
        int type = query->getType();
257
        LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_RECEIVED)
258
            .arg(serverReceivedPacketName(type))
259
            .arg(type)
260
261
            .arg(query->getIface());
        LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_QUERY_DATA)
262
            .arg(type)
263
264
            .arg(query->toText());

Tomek Mrugalski's avatar
Tomek Mrugalski committed
265
        // Let's execute all callouts registered for pkt4_receive
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
        if (HooksManager::calloutsPresent(hook_index_pkt4_receive_)) {
            CalloutHandlePtr callout_handle = getCalloutHandle(query);

            // Delete previously set arguments
            callout_handle->deleteAllArguments();

            // Pass incoming packet as argument
            callout_handle->setArgument("query4", query);

            // Call callouts
            HooksManager::callCallouts(hook_index_pkt4_receive_,
                                       *callout_handle);

            // Callouts decided to skip the next processing step. The next
            // processing step would to process the packet, so skip at this
            // stage means drop.
            if (callout_handle->getSkip()) {
                LOG_DEBUG(dhcp4_logger, DBG_DHCP4_HOOKS, DHCP4_HOOK_PACKET_RCVD_SKIP);
                continue;
            }
286

287
288
            callout_handle->getArgument("query4", query);
        }
289

290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
        try {
            switch (query->getType()) {
            case DHCPDISCOVER:
                rsp = processDiscover(query);
                break;

            case DHCPREQUEST:
                // Note that REQUEST is used for many things in DHCPv4: for
                // requesting new leases, renewing existing ones and even
                // for rebinding.
                rsp = processRequest(query);
                break;

            case DHCPRELEASE:
                processRelease(query);
                break;

            case DHCPDECLINE:
                processDecline(query);
                break;

            case DHCPINFORM:
312
                rsp = processInform(query);
313
314
315
316
317
318
319
                break;

            default:
                // Only action is to output a message if debug is enabled,
                // and that is covered by the debug statement before the
                // "switch" statement.
                ;
320
            }
321
322
        } catch (const isc::Exception& e) {

323
324
325
326
327
328
            // Catch-all exception (at least for ones based on the isc Exception
            // class, which covers more or less all that are explicitly raised
            // in the Kea code).  Just log the problem and ignore the packet.
            // (The problem is logged as a debug message because debug is
            // disabled by default - it prevents a DDOS attack based on the
            // sending of problem packets.)
329
330
331
332
333
            if (dhcp4_logger.isDebugEnabled(DBG_DHCP4_BASIC)) {
                std::string source = "unknown";
                HWAddrPtr hwptr = query->getHWAddr();
                if (hwptr) {
                    source = hwptr->toText();
334
                }
335
336
337
                LOG_DEBUG(dhcp4_logger, DBG_DHCP4_BASIC,
                          DHCP4_PACKET_PROCESS_FAIL)
                    .arg(source).arg(e.what());
338
            }
339
        }
340

341
342
343
        if (!rsp) {
            continue;
        }
344

Tomek Mrugalski's avatar
Tomek Mrugalski committed
345
346
347
348
349
        // Let's do class specific processing. This is done before
        // pkt4_send.
        //
        /// @todo: decide whether we want to add a new hook point for
        /// doing class specific processing.
350
351
352
353
354
355
356
        if (!classSpecificProcessing(query, rsp)) {
            /// @todo add more verbosity here
            LOG_DEBUG(dhcp4_logger, DBG_DHCP4_BASIC, DHCP4_CLASS_PROCESSING_FAILED);

            continue;
        }

357
358
        // Specifies if server should do the packing
        bool skip_pack = false;
359

Tomek Mrugalski's avatar
Tomek Mrugalski committed
360
        // Execute all callouts registered for pkt4_send
361
362
        if (HooksManager::calloutsPresent(hook_index_pkt4_send_)) {
            CalloutHandlePtr callout_handle = getCalloutHandle(query);
363

364
365
            // Delete all previous arguments
            callout_handle->deleteAllArguments();
366

367
368
            // Clear skip flag if it was set in previous callouts
            callout_handle->setSkip(false);
369

370
371
            // Set our response
            callout_handle->setArgument("response4", rsp);
372

373
374
375
            // Call all installed callouts
            HooksManager::callCallouts(hook_index_pkt4_send_,
                                       *callout_handle);
376

377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
            // Callouts decided to skip the next processing step. The next
            // processing step would to send the packet, so skip at this
            // stage means "drop response".
            if (callout_handle->getSkip()) {
                LOG_DEBUG(dhcp4_logger, DBG_DHCP4_HOOKS, DHCP4_HOOK_PACKET_SEND_SKIP);
                skip_pack = true;
            }
        }

        if (!skip_pack) {
            try {
                rsp->pack();
            } catch (const std::exception& e) {
                LOG_ERROR(dhcp4_logger, DHCP4_PACKET_SEND_FAIL)
                    .arg(e.what());
            }
        }

        try {
            // Now all fields and options are constructed into output wire buffer.
            // Option objects modification does not make sense anymore. Hooks
            // can only manipulate wire buffer at this stage.
Tomek Mrugalski's avatar
Tomek Mrugalski committed
399
            // Let's execute all callouts registered for buffer4_send
400
            if (HooksManager::calloutsPresent(Hooks.hook_index_buffer4_send_)) {
401
                CalloutHandlePtr callout_handle = getCalloutHandle(query);
402

403
404
                // Delete previously set arguments
                callout_handle->deleteAllArguments();
405

406
407
                // Pass incoming packet as argument
                callout_handle->setArgument("response4", rsp);
408

409
                // Call callouts
Tomek Mrugalski's avatar
Tomek Mrugalski committed
410
411
                HooksManager::callCallouts(Hooks.hook_index_buffer4_send_,
                                           *callout_handle);
412

413
414
415
416
                // Callouts decided to skip the next processing step. The next
                // processing step would to parse the packet, so skip at this
                // stage means drop.
                if (callout_handle->getSkip()) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
417
418
                    LOG_DEBUG(dhcp4_logger, DBG_DHCP4_HOOKS,
                              DHCP4_HOOK_BUFFER_SEND_SKIP);
419
                    continue;
420
                }
421
422

                callout_handle->getArgument("response4", rsp);
423
            }
424
425
426
427
428
429
430
431
432

            LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL_DATA,
                      DHCP4_RESPONSE_DATA)
                .arg(static_cast<int>(rsp->getType())).arg(rsp->toText());

            sendPacket(rsp);
        } catch (const std::exception& e) {
            LOG_ERROR(dhcp4_logger, DHCP4_PACKET_SEND_FAIL)
                .arg(e.what());
433
        }
434
435
436
437
438
    }

    return (true);
}

439
string
440
Dhcpv4Srv::srvidToString(const OptionPtr& srvid) {
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
    if (!srvid) {
        isc_throw(BadValue, "NULL pointer passed to srvidToString()");
    }
    boost::shared_ptr<Option4AddrLst> generated =
        boost::dynamic_pointer_cast<Option4AddrLst>(srvid);
    if (!srvid) {
        isc_throw(BadValue, "Pointer to invalid option passed to srvidToString()");
    }

    Option4AddrLst::AddressContainer addrs = generated->getAddresses();
    if (addrs.size() != 1) {
        isc_throw(BadValue, "Malformed option passed to srvidToString(). "
                  << "Expected to contain a single IPv4 address.");
    }

    return (addrs[0].toText());
457
458
}

459
isc::dhcp_ddns::D2Dhcid
460
461
462
463
464
465
466
467
468
Dhcpv4Srv::computeDhcid(const Lease4Ptr& lease) {
    if (!lease) {
        isc_throw(DhcidComputeError, "a pointer to the lease must be not"
                  " NULL to compute DHCID");

    } else if (lease->hostname_.empty()) {
        isc_throw(DhcidComputeError, "unable to compute the DHCID for the"
                  " lease which has empty hostname set");

469
470
    }

471
472
473
474
475
476
477
478
479
    // In order to compute DHCID the client's hostname must be encoded in
    // canonical wire format. It is unlikely that the FQDN is malformed
    // because it is validated by the classes which encapsulate options
    // carrying client FQDN. However, if the client name was carried in the
    // Hostname option it is more likely as it carries the hostname as a
    // regular string.
    std::vector<uint8_t> fqdn_wire;
    try {
        OptionDataTypeUtil::writeFqdn(lease->hostname_, fqdn_wire, true);
480

481
482
483
    } catch (const Exception& ex) {
        isc_throw(DhcidComputeError, "unable to compute DHCID because the"
                  " hostname: " << lease->hostname_ << " is invalid");
484
485

    }
486
487
488

    // Prefer client id to HW address to compute DHCID. If Client Id is
    // NULL, use HW address.
489
    try {
490
491
492
493
        if (lease->client_id_) {
            return (D2Dhcid(lease->client_id_->getClientId(), fqdn_wire));

        } else {
494
            return (D2Dhcid(lease->hwaddr_, fqdn_wire));
495
        }
496
    } catch (const Exception& ex) {
497
498
        isc_throw(DhcidComputeError, "unable to compute DHCID: "
                  << ex.what());
499

500
    }
501
502
503

}

504
505
void
Dhcpv4Srv::copyDefaultFields(const Pkt4Ptr& question, Pkt4Ptr& answer) {
506
507
    answer->setIface(question->getIface());
    answer->setIndex(question->getIndex());
508

509
    answer->setSiaddr(IOAddress("0.0.0.0")); // explicitly set this to 0
510
511
512
    // ciaddr is always 0, except for the Renew/Rebind state when it may
    // be set to the ciaddr sent by the client.
    answer->setCiaddr(IOAddress("0.0.0.0"));
513
    answer->setHops(question->getHops());
514
515

    // copy MAC address
516
    answer->setHWAddr(question->getHWAddr());
517
518

    // relay address
519
520
    answer->setGiaddr(question->getGiaddr());

521
    // Let's copy client-id to response. See RFC6842.
522
523
    // It is possible to disable RFC6842 to keep backward compatibility
    bool echo = CfgMgr::instance().echoClientId();
524
    OptionPtr client_id = question->getOption(DHO_DHCP_CLIENT_IDENTIFIER);
525
    if (client_id && echo) {
526
527
        answer->addOption(client_id);
    }
528
529

    // If src/dest HW addresses are used by the packet filtering class
530
531
532
533
534
535
    // we need to copy them as well. There is a need to check that the
    // address being set is not-NULL because an attempt to set the NULL
    // HW would result in exception. If these values are not set, the
    // the default HW addresses (zeroed) should be generated by the
    // packet filtering class when creating Ethernet header for
    // outgoing packet.
536
537
    HWAddrPtr src_hw_addr = question->getLocalHWAddr();
    if (src_hw_addr) {
538
        answer->setLocalHWAddr(src_hw_addr);
539
    }
540
    HWAddrPtr dst_hw_addr = question->getRemoteHWAddr();
541
    if (dst_hw_addr) {
542
        answer->setRemoteHWAddr(dst_hw_addr);
543
    }
544
545
546
547
548
549

    // If this packet is relayed, we want to copy Relay Agent Info option
    OptionPtr rai = question->getOption(DHO_DHCP_AGENT_OPTIONS);
    if (rai) {
        answer->addOption(rai);
    }
550
551
}

552
553
void
Dhcpv4Srv::appendDefaultOptions(Pkt4Ptr& msg, uint8_t msg_type) {
554
    OptionPtr opt;
555
556

    // add Message Type Option (type 53)
557
    msg->setType(msg_type);
558
559
560
561

    // more options will be added here later
}

562
563
564
565
566
void
Dhcpv4Srv::appendServerID(const Pkt4Ptr& response) {
    // The source address for the outbound message should have been set already.
    // This is the address that to the best of the server's knowledge will be
    // available from the client.
567
568
    /// @todo: perhaps we should consider some more sophisticated server id
    /// generation, but for the current use cases, it should be ok.
569
570
571
572
573
    response->addOption(OptionPtr(new Option4AddrLst(DHO_DHCP_SERVER_IDENTIFIER,
                                                     response->getLocalAddr()))
                        );
}

574
575
void
Dhcpv4Srv::appendRequestedOptions(const Pkt4Ptr& question, Pkt4Ptr& msg) {
576
577
578
579
580
581
582
583
584
585
586

    // Get the subnet relevant for the client. We will need it
    // to get the options associated with it.
    Subnet4Ptr subnet = selectSubnet(question);
    // If we can't find the subnet for the client there is no way
    // to get the options to be sent to a client. We don't log an
    // error because it will be logged by the assignLease method
    // anyway.
    if (!subnet) {
        return;
    }
587

588
589
590
591
592
593
594
595
596
    // try to get the 'Parameter Request List' option which holds the
    // codes of requested options.
    OptionUint8ArrayPtr option_prl = boost::dynamic_pointer_cast<
        OptionUint8Array>(question->getOption(DHO_DHCP_PARAMETER_REQUEST_LIST));
    // If there is no PRL option in the message from the client then
    // there is nothing to do.
    if (!option_prl) {
        return;
    }
597

598
599
600
601
602
603
    // Get the codes of requested options.
    const std::vector<uint8_t>& requested_opts = option_prl->getValues();
    // For each requested option code get the instance of the option
    // to be returned to the client.
    for (std::vector<uint8_t>::const_iterator opt = requested_opts.begin();
         opt != requested_opts.end(); ++opt) {
604
        if (!msg->getOption(*opt)) {
605
            OptionDescriptor desc = subnet->getCfgOption()->get("dhcp4", *opt);
606
607
            if (desc.option_ && !msg->getOption(*opt)) {
                msg->addOption(desc.option_);
608
            }
609
610
        }
    }
Tomek Mrugalski's avatar
Tomek Mrugalski committed
611
}
612

613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
void
Dhcpv4Srv::appendRequestedVendorOptions(const Pkt4Ptr& question, Pkt4Ptr& answer) {
    // Get the configured subnet suitable for the incoming packet.
    Subnet4Ptr subnet = selectSubnet(question);
    // Leave if there is no subnet matching the incoming packet.
    // There is no need to log the error message here because
    // it will be logged in the assignLease() when it fails to
    // pick the suitable subnet. We don't want to duplicate
    // error messages in such case.
    if (!subnet) {
        return;
    }

    // Try to get the vendor option
    boost::shared_ptr<OptionVendor> vendor_req =
        boost::dynamic_pointer_cast<OptionVendor>(question->getOption(DHO_VIVSO_SUBOPTIONS));
    if (!vendor_req) {
        return;
    }

    uint32_t vendor_id = vendor_req->getVendorId();

    // Let's try to get ORO within that vendor-option
636
637
    /// @todo This is very specific to vendor-id=4491 (Cable Labs). Other
    /// vendors may have different policies.
Tomek Mrugalski's avatar
Tomek Mrugalski committed
638
639
    OptionUint8ArrayPtr oro =
        boost::dynamic_pointer_cast<OptionUint8Array>(vendor_req->getOption(DOCSIS3_V4_ORO));
640
641
642
643
644
645
646
647
648
649

    // Option ORO not found. Don't do anything then.
    if (!oro) {
        return;
    }

    boost::shared_ptr<OptionVendor> vendor_rsp(new OptionVendor(Option::V4, vendor_id));

    // Get the list of options that client requested.
    bool added = false;
650
    const std::vector<uint8_t>& requested_opts = oro->getValues();
651

Tomek Mrugalski's avatar
Tomek Mrugalski committed
652
    for (std::vector<uint8_t>::const_iterator code = requested_opts.begin();
653
         code != requested_opts.end(); ++code) {
654
        if  (!vendor_rsp->getOption(*code)) {
655
656
            OptionDescriptor desc = subnet->getCfgOption()->get(vendor_id,
                                                                *code);
657
658
            if (desc.option_) {
                vendor_rsp->addOption(desc.option_);
659
660
                added = true;
            }
661
662
        }

663
664
        if (added) {
            answer->addOption(vendor_rsp);
665
666
        }
    }
Tomek Mrugalski's avatar
Tomek Mrugalski committed
667
}
668

669

670
671
672
673
674
675
676
677
void
Dhcpv4Srv::appendBasicOptions(const Pkt4Ptr& question, Pkt4Ptr& msg) {
    // Identify options that we always want to send to the
    // client (if they are configured).
    static const uint16_t required_options[] = {
        DHO_ROUTERS,
        DHO_DOMAIN_NAME_SERVERS,
        DHO_DOMAIN_NAME };
678

679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
    static size_t required_options_size =
        sizeof(required_options) / sizeof(required_options[0]);

    // Get the subnet.
    Subnet4Ptr subnet = selectSubnet(question);
    if (!subnet) {
        return;
    }

    // Try to find all 'required' options in the outgoing
    // message. Those that are not present will be added.
    for (int i = 0; i < required_options_size; ++i) {
        OptionPtr opt = msg->getOption(required_options[i]);
        if (!opt) {
            // Check whether option has been configured.
694
695
            OptionDescriptor desc = subnet->getCfgOption()->
                get("dhcp4", required_options[i]);
696
697
            if (desc.option_) {
                msg->addOption(desc.option_);
698
699
700
            }
        }
    }
Tomek Mrugalski's avatar
Tomek Mrugalski committed
701
}
702

703
704
705
706
707
void
Dhcpv4Srv::processClientName(const Pkt4Ptr& query, Pkt4Ptr& answer) {
    // It is possible that client has sent both Client FQDN and Hostname
    // option. In such case, server should prefer Client FQDN option and
    // ignore the Hostname option.
708
709
710
711
712
713
714
    try {
        Option4ClientFqdnPtr fqdn = boost::dynamic_pointer_cast<Option4ClientFqdn>
            (query->getOption(DHO_FQDN));
        if (fqdn) {
            processClientFqdnOption(fqdn, answer);

        } else {
715
            OptionStringPtr hostname = boost::dynamic_pointer_cast<OptionString>
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
                (query->getOption(DHO_HOST_NAME));
            if (hostname) {
                processHostnameOption(hostname, answer);
            }
        }
    } catch (const Exception& ex) {
        // In some rare cases it is possible that the client's name processing
        // fails. For example, the Hostname option may be malformed, or there
        // may be an error in the server's logic which would cause multiple
        // attempts to add the same option to the response message. This
        // error message aggregates all these errors so they can be diagnosed
        // from the log. We don't want to throw an exception here because,
        // it will impact the processing of the whole packet. We rather want
        // the processing to continue, even if the client's name is wrong.
        LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_NAME_PROC_FAIL)
            .arg(ex.what());
732
733
734
735
    }
}

void
736
737
738
739
740
741
Dhcpv4Srv::processClientFqdnOption(const Option4ClientFqdnPtr& fqdn,
                                   Pkt4Ptr& answer) {
    // Create the DHCPv4 Client FQDN Option to be included in the server's
    // response to a client.
    Option4ClientFqdnPtr fqdn_resp(new Option4ClientFqdn(*fqdn));

742
743
744
745
    // Set the server S, N, and O flags based on client's flags and
    // current configuration.
    D2ClientMgr& d2_mgr = CfgMgr::instance().getD2ClientMgr();
    d2_mgr.adjustFqdnFlags<Option4ClientFqdn>(*fqdn, *fqdn_resp);
746

747
748
749
    // Carry over the client's E flag.
    fqdn_resp->setFlag(Option4ClientFqdn::FLAG_E,
                       fqdn->getFlag(Option4ClientFqdn::FLAG_E));
750
751


752
753
754
    // Adjust the domain name based on domain name value and type sent by the
    // client and current configuration.
    d2_mgr.adjustDomainName<Option4ClientFqdn>(*fqdn, *fqdn_resp);
755
756
757
758
759
760
761
762
763
764
765
766
767

    // Add FQDN option to the response message. Note that, there may be some
    // cases when server may choose not to include the FQDN option in a
    // response to a client. In such cases, the FQDN should be removed from the
    // outgoing message. In theory we could cease to include the FQDN option
    // in this function until it is confirmed that it should be included.
    // However, we include it here for simplicity. Functions used to acquire
    // lease for a client will scan the response message for FQDN and if it
    // is found they will take necessary actions to store the FQDN information
    // in the lease database as well as to generate NameChangeRequests to DNS.
    // If we don't store the option in the reponse message, we will have to
    // propagate it in the different way to the functions which acquire the
    // lease. This would require modifications to the API of this class.
768
    answer->addOption(fqdn_resp);
769
770
771
}

void
772
Dhcpv4Srv::processHostnameOption(const OptionStringPtr& opt_hostname,
773
                                 Pkt4Ptr& answer) {
774
775
776
    // Fetch D2 configuration.
    D2ClientMgr& d2_mgr = CfgMgr::instance().getD2ClientMgr();

777
    // Do nothing if the DNS updates are disabled.
778
    if (!d2_mgr.ddnsEnabled()) {
779
780
781
        return;
    }

782
    std::string hostname = isc::util::str::trim(opt_hostname->getValue());
783
    unsigned int label_count = OptionDataTypeUtil::getLabelCount(hostname);
784
    // The hostname option sent by the client should be at least 1 octet long.
785
786
787
    // If it isn't we ignore this option. (Per RFC 2131, section 3.14)
    /// @todo It would be more liberal to accept this and let it fall into
    /// the case  of replace or less than two below.
788
789
790
791
    if (label_count == 0) {
        LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_EMPTY_HOSTNAME);
        return;
    }
792
793
794
795
    // Copy construct the hostname provided by the client. It is entirely
    // possible that we will use the hostname option provided by the client
    // to perform the DNS update and we will send the same option to him to
    // indicate that we accepted this hostname.
796
    OptionStringPtr opt_hostname_resp(new OptionString(*opt_hostname));
797
798
799
800
801
802
803
804

    // The hostname option may be unqualified or fully qualified. The lab_count
    // holds the number of labels for the name. The number of 1 means that
    // there is only root label "." (even for unqualified names, as the
    // getLabelCount function treats each name as a fully qualified one).
    // By checking the number of labels present in the hostname we may infer
    // whether client has sent the fully qualified or unqualified hostname.

805
806
807
808
809
810
811
812
    /// @todo We may want to reconsider whether it is appropriate for the
    /// client to send a root domain name as a Hostname. There are
    /// also extensions to the auto generation of the client's name,
    /// e.g. conversion to the puny code which may be considered at some point.
    /// For now, we just remain liberal and expect that the DNS will handle
    /// conversion if needed and possible.
    if ((d2_mgr.getD2ClientConfig()->getReplaceClientName()) ||
        (label_count < 2)) {
813
814
815
        // Set to root domain to signal later on that we should replace it.
        // DHO_HOST_NAME is a string option which cannot be empty.
        opt_hostname_resp->setValue(".");
816
    } else if (label_count == 2) {
817
818
        // If there are two labels, it means that the client has specified
        // the unqualified name. We have to concatenate the unqalified name
819
820
821
822
823
824
        // with the domain name. The false value passed as a second argument
        // indicates that the trailing dot should not be appended to the
        // hostname. We don't want to append the trailing dot because
        // we don't know whether the hostname is partial or not and some
        // clients do not handle the hostnames with the trailing dot.
        opt_hostname_resp->setValue(d2_mgr.qualifyName(hostname, false));
825
826
827
    }

    answer->addOption(opt_hostname_resp);
828
829
}

830
831
void
Dhcpv4Srv::createNameChangeRequests(const Lease4Ptr& lease,
832
                                    const Lease4Ptr& old_lease) {
833
834
835
836
837
    if (!lease) {
        isc_throw(isc::Unexpected,
                  "NULL lease specified when creating NameChangeRequest");
    }

838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
    // If old lease is not NULL, it is an indication that the lease has
    // just been renewed. In such case we may need to generate the
    // additional NameChangeRequest to remove an existing entry before
    // we create a NameChangeRequest to add the entry for an updated lease.
    // We may also decide not to generate any requests at all. This is when
    // we discover that nothing has changed in the client's FQDN data.
    if (old_lease) {
        if (!lease->matches(*old_lease)) {
            isc_throw(isc::Unexpected,
                      "there is no match between the current instance of the"
                      " lease: " << lease->toText() << ", and the previous"
                      " instance: " << lease->toText());
        } else {
            // There will be a NameChangeRequest generated to remove existing
            // DNS entries if the following conditions are met:
            // - The hostname is set for the existing lease, we can't generate
            //   removal request for non-existent hostname.
            // - A server has performed reverse, forward or both updates.
            // - FQDN data between the new and old lease do not match.
857
            if (!lease->hasIdenticalFqdn(*old_lease)) {
858
859
                queueNameChangeRequest(isc::dhcp_ddns::CHG_REMOVE,
                                       old_lease);
860
861

            // If FQDN data from both leases match, there is no need to update.
862
            } else if (lease->hasIdenticalFqdn(*old_lease)) {
863
                return;
864

865
866
867
868
869
            }

        }
    }

870
871
872
873
    // We may need to generate the NameChangeRequest for the new lease. It
    // will be generated only if hostname is set and if forward or reverse
    // update has been requested.
    queueNameChangeRequest(isc::dhcp_ddns::CHG_ADD, lease);
874
875
}

876
877
void
Dhcpv4Srv::
878
879
880
881
882
883
884
885
queueNameChangeRequest(const isc::dhcp_ddns::NameChangeType chg_type,
                       const Lease4Ptr& lease) {
    // The hostname must not be empty, and at least one type of update
    // should be requested.
    if (!lease || lease->hostname_.empty() ||
        (!lease->fqdn_rev_ && !lease->fqdn_fwd_)) {
        return;
    }
886
887

    // Create the DHCID for the NameChangeRequest.
888
889
890
891
892
893
894
895
896
    D2Dhcid dhcid;
    try {
        dhcid  = computeDhcid(lease);
    } catch (const DhcidComputeError& ex) {
        LOG_ERROR(dhcp4_logger, DHCP4_DHCID_COMPUTE_ERROR)
            .arg(lease->toText())
            .arg(ex.what());
        return;
    }
897

898
    // Create NameChangeRequest
899
900
901
902
903
904
905
906
907
    NameChangeRequestPtr ncr(new NameChangeRequest(chg_type, lease->fqdn_fwd_,
                                                   lease->fqdn_rev_,
                                                   lease->hostname_,
                                                   lease->addr_.toText(),
                                                   dhcid,
                                                   (lease->cltt_ +
                                                    lease->valid_lft_),
                                                   lease->valid_lft_));

908
909
    LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_QUEUE_NCR)
        .arg(chg_type == CHG_ADD ? "add" : "remove")
910
        .arg(ncr->toText());
911

912
913
    // And pass it to the the manager.
    CfgMgr::instance().getD2ClientMgr().sendRequest(ncr);
914
}
915

916
917
void
Dhcpv4Srv::assignLease(const Pkt4Ptr& question, Pkt4Ptr& answer) {
918
919
920
921
922
923
924
925
926
927
928
929

    // We need to select a subnet the client is connected in.
    Subnet4Ptr subnet = selectSubnet(question);
    if (!subnet) {
        // This particular client is out of luck today. We do not have
        // information about the subnet he is connected to. This likely means
        // misconfiguration of the server (or some relays). We will continue to
        // process this message, but our response will be almost useless: no
        // addresses or prefixes, no subnet specific configuration etc. The only
        // thing this client can get is some global information (like DNS
        // servers).

930
931
        // perhaps this should be logged on some higher level? This is most
        // likely configuration bug.
932
933
934
        LOG_ERROR(dhcp4_logger, DHCP4_SUBNET_SELECTION_FAILED)
            .arg(question->getRemoteAddr().toText())
            .arg(serverReceivedPacketName(question->getType()));
935
        answer->setType(DHCPNAK);
936
937
938
        answer->setYiaddr(IOAddress("0.0.0.0"));
        return;
    }
939

940
941
942
943
    // Set up siaddr. Perhaps assignLease is not the best place to call this
    // as siaddr has nothing to do with a lease, but otherwise we would have
    // to select subnet twice (performance hit) or update too many functions
    // at once.
944
    /// @todo: move subnet selection to a common code
945
946
    answer->setSiaddr(subnet->getSiaddr());

947
948
949
    LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_SUBNET_SELECTED)
        .arg(subnet->toText());

950
951
952
953
954
955
    // Get client-id option
    ClientIdPtr client_id;
    OptionPtr opt = question->getOption(DHO_DHCP_CLIENT_IDENTIFIER);
    if (opt) {
        client_id = ClientIdPtr(new ClientId(opt->getData()));
    }
956

957
    // client-id is not mandatory in DHCPv4
958

959
960
961
962
963
    // Get the server identifier. It will be used to determine the state
    // of the client.
    OptionCustomPtr opt_serverid = boost::dynamic_pointer_cast<
        OptionCustom>(question->getOption(DHO_DHCP_SERVER_IDENTIFIER));

964
965
    // Check if the client has sent a requested IP address option or
    // ciaddr.
966
967
968
969
970
    OptionCustomPtr opt_requested_address = boost::dynamic_pointer_cast<
        OptionCustom>(question->getOption(DHO_DHCP_REQUESTED_ADDRESS));
    IOAddress hint("0.0.0.0");
    if (opt_requested_address) {
        hint = opt_requested_address->readAddress();
971
972
973
974

    } else if (question->getCiaddr() != IOAddress("0.0.0.0")) {
        hint = question->getCiaddr();

975
    }
976

977
    HWAddrPtr hwaddr = question->getHWAddr();
978

979
980
981
982
983
984
    // "Fake" allocation is processing of DISCOVER message. We pretend to do an
    // allocation, but we do not put the lease in the database. That is ok,
    // because we do not guarantee that the user will get that exact lease. If
    // the user selects this server to do actual allocation (i.e. sends REQUEST)
    // it should include this hint. That will help us during the actual lease
    // allocation.
985
    bool fake_allocation = (question->getType() == DHCPDISCOVER);
986

987
988
989
990
991
992
993
994
    // If there is no server id and there is a Requested IP Address option
    // the client is in the INIT-REBOOT state in which the server has to
    // determine whether the client's notion of the address has to be verified.
    if (!fake_allocation && !opt_serverid && opt_requested_address) {
        Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(hint);
        if (!lease) {
            LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL,
                      DHCP4_INVALID_ADDRESS_INIT_REBOOT)
995
                .arg(hint.toText())
996
                .arg(client_id ? client_id->toText():"(no client-id)")
997
                .arg(hwaddr ? hwaddr->toText():"(no hwaddr info)");
998
999
1000
1001
1002
1003
1004
1005

            answer->setType(DHCPNAK);
            answer->setYiaddr(IOAddress("0.0.0.0"));
            return;
        }
    }


1006
1007
    CalloutHandlePtr callout_handle = getCalloutHandle(question);

1008
1009
1010
    std::string hostname;
    bool fqdn_fwd = false;
    bool fqdn_rev = false;
1011
    OptionStringPtr opt_hostname;
1012
1013
1014
1015
    Option4ClientFqdnPtr fqdn = boost::dynamic_pointer_cast<
        Option4ClientFqdn>(answer->getOption(DHO_FQDN));
    if (fqdn) {
        hostname = fqdn->getDomainName();
1016
1017
1018
        CfgMgr::instance().getD2ClientMgr().getUpdateDirections(*fqdn,
                                                                fqdn_fwd,
                                                                fqdn_rev);
1019
    } else {
1020
        opt_hostname = boost::dynamic_pointer_cast<OptionString>
1021
            (answer->getOption(DHO_HOST_NAME));
1022
        if (opt_hostname) {
1023
1024
1025
1026
1027
1028
1029
1030
            hostname = opt_hostname->getValue();
            // DHO_HOST_NAME is string option which cannot be blank,
            // we use "." to know we should replace it with a fully
            // generated name. The local string variable needs to be
            // blank in logic below.
            if (hostname == ".") {
                hostname = "";
            }
1031
1032
            /// @todo It could be configurable what sort of updates the
            /// server is doing when Hostname option was sent.
1033
1034
1035
            fqdn_fwd = true;
            fqdn_rev = true;
        }
1036
1037
    }

1038
1039
1040
1041
    // Use allocation engine to pick a lease for this client. Allocation engine
    // will try to honour the hint, but it is just a hint - some other address
    // may be used instead. If fake_allocation is set to false, the lease will
    // be inserted into the LeaseMgr as well.
1042
    /// @todo pass the actual FQDN data.
1043
    Lease4Ptr old_lease;
1044
    Lease4Ptr lease = alloc_engine_->allocateLease4(subnet, client_id, hwaddr,
1045
1046
                                                    hint, fqdn_fwd, fqdn_rev,
                                                    hostname,
1047
1048
1049
                                                    fake_allocation,
                                                    callout_handle,
                                                    old_lease);
1050
1051

    if (lease) {
1052
1053
        // We have a lease! Let's set it in the packet and send it back to
        // the client.
1054
1055
        LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL, fake_allocation?
                  DHCP4_LEASE_ADVERT:DHCP4_LEASE_ALLOC)
Tomek Mrugalski's avatar
Tomek Mrugalski committed
1056
            .arg(lease->addr_.toText())
1057
            .arg(client_id?client_id->toText():"(no client-id)")
Tomek Mrugalski's avatar
Tomek Mrugalski committed
1058
            .arg(hwaddr?hwaddr->toText():"(no hwaddr info)");
1059
1060
1061

        answer->setYiaddr(lease->addr_);

1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
        /// @todo The server should check what ciaddr the client has supplied
        /// in ciaddr. Currently the ciaddr is ignored except for the subnet
        /// selection. If the client supplied an invalid address, the server
        /// will also return an invalid address here.
        if (!fake_allocation) {
            // If this is a renewing client it will set a ciaddr which the
            // server may include in the response. If this is a new allocation
            // the client will set ciaddr to 0 and this will also be propagated
            // to the server's answer.
            answer->setCiaddr(question->getCiaddr());
        }

1074
1075
1076
1077
        // If there has been Client FQDN or Hostname option sent, but the
        // hostname is empty, it means that server is responsible for
        // generating the entire hostname for the client. The example of the
        // client's name, generated from the IP address is: host-192-0-2-3.
1078
1079
1080
1081
1082
1083
1084
1085
1086
        if ((fqdn || opt_hostname) && lease->hostname_.empty()) {
            // Note that if we have received the hostname option, rather than
            // Client FQDN the trailing dot is not appended to the generated
            // hostname because some clients don't handle the trailing dot in
            // the hostname. Whether the trailing dot is appended or not is
            // controlled by the second argument to the generateFqdn().
            lease->hostname_ = CfgMgr::instance().getD2ClientMgr()
                .generateFqdn(lease->addr_, static_cast<bool>(fqdn));

1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
            // The operations below are rather safe, but we want to catch
            // any potential exceptions (e.g. invalid lease database backend
            // implementation) and log an error.
            try {
                // The lease update should be safe, because the lease should
                // be already in the database. In most cases the exception
                // would be thrown if the lease was missing.
                LeaseMgrFactory::instance().updateLease4(lease);
                // The name update in the option should be also safe,
                // because the generated name is well formed.
                if (fqdn) {
                    fqdn->setDomainName(lease->hostname_,
                                        Option4ClientFqdn::FULL);
                } else if (opt_hostname) {
1101
                    opt_hostname->setValue(lease->hostname_);
1102
1103
1104
1105
1106
1107
1108
1109
                }

            } catch (const Exception& ex) {
                LOG_ERROR(dhcp4_logger, DHCP4_NAME_GEN_UPDATE_FAIL)
                    .arg(ex.what());
            }
        }

1110
        // IP Address Lease time (type 51)
1111
1112
        opt.reset(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME,
                                   lease->valid_lft_));
1113
1114
1115
1116
1117
        answer->addOption(opt);

        // Subnet mask (type 1)
        answer->addOption(getNetmaskOption(subnet));

1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
        // renewal-timer (type 58)
        if (!subnet->getT1().unspecified()) {
            OptionUint32Ptr t1(new OptionUint32(Option::V4,
                                                DHO_DHCP_RENEWAL_TIME,
                                                subnet->getT1()));
            answer->addOption(t1);
        }

        // rebind timer (type 59)
        if (!subnet->getT2().unspecified()) {
            OptionUint32Ptr t2(new OptionUint32(Option::V4,
                                                DHO_DHCP_REBINDING_TIME,
                                                subnet->getT2()));
            answer->addOption(t2);
        }
1133

1134
1135
1136
        // Create NameChangeRequests if DDNS is enabled and this is a
        // real allocation.
        if (!fake_allocation && CfgMgr::instance().ddnsEnabled()) {
1137
1138
1139
1140
1141
1142
1143
1144
            try {
                createNameChangeRequests(lease, old_lease);
            } catch (const Exception& ex) {
                LOG_ERROR(dhcp4_logger, DHCP4_NCR_CREATION_FAILED)
                    .arg(ex.what());
            }
        }

1145
1146
    } else {
        // Allocation engine did not allocate a lease. The engine logged
1147
        // cause of that failure. The only thing left is to insert
1148
1149
1150
1151
1152
1153
1154
1155
        // status code to pass the sad news to the client.

        LOG_DEBUG(dhcp4_logger, DBG_DHCP4_DETAIL, fake_allocation?
                  DHCP4_LEASE_ADVERT_FAIL:DHCP4_LEASE_ALLOC_FAIL)
            .arg(client_id?client_id->toText():"(no client-id)")
            .arg(hwaddr?hwaddr->toText():"(no hwaddr info)")
            .arg(hint.toText());

1156
        answer->setType(DHCPNAK);
1157
        answer->setYiaddr(IOAddress("0.0.0.0"));
1158
1159
1160

        answer->delOption(DHO_FQDN);
        answer->delOption(DHO_HOST_NAME);
1161
1162
1163
    }
}

1164
void
1165
1166
1167
1168
1169
Dhcpv4Srv::adjustIfaceData(const Pkt4Ptr& query, const Pkt4Ptr& response) {
    adjustRemoteAddr(query, response);

    // For the non-relayed message, the destination port is the client's port.
    // For the relayed message, the server/relay port is a destination.