pkt6.cc 23.7 KB
Newer Older
Tomek Mrugalski's avatar
Tomek Mrugalski committed
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
16
#include <config.h>

17
18
#include <dhcp/dhcp6.h>
#include <dhcp/libdhcp++.h>
19
#include <dhcp/option.h>
20
#include <dhcp/option_vendor_class.h>
21
#include <dhcp/option_vendor.h>
22
#include <dhcp/pkt6.h>
23
#include <dhcp/docsis3_option_defs.h>
24
#include <util/io_utilities.h>
25
#include <exceptions/exceptions.h>
26
#include <dhcp/duid.h>
27
#include <dhcp/iface_mgr.h>
28

29
#include <iostream>
30
31
32
#include <sstream>

using namespace std;
33
using namespace isc::asiolink;
34

Tomek Mrugalski's avatar
Tomek Mrugalski committed
35
36
37
/// @brief Default address used in Pkt6 constructor
const IOAddress DEFAULT_ADDRESS6("::");

38
namespace isc {
39
namespace dhcp {
40

41
Pkt6::RelayInfo::RelayInfo()
42
43
    :msg_type_(0), hop_count_(0), linkaddr_(DEFAULT_ADDRESS6),
    peeraddr_(DEFAULT_ADDRESS6), relay_msg_len_(0) {
44
45
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
46
47
48
Pkt6::Pkt6(const uint8_t* buf, uint32_t buf_len, DHCPv6Proto proto /* = UDP */)
   :Pkt(buf, buf_len, DEFAULT_ADDRESS6, DEFAULT_ADDRESS6, 0, 0),
    proto_(proto), msg_type_(0) {
49
}
50

Tomek Mrugalski's avatar
Tomek Mrugalski committed
51
52
53
Pkt6::Pkt6(uint8_t msg_type, uint32_t transid, DHCPv6Proto proto /*= UDP*/)
:Pkt(transid, DEFAULT_ADDRESS6, DEFAULT_ADDRESS6, 0, 0), proto_(proto),
    msg_type_(msg_type) {
54
55
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
56
size_t Pkt6::len() {
57
58
59
    if (relay_info_.empty()) {
        return (directLen());
    } else {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
60
61
62
        // Unfortunately we need to re-calculate relay size every time, because
        // we need to make sure that once a new option is added, its extra size
        // is reflected in Pkt6::len().
63
64
65
66
67
        calculateRelaySizes();
        return (relay_info_[0].relay_msg_len_ + getRelayOverhead(relay_info_[0]));
    }
}

68
69
70
OptionPtr Pkt6::getAnyRelayOption(uint16_t opt_type, RelaySearchOrder order) {

    if (relay_info_.empty()) {
71
        // There's no relay info, this is a direct message
72
73
74
        return (OptionPtr());
    }

75
76
77
78
    int start = 0; // First relay to check
    int end = 0;   // Last relay to check
    int direction = 0; // How we going to iterate: forward or backward?

79
80
    switch (order) {
    case RELAY_SEARCH_FROM_CLIENT:
81
        // Search backwards
82
83
84
85
86
        start = relay_info_.size() - 1;
        end = 0;
        direction = -1;
        break;
    case RELAY_SEARCH_FROM_SERVER:
87
        // Search forward
88
89
90
91
        start = 0;
        end = relay_info_.size() - 1;
        direction = 1;
        break;
92
93
    case RELAY_GET_FIRST:
        // Look at the innermost relay only
94
95
        start = relay_info_.size() - 1;
        end = start;
96
        direction = 1;
97
        break;
98
99
    case RELAY_GET_LAST:
        // Look at the outermost relay only
100
101
        start = 0;
        end = 0;
102
        direction = 1;
103
104
    }

105
    // This is a tricky loop. It must go from start to end, but it must work in
106
    // both directions (start > end; or start < end). We can't use regular
107
108
109
110
111
    // exit condition, because we don't know whether to use i <= end or i >= end.
    // That's why we check if in the next iteration we would go past the
    // list (end + direction). It is similar to STL concept of end pointing
    // to a place after the last element
    for (int i = start; i != end + direction; i += direction) {
112
113
114
115
116
117
        OptionPtr opt = getRelayOption(opt_type, i);
        if (opt) {
            return (opt);
        }
    }

118
119
120
    // We iterated over specified relays and haven't found what we were
    // looking for
    return (OptionPtr());
121
122
}

123
124
125
126
127
128
OptionPtr Pkt6::getRelayOption(uint16_t opt_type, uint8_t relay_level) {
    if (relay_level >= relay_info_.size()) {
        isc_throw(OutOfRange, "This message was relayed " << relay_info_.size() << " time(s)."
                  << " There is no info about " << relay_level + 1 << " relay.");
    }

129
    for (OptionCollection::iterator it = relay_info_[relay_level].options_.begin();
130
131
132
133
134
135
136
137
138
         it != relay_info_[relay_level].options_.end(); ++it) {
        if ((*it).second->getType() == opt_type) {
            return (it->second);
        }
    }

    return (OptionPtr());
}

139
uint16_t Pkt6::getRelayOverhead(const RelayInfo& relay) const {
140
141
142
    uint16_t len = DHCPV6_RELAY_HDR_LEN // fixed header
        + Option::OPTION6_HDR_LEN; // header of the relay-msg option

143
    for (OptionCollection::const_iterator opt = relay.options_.begin();
144
         opt != relay.options_.end(); ++opt) {
145
146
147
148
149
150
151
152
153
154
        len += (opt->second)->len();
    }

    return (len);
}

uint16_t Pkt6::calculateRelaySizes() {

    uint16_t len = directLen(); // start with length of all options

Tomek Mrugalski's avatar
Tomek Mrugalski committed
155
    for (int relay_index = relay_info_.size(); relay_index > 0; --relay_index) {
156
157
158
159
160
161
162
        relay_info_[relay_index - 1].relay_msg_len_ = len;
        len += getRelayOverhead(relay_info_[relay_index - 1]);
    }

    return (len);
}

163
uint16_t Pkt6::directLen() const {
164
    uint16_t length = DHCPV6_PKT_HDR_LEN; // DHCPv6 header
165

166
    for (OptionCollection::const_iterator it = options_.begin();
167
168
169
170
171
         it != options_.end();
         ++it) {
        length += (*it).second->len();
    }

172
    return (length);
173
174
175
}


176
void
177
178
179
Pkt6::pack() {
    switch (proto_) {
    case UDP:
180
181
        packUDP();
        break;
182
    case TCP:
183
184
        packTCP();
        break;
185
186
187
188
189
    default:
        isc_throw(BadValue, "Invalid protocol specified (non-TCP, non-UDP)");
    }
}

190
void
191
192
Pkt6::packUDP() {
    try {
193
194
        // Make sure that the buffer is empty before we start writting to it.
        buffer_out_.clear();
195

Tomek Mrugalski's avatar
Tomek Mrugalski committed
196
        // is this a relayed packet?
197
        if (!relay_info_.empty()) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
198
199
200
201
202
203

            // calculate size needed for each relay (if there is only one relay,
            // then it will be equal to "regular" length + relay-forw header +
            // size of relay-msg option header + possibly size of interface-id
            // option (if present). If there is more than one relay, the whole
            // process is called iteratively for each relay.
204
205
            calculateRelaySizes();

Tomek Mrugalski's avatar
Tomek Mrugalski committed
206
            // Now for each relay, we need to...
207
208
            for (vector<RelayInfo>::iterator relay = relay_info_.begin();
                 relay != relay_info_.end(); ++relay) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
209
210

                // build relay-forw/relay-repl header (see RFC3315, section 7)
211
212
213
                buffer_out_.writeUint8(relay->msg_type_);
                buffer_out_.writeUint8(relay->hop_count_);
                buffer_out_.writeData(&(relay->linkaddr_.toBytes()[0]),
214
                                     isc::asiolink::V6ADDRESS_LEN);
215
                buffer_out_.writeData(&relay->peeraddr_.toBytes()[0],
216
217
                                     isc::asiolink::V6ADDRESS_LEN);

Tomek Mrugalski's avatar
Tomek Mrugalski committed
218
219
220
221
222
                // store every option in this relay scope. Usually that will be
                // only interface-id, but occasionally other options may be
                // present here as well (vendor-opts for Cable modems,
                // subscriber-id, remote-id, options echoed back from Echo
                // Request Option, etc.)
223
                for (OptionCollection::const_iterator opt =
224
225
                         relay->options_.begin();
                     opt != relay->options_.end(); ++opt) {
226
                    (opt->second)->pack(buffer_out_);
227
228
                }

Tomek Mrugalski's avatar
Tomek Mrugalski committed
229
230
231
232
                // and include header relay-msg option. Its payload will be
                // generated in the next iteration (if there are more relays)
                // or outside the loop (if there are no more relays and the
                // payload is a direct message)
233
234
                buffer_out_.writeUint16(D6O_RELAY_MSG);
                buffer_out_.writeUint16(relay->relay_msg_len_);
235
236
237
238
            }

        }

239
        // DHCPv6 header: message-type (1 octect) + transaction id (3 octets)
240
        buffer_out_.writeUint8(msg_type_);
241
        // store 3-octet transaction-id
242
243
244
        buffer_out_.writeUint8( (transid_ >> 16) & 0xff );
        buffer_out_.writeUint8( (transid_ >> 8) & 0xff );
        buffer_out_.writeUint8( (transid_) & 0xff );
245

246
        // the rest are options
247
        LibDHCP::packOptions(buffer_out_, options_);
248
    }
249
    catch (const Exception& e) {
250
251
       // An exception is thrown and message will be written to Logger
       isc_throw(InvalidOperation, e.what());
252
253
254
    }
}

255
void
256
257
Pkt6::packTCP() {
    /// TODO Implement this function.
258
    isc_throw(NotImplemented, "DHCPv6 over TCP (bulk leasequery and failover)"
259
              "not implemented yet.");
260
261
}

262
void
263
264
265
266
267
268
269
270
271
272
273
Pkt6::unpack() {
    switch (proto_) {
    case UDP:
        return unpackUDP();
    case TCP:
        return unpackTCP();
    default:
        isc_throw(BadValue, "Invalid protocol specified (non-TCP, non-UDP)");
    }
}

274
void
275
Pkt6::unpackUDP() {
276
    if (data_.size() < 4) {
277
278
        isc_throw(BadValue, "Received truncated UDP DHCPv6 packet of size "
                  << data_.size() << ", DHCPv6 header alone has 4 bytes.");
279
280
    }
    msg_type_ = data_[0];
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
    switch (msg_type_) {
    case DHCPV6_SOLICIT:
    case DHCPV6_ADVERTISE:
    case DHCPV6_REQUEST:
    case DHCPV6_CONFIRM:
    case DHCPV6_RENEW:
    case DHCPV6_REBIND:
    case DHCPV6_REPLY:
    case DHCPV6_DECLINE:
    case DHCPV6_RECONFIGURE:
    case DHCPV6_INFORMATION_REQUEST:
    default: // assume that uknown messages are not using relay format
        {
            return (unpackMsg(data_.begin(), data_.end()));
        }
    case DHCPV6_RELAY_FORW:
    case DHCPV6_RELAY_REPL:
        return (unpackRelayMsg());
    }
}

302
void
303
304
Pkt6::unpackMsg(OptionBuffer::const_iterator begin,
                OptionBuffer::const_iterator end) {
305
306
    size_t size = std::distance(begin, end);
    if (size < 4) {
307
        // truncated message (less than 4 bytes)
308
309
        isc_throw(BadValue, "Received truncated UDP DHCPv6 packet of size "
                  << data_.size() << ", DHCPv6 header alone has 4 bytes.");
310
311
312
313
314
315
    }

    msg_type_ = *begin++;

    transid_ = ( (*begin++) << 16 ) +
        ((*begin++) << 8) + (*begin++);
316
    transid_ = transid_ & 0xffffff;
317

318
319
320
321
    // See below about invoking Postel's law, as we aren't using
    // size we don't need to update it.  If we do so in the future
    // perhaps for stats gathering we can uncomment this.
    //    size -= sizeof(uint32_t); // We just parsed 4 bytes header
322

323
324
325
326
    OptionBuffer opt_buffer(begin, end);

    // If custom option parsing function has been set, use this function
    // to parse options. Otherwise, use standard function from libdhcp.
327
    size_t offset;
328
    if (callback_.empty()) {
329
        offset = LibDHCP::unpackOptions6(opt_buffer, "dhcp6", options_);
330
331
332
333
    } else {
        // The last two arguments hold the DHCPv6 Relay message offset and
        // length. Setting them to NULL because we are dealing with the
        // not-relayed message.
334
        offset = callback_(opt_buffer, "dhcp6", options_, NULL, NULL);
335
    }
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351

    // If offset is not equal to the size, then something is wrong here. We
    // either parsed past input buffer (bug in our code) or we haven't parsed
    // everything (received trailing garbage or truncated option).
    //
    // Invoking Jon Postel's law here: be conservative in what you send, and be
    // liberal in what you accept. There's no easy way to log something from
    // libdhcp++ library, so we just choose to be silent about remaining
    // bytes. We also need to quell compiler warning about unused offset
    // variable.
    //
    // if (offset != size) {
    //        isc_throw(BadValue, "Received DHCPv6 buffer of size " << size
    //                  << ", were able to parse " << offset << " bytes.");
    // }
    (void)offset;
352
353
}

354
void
355
356
357
358
359
360
361
362
363
364
365
366
367
Pkt6::unpackRelayMsg() {

    // we use offset + bufsize, because we want to avoid creating unnecessary
    // copies. There may be up to 32 relays. While using InputBuffer would
    // be probably a bit cleaner, copying data up to 32 times is unacceptable
    // price here. Hence a single buffer with offets and lengths.
    size_t bufsize = data_.size();
    size_t offset = 0;

    while (bufsize >= DHCPV6_RELAY_HDR_LEN) {

        RelayInfo relay;

368
369
370
        size_t relay_msg_offset = 0;
        size_t relay_msg_len = 0;

371
372
373
374
375
376
377
378
379
        // parse fixed header first (first 34 bytes)
        relay.msg_type_ = data_[offset++];
        relay.hop_count_ = data_[offset++];
        relay.linkaddr_ = IOAddress::fromBytes(AF_INET6, &data_[offset]);
        offset += isc::asiolink::V6ADDRESS_LEN;
        relay.peeraddr_ = IOAddress::fromBytes(AF_INET6, &data_[offset]);
        offset += isc::asiolink::V6ADDRESS_LEN;
        bufsize -= DHCPV6_RELAY_HDR_LEN; // 34 bytes (1+1+16+16)

380
381
        // parse the rest as options
        OptionBuffer opt_buffer(&data_[offset], &data_[offset+bufsize]);
382

383
384
385
386
387
388
389
390
391
        // If custom option parsing function has been set, use this function
        // to parse options. Otherwise, use standard function from libdhcp.
        if (callback_.empty()) {
            LibDHCP::unpackOptions6(opt_buffer, "dhcp6", relay.options_,
                                    &relay_msg_offset, &relay_msg_len);
        } else {
            callback_(opt_buffer, "dhcp6", relay.options_,
                      &relay_msg_offset, &relay_msg_len);
        }
392

393
394
395
396
        /// @todo: check that each option appears at most once
        //relay.interface_id_ = options->getOption(D6O_INTERFACE_ID);
        //relay.subscriber_id_ = options->getOption(D6O_SUBSCRIBER_ID);
        //relay.remote_id_ = options->getOption(D6O_REMOTE_ID);
397

398
399
400
        if (relay_msg_offset == 0 || relay_msg_len == 0) {
            isc_throw(BadValue, "Mandatory relay-msg option missing");
        }
401

402
403
        // store relay information parsed so far
        addRelayInfo(relay);
404

405
        /// @todo: implement ERO (Echo Request Option, RFC 4994) here
406

407
408
409
        if (relay_msg_len >= bufsize) {
            // length of the relay_msg option extends beyond end of the message
            isc_throw(Unexpected, "Relay-msg option is truncated.");
410
        }
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
        uint8_t inner_type = data_[offset + relay_msg_offset];
        offset += relay_msg_offset; // offset is relative
        bufsize = relay_msg_len;    // length is absolute

        if ( (inner_type != DHCPV6_RELAY_FORW) &&
             (inner_type != DHCPV6_RELAY_REPL)) {
            // Ok, the inner message is not encapsulated, let's decode it
            // directly
            return (unpackMsg(data_.begin() + offset, data_.begin() + offset
                              + relay_msg_len));
        }

        // Oh well, there's inner relay-forw or relay-repl inside. Let's
        // unpack it as well. The next loop iteration will take care
        // of that.
426
427
428
429
    }

    if ( (offset == data_.size()) && (bufsize == 0) ) {
        // message has been parsed completely
430
        return;
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
    }

    /// @todo: log here that there are additional unparsed bytes
}

void
Pkt6::addRelayInfo(const RelayInfo& relay) {
    if (relay_info_.size() > 32) {
        isc_throw(BadValue, "Massage cannot be encapsulated more than 32 times");
    }

    /// @todo: Implement type checks here (e.g. we could receive relay-forw in relay-repl)
    relay_info_.push_back(relay);
}

446
void
447
Pkt6::unpackTCP() {
448
449
    isc_throw(Unexpected, "DHCPv6 over TCP (bulk leasequery and failover) "
              "not implemented yet.");
450
451
}

452
453
HWAddrPtr
Pkt6::getMACFromDUID() {
454
455
456
457
    OptionPtr opt_duid = getOption(D6O_CLIENTID);
    if (!opt_duid) {
        return (HWAddrPtr());
    }
458

459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
    uint8_t hlen = opt_duid->getData().size();
    vector<uint8_t> hw_addr(hlen, 0);
    std::vector<unsigned char> duid_data = opt_duid->getData();

    // Read the first two bytes. That duid type.
    uint16_t duid_type = util::readUint16(&duid_data[0], duid_data.size());

    switch (duid_type) {
    case DUID::DUID_LL:
    {
        // 2 bytes of duid type, 2 bytes of hardware type and at least
        // 1 byte of actual identification
        if (duid_data.size() < 5) {
            // This duid is truncated. We can't extract anything from it.
            return (HWAddrPtr());
        }
475

476
477
478
479
480
481
482
483
484
485
486
487
        uint16_t hwtype = util::readUint16(&duid_data[2], duid_data.size() - 2);
        return (HWAddrPtr(new HWAddr(&duid_data[4], duid_data.size() - 4,
                                     hwtype)));
    }
    case DUID::DUID_LLT:
    {
        // 2 bytes of duid type, 2 bytes of hardware, 4 bytes for timestamp,
        // and at least 1 byte of actual identification
        if (duid_data.size() < 9) {
            // This duid is truncated. We can't extract anything from it.
            return (HWAddrPtr());
        }
488

489
490
491
492
493
494
495
        uint16_t hwtype = util::readUint16(&duid_data[2], duid_data.size() - 2);
        return (HWAddrPtr(new HWAddr(&duid_data[8], duid_data.size() - 8,
                                     hwtype)));
    }
    default:
        return (HWAddrPtr());
    }
496
497
}

498
499
500
std::string
Pkt6::toText() {
    stringstream tmp;
501
502
    tmp << "localAddr=[" << local_addr_ << "]:" << local_port_
        << " remoteAddr=[" << remote_addr_
503
        << "]:" << remote_port_ << endl;
504
505
    tmp << "msgtype=" << static_cast<int>(msg_type_) << ", transid=0x" <<
        hex << transid_ << dec << endl;
506
    for (isc::dhcp::OptionCollection::iterator opt=options_.begin();
507
508
509
510
511
512
513
         opt != options_.end();
         ++opt) {
        tmp << opt->second->toText() << std::endl;
    }
    return tmp.str();
}

514
isc::dhcp::OptionCollection
515
Pkt6::getOptions(uint16_t opt_type) {
516
    isc::dhcp::OptionCollection found;
517

518
    for (OptionCollection::const_iterator x = options_.begin();
519
520
521
522
523
524
         x != options_.end(); ++x) {
        if (x->first == opt_type) {
            found.insert(make_pair(opt_type, x->second));
        }
    }
    return (found);
525
526
}

527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
const char*
Pkt6::getName(uint8_t type) {
    static const char* CONFIRM = "CONFIRM";
    static const char* DECLINE = "DECLINE";
    static const char* INFORMATION_REQUEST = "INFORMATION_REQUEST";
    static const char* REBIND = "REBIND";
    static const char* RELEASE = "RELEASE";
    static const char* RENEW = "RENEW";
    static const char* REQUEST = "REQUEST";
    static const char* SOLICIT = "SOLICIT";
    static const char* UNKNOWN = "UNKNOWN";

    switch (type) {
    case DHCPV6_CONFIRM:
        return (CONFIRM);

    case DHCPV6_DECLINE:
        return (DECLINE);

    case DHCPV6_INFORMATION_REQUEST:
        return (INFORMATION_REQUEST);

    case DHCPV6_REBIND:
        return (REBIND);

    case DHCPV6_RELEASE:
        return (RELEASE);

    case DHCPV6_RENEW:
        return (RENEW);

    case DHCPV6_REQUEST:
        return (REQUEST);

    case DHCPV6_SOLICIT:
        return (SOLICIT);

    default:
        ;
    }
    return (UNKNOWN);
}

const char* Pkt6::getName() const {
    return (getName(getType()));
}
573

574
575
void Pkt6::copyRelayInfo(const Pkt6Ptr& question) {

576
    // We use index rather than iterator, because we need that as a parameter
577
578
    // passed to getRelayOption()
    for (int i = 0; i < question->relay_info_.size(); ++i) {
579
580
581
582
583
584
585
586
        RelayInfo info;
        info.msg_type_ = DHCPV6_RELAY_REPL;
        info.hop_count_ = question->relay_info_[i].hop_count_;
        info.linkaddr_ = question->relay_info_[i].linkaddr_;
        info.peeraddr_ = question->relay_info_[i].peeraddr_;

        // Is there an interface-id option in this nesting level?
        // If there is, we need to echo it back
587
588
589
        OptionPtr opt = question->getRelayOption(D6O_INTERFACE_ID, i);
        // taken from question->RelayInfo_[i].options_
        if (opt) {
590
            info.options_.insert(make_pair(opt->getType(), opt));
591
592
        }

593
        /// @todo: Implement support for ERO (Echo Request Option, RFC4994)
594

595
596
597
        // Add this relay-forw info (client's message) to our relay-repl
        // message (server's response)
        relay_info_.push_back(info);
598
599
600
    }
}

601
602
603
604
HWAddrPtr
Pkt6::getMACFromSrcLinkLocalAddr() {
    if (relay_info_.empty()) {
        // This is a direct message, use source address
Tomek Mrugalski's avatar
Tomek Mrugalski committed
605
        return (getMACFromIPv6(remote_addr_));
606
607
608
    }

    // This is a relayed message, get the peer-addr from the first relay-forw
Tomek Mrugalski's avatar
Tomek Mrugalski committed
609
    return (getMACFromIPv6(relay_info_[relay_info_.size() - 1].peeraddr_));
610
611
}

612
613
614
HWAddrPtr
Pkt6::getMACFromIPv6RelayOpt() {
    if (relay_info_.empty()) {
615
        // This is a direct message
616
617
618
619
620
621
        return (HWAddrPtr());
    }
    // RFC6969 Section 6: Look for the client_linklayer_addr option on the
    // relay agent closest to the client
    OptionPtr opt = getAnyRelayOption(D6O_CLIENT_LINKLAYER_ADDR, RELAY_GET_FIRST);
    if (opt) {
622
623
        const OptionBuffer data = opt->getData();
        if (data.size() < 3) {
624
            // This client link address option is truncated. It's supposed to be
625
626
627
628
629
630
631
            // 2 bytes of link-layer type followed by link-layer address.
            return (HWAddrPtr());
        }

        // +2, -2 means to skip the initial 2 bytes which are hwaddress type
        return (HWAddrPtr(new HWAddr(&data[0] + 2, data.size() - 2,
                                     opt->getUint16())));
632
633
634
635
636
637
638
    } else {
        return (HWAddrPtr());
    }
}

HWAddrPtr
Pkt6::getMACFromDocsisModem() {
639
640
    OptionVendorPtr vendor = boost::dynamic_pointer_cast<
        OptionVendor>(getOption(D6O_VENDOR_OPTS));
641
642

    // Check if this is indeed DOCSIS3 environment
643
    if (!vendor || vendor->getVendorId() != VENDOR_ID_CABLE_LABS) {
644
645
646
647
648
649
650
651
652
        return (HWAddrPtr());
    }

    // If it is, try to get device-id option
    OptionPtr device_id = vendor->getOption(DOCSIS3_V6_DEVICE_ID);
    if (!device_id) {
        return (HWAddrPtr());
    }

Tomek Mrugalski's avatar
Tomek Mrugalski committed
653
654
    // If the option contains any data, use it as MAC address
    if (!device_id->getData().empty()) {
655
656
657
        return (HWAddrPtr(new HWAddr(device_id->getData(), HTYPE_DOCSIS)));
    } else {
        return (HWAddrPtr());
658
    }
659
660
661
662
663
664
665
666
667
668
}

HWAddrPtr
Pkt6::getMACFromDocsisCMTS() {
    if (relay_info_.empty()) {
        // This message didn't pass through a CMTS, so there won't be any
        // CMTS-specific options in it.
        return (HWAddrPtr());
    }

669
670
    OptionVendorPtr vendor = boost::dynamic_pointer_cast<
        OptionVendor>(getAnyRelayOption(D6O_VENDOR_OPTS,
671
672
673
                                        RELAY_SEARCH_FROM_CLIENT));

    // Check if this is indeed DOCSIS3 environment
674
    if (!vendor || vendor->getVendorId() != VENDOR_ID_CABLE_LABS) {
675
676
677
678
679
680
681
682
683
        return (HWAddrPtr());
    }

    // If it is, try to get cable modem mac
    OptionPtr cm_mac = vendor->getOption(DOCSIS3_V6_CMTS_CM_MAC);
    if (!cm_mac) {
        return (HWAddrPtr());
    }

Tomek Mrugalski's avatar
Tomek Mrugalski committed
684
685
    // If the option contains any data, use it as MAC address
    if (!cm_mac->getData().empty()) {
686
687
        return (HWAddrPtr(new HWAddr(cm_mac->getData(), HTYPE_DOCSIS)));
    } else {
688
        return (HWAddrPtr());
689
690
    }
}
691

692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
HWAddrPtr
Pkt6::getMACFromRemoteIdRelayOption() {
    if (relay_info_.empty()) {
        // This is a direct message
        return (HWAddrPtr());
    }

    // Get remote-id option from a relay agent closest to the client
    OptionPtr opt = getAnyRelayOption(D6O_REMOTE_ID, RELAY_GET_FIRST);
    if (opt) {
        const OptionBuffer data = opt->getData();
        if (data.size() < 5) {
            // This remote-id option is truncated. It's supposed to be
            // 4 bytes of enterprise-number followed by remote-id.
            return (HWAddrPtr());
        }

        // Let's get the interface this packet was received on. We need it to get
        // the hardware type.
711
        IfacePtr iface = IfaceMgr::instance().getIface(iface_);
712
713
714
715
716
717
718
719
720
721
722
723
724
725
        uint16_t hwtype = 0; // not specified

        // If we get the interface HW type, great! If not, let's not panic.
        if (iface) {
            hwtype = iface->getHWType();
        }

        // Skip the initial 4 bytes which are enterprise-number.
        return (HWAddrPtr(new HWAddr(&data[0] + 4, data.size() - 4, hwtype)));
    } else {
        return (HWAddrPtr());
    }
}

726
727
} // end of isc::dhcp namespace
} // end of isc namespace