pkt4.h 15.5 KB
Newer Older
1
// Copyright (C) 2011-2012 Internet Systems Consortium, Inc. ("ISC")
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
//
// 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.

#ifndef PKT4_H
#define PKT4_H

#include <iostream>
19
#include <time.h>
20
#include <vector>
21
#include <boost/shared_ptr.hpp>
22
#include <boost/date_time/posix_time/posix_time.hpp>
23 24 25 26 27 28 29 30 31 32 33
#include "asiolink/io_address.h"
#include "util/buffer.h"
#include "dhcp/option.h"

namespace isc {

namespace dhcp {

class Pkt4 {
public:

34
    /// length of the CHADDR field in DHCPv4 message
35 36
    const static size_t MAX_CHADDR_LEN = 16;

37
    /// length of the SNAME field in DHCPv4 message
38 39
    const static size_t MAX_SNAME_LEN = 64;

40
    /// length of the FILE field in DHCPv4 message
41 42
    const static size_t MAX_FILE_LEN = 128;

43
    /// specifies DHCPv4 packet header length (fixed part)
44 45
    const static size_t DHCPV4_PKT_HDR_LEN = 236;

46
    /// Constructor, used in replying to a message.
47 48 49 50 51
    ///
    /// @param msg_type type of message (e.g. DHCPDISOVER=1)
    /// @param transid transaction-id
    Pkt4(uint8_t msg_type, uint32_t transid);

52
    /// @brief Constructor, used in message reception.
53
    ///
54 55
    /// Creates new message. Pkt4 will copy data to bufferIn_
    /// buffer on creation.
56 57 58 59 60
    ///
    /// @param data pointer to received data
    /// @param len size of buffer to be allocated for this packet.
    Pkt4(const uint8_t* data, size_t len);

61
    /// @brief Prepares on-wire format of DHCPv4 packet.
62 63 64
    ///
    /// Prepares on-wire format of message and all its options.
    /// Options must be stored in options_ field.
65
    /// Output buffer will be stored in bufferOut_.
66 67 68 69 70
    ///
    /// @return true if packing procedure was successful
    bool
    pack();

71 72 73
    /// @brief Parses on-wire form of DHCPv4 packet.
    ///
    /// Parses received packet, stored in on-wire format in bufferIn_.
74 75 76 77
    ///
    /// Will create a collection of option objects that will
    /// be stored in options_ container.
    ///
Tomek Mrugalski's avatar
Tomek Mrugalski committed
78 79
    /// Method with throw exception if packet parsing fails.
    void unpack();
80

81 82 83 84 85 86 87 88
    /// @brief performs sanity check on a packet.
    ///
    /// This is usually performed after unpack(). It checks if packet is sane:
    /// required options are present, fields have sane content etc.
    /// For example verifies that DHCP_MESSAGE_TYPE is present and have
    /// reasonable value. This method is expected to grow significantly.
    /// It makes sense to separate unpack() and check() for testing purposes.
    ///
Tomek Mrugalski's avatar
Tomek Mrugalski committed
89 90
    /// TODO: It is called from unpack() directly. It should be separated.
    ///
91 92 93
    /// Method will throw exception if anomaly is found.
    void check();

94 95 96 97 98 99 100 101
    /// @brief Copies content of input buffer to output buffer.
    ///
    /// This is mostly a diagnostic function. It is being used for sending
    /// received packet. Received packet is stored in bufferIn_, but
    /// transmitted data is stored in bufferOut_. If we want to send packet
    /// that we just received, a copy between those two buffers is necessary.
    void repack();

102 103 104 105 106
    /// @brief Returns text representation of the packet.
    ///
    /// This function is useful mainly for debugging.
    ///
    /// @return string with text representation
107
    std::string toText();
108

109
    /// @brief Returns the size of the required buffer to build the packet.
110
    ///
111 112
    /// Returns the size of the required buffer to build the packet with
    /// the current set of packet options.
113 114
    ///
    /// @return number of bytes required to build this packet
115
    size_t len();
116

117
    /// @brief Sets hops field.
118 119
    ///
    /// @param hops value to be set
120
    void setHops(uint8_t hops) { hops_ = hops; };
121

122
    /// @brief Returns hops field.
123 124
    ///
    /// @return hops field
125
    uint8_t getHops() const { return (hops_); };
126 127 128 129

    // Note: There's no need to manipulate OP field directly,
    // thus no setOp() method. See op_ comment.

130
    /// @brief Returns op field.
131 132
    ///
    /// @return op field
133
    uint8_t getOp() const { return (op_); };
134

135
    /// @brief Sets secs field.
136 137
    ///
    /// @param secs value to be set
138
    void setSecs(uint16_t secs) { secs_ = secs; };
139

140
    /// @brief Returns secs field.
141 142
    ///
    /// @return secs field
143
    uint16_t getSecs() const { return (secs_); };
144

145
    /// @brief Sets flags field.
146 147
    ///
    /// @param flags value to be set
148
    void setFlags(uint16_t flags) { flags_ = flags; };
149

150
    /// @brief Returns flags field.
151 152
    ///
    /// @return flags field
153
    uint16_t getFlags() const { return (flags_); };
154 155


156
    /// @brief Returns ciaddr field.
157 158
    ///
    /// @return ciaddr field
Tomek Mrugalski's avatar
Tomek Mrugalski committed
159 160
    const isc::asiolink::IOAddress&
    getCiaddr() const { return (ciaddr_); };
161

162
    /// @brief Sets ciaddr field.
163 164 165 166 167 168
    ///
    /// @param ciaddr value to be set
    void
    setCiaddr(const isc::asiolink::IOAddress& ciaddr) { ciaddr_ = ciaddr; };


169
    /// @brief Returns siaddr field.
170 171
    ///
    /// @return siaddr field
Tomek Mrugalski's avatar
Tomek Mrugalski committed
172 173
    const isc::asiolink::IOAddress&
    getSiaddr() const { return (siaddr_); };
174

175
    /// @brief Sets siaddr field.
176 177 178 179 180 181
    ///
    /// @param siaddr value to be set
    void
    setSiaddr(const isc::asiolink::IOAddress& siaddr) { siaddr_ = siaddr; };


182
    /// @brief Returns yiaddr field.
183 184
    ///
    /// @return yiaddr field
Tomek Mrugalski's avatar
Tomek Mrugalski committed
185 186
    const isc::asiolink::IOAddress&
    getYiaddr() const { return (yiaddr_); };
187

188
    /// @brief Sets yiaddr field.
189 190 191 192 193 194
    ///
    /// @param yiaddr value to be set
    void
    setYiaddr(const isc::asiolink::IOAddress& yiaddr) { yiaddr_ = yiaddr; };


195
    /// @brief Returns giaddr field.
196 197
    ///
    /// @return giaddr field
Tomek Mrugalski's avatar
Tomek Mrugalski committed
198 199
    const isc::asiolink::IOAddress&
    getGiaddr() const { return (giaddr_); };
200

201
    /// @brief Sets giaddr field.
202 203 204 205 206
    ///
    /// @param giaddr value to be set
    void
    setGiaddr(const isc::asiolink::IOAddress& giaddr) { giaddr_ = giaddr; };

207
    /// @brief Returns value of transaction-id field.
208 209
    ///
    /// @return transaction-id
Tomek Mrugalski's avatar
Tomek Mrugalski committed
210
    uint32_t getTransid() const { return (transid_); };
211

212
    /// @brief Returns message type (e.g. 1 = DHCPDISCOVER).
213 214 215
    ///
    /// @return message type
    uint8_t
Tomek Mrugalski's avatar
Tomek Mrugalski committed
216
    getType() const { return (msg_type_); }
217

218
    /// @brief Sets message type (e.g. 1 = DHCPDISCOVER).
219 220 221 222 223 224 225
    ///
    /// @param type message type to be set
    void setType(uint8_t type) { msg_type_=type; };

    /// @brief Returns sname field
    ///
    /// Note: This is 64 bytes long field. It doesn't have to be
226
    /// null-terminated. Do not use strlen() or similar on it.
227 228
    ///
    /// @return sname field
229
    const OptionBuffer
Tomek Mrugalski's avatar
Tomek Mrugalski committed
230
    getSname() const { return (std::vector<uint8_t>(sname_, &sname_[MAX_SNAME_LEN])); };
231

232
    /// @brief Sets sname field.
233 234
    ///
    /// @param sname value to be set
235 236
    /// @param sname_len length of the sname buffer (up to MAX_SNAME_LEN)
    void setSname(const uint8_t* sname, size_t sname_len = MAX_SNAME_LEN);
237 238 239 240

    /// @brief Returns file field
    ///
    /// Note: This is 128 bytes long field. It doesn't have to be
241
    /// null-terminated. Do not use strlen() or similar on it.
242 243
    ///
    /// @return pointer to file field
244
    const OptionBuffer
Tomek Mrugalski's avatar
Tomek Mrugalski committed
245
    getFile() const { return (std::vector<uint8_t>(file_, &file_[MAX_FILE_LEN])); };
246 247 248 249

    /// Sets file field
    ///
    /// @param file value to be set
250
    /// @param file_len length of the file buffer (up to MAX_FILE_LEN)
251
    void
252
    setFile(const uint8_t* file, size_t file_len = MAX_FILE_LEN);
253

254 255 256 257 258 259 260
    /// @brief Sets hardware address.
    ///
    /// Sets parameters of hardware address. hlen specifies
    /// length of macAddr buffer. Content of macAddr buffer
    /// will be copied to appropriate field.
    ///
    /// Note: macAddr must be a buffer of at least hlen bytes.
261
    ///
262
    /// @param hType hardware type (will be sent in htype field)
263 264 265
    /// @param hlen hardware length (will be sent in hlen field)
    /// @param macAddr pointer to hardware address
    void setHWAddr(uint8_t hType, uint8_t hlen,
266
                   const std::vector<uint8_t>& macAddr);
267 268 269 270 271

    /// Returns htype field
    ///
    /// @return hardware type
    uint8_t
Tomek Mrugalski's avatar
Tomek Mrugalski committed
272
    getHtype() const { return (htype_); };
273 274 275 276 277

    /// Returns hlen field
    ///
    /// @return hardware address length
    uint8_t
Tomek Mrugalski's avatar
Tomek Mrugalski committed
278
    getHlen() const { return (hlen_); };
279

280
    /// @brief Returns chaddr field.
281 282 283 284 285 286
    ///
    /// Note: This is 16 bytes long field. It doesn't have to be
    /// null-terminated. Do no use strlen() or similar on it.
    ///
    /// @return pointer to hardware address
    const uint8_t*
Tomek Mrugalski's avatar
Tomek Mrugalski committed
287
    getChaddr() const { return (chaddr_); };
288 289


290
    /// @brief Returns reference to output buffer.
291 292
    ///
    /// Returned buffer will contain reasonable data only for
Tomek Mrugalski's avatar
Tomek Mrugalski committed
293 294
    /// output (TX) packet and after pack() was called. This buffer
    /// is only valid till Pkt4 object is valid.
295 296 297 298 299
    ///
    /// RX packet or TX packet before pack() will return buffer with
    /// zero length
    ///
    /// @return reference to output buffer
Tomek Mrugalski's avatar
Tomek Mrugalski committed
300 301
    const isc::util::OutputBuffer&
    getBuffer() const { return (bufferOut_); };
302

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
    /// @brief Add an option.
    ///
    /// Throws BadValue if option with that type is already present.
    ///
    /// @param opt option to be added
    void
    addOption(boost::shared_ptr<Option> opt);

    /// @brief Returns an option of specified type.
    ///
    /// @return returns option of requested type (or NULL)
    ///         if no such option is present
    boost::shared_ptr<Option>
    getOption(uint8_t opt_type);

318 319 320 321 322 323
    /// @brief Returns interface name.
    ///
    /// Returns interface name over which packet was received or is
    /// going to be transmitted.
    ///
    /// @return interface name
Tomek Mrugalski's avatar
Tomek Mrugalski committed
324
    std::string getIface() const { return iface_; };
325

326 327 328 329 330 331
    /// @brief Returns packet timestamp.
    ///
    /// Returns packet timestamp value updated when
    /// packet is received or send.
    ///
    /// @return packet timestamp.
332
    const boost::posix_time::ptime& getTimestamp() const { return timestamp_; }
333

334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
    /// @brief Sets interface name.
    ///
    /// Sets interface name over which packet was received or is
    /// going to be transmitted.
    ///
    /// @return interface name
    void setIface(const std::string& iface ) { iface_ = iface; };

    /// @brief Sets interface index.
    ///
    /// @param ifindex specifies interface index.
    void setIndex(uint32_t ifindex) { ifindex_ = ifindex; };

    /// @brief Returns interface index.
    ///
    /// @return interface index
350
    uint32_t getIndex() const { return (ifindex_); };
351 352 353

    /// @brief Sets remote address.
    ///
354
    /// @param remote specifies remote address
355 356 357 358 359 360 361 362 363 364 365 366 367
    void setRemoteAddr(const isc::asiolink::IOAddress& remote) {
        remote_addr_ = remote;
    }

    /// @brief Returns remote address
    ///
    /// @return remote address
    const isc::asiolink::IOAddress& getRemoteAddr() {
        return (remote_addr_);
    }

    /// @brief Sets local address.
    ///
368
    /// @param local specifies local address
369 370 371 372 373 374 375 376 377 378 379 380 381
    void setLocalAddr(const isc::asiolink::IOAddress& local) {
        local_addr_ = local;
    }

    /// @brief Returns local address.
    ///
    /// @return local address
    const isc::asiolink::IOAddress& getLocalAddr() {
        return (local_addr_);
    }

    /// @brief Sets local port.
    ///
382
    /// @param local specifies local port
383 384 385 386 387 388 389 390 391
    void setLocalPort(uint16_t local) { local_port_ = local; }

    /// @brief Returns local port.
    ///
    /// @return local port
    uint16_t getLocalPort() { return (local_port_); }

    /// @brief Sets remote port.
    ///
392
    /// @param remote specifies remote port
393 394 395 396 397 398 399
    void setRemotePort(uint16_t remote) { remote_port_ = remote; }

    /// @brief Returns remote port.
    ///
    /// @return remote port
    uint16_t getRemotePort() { return (remote_port_); }

400 401 402 403 404 405 406 407
    /// @brief Update packet timestamp.
    ///
    /// Updates packet timestamp. This method is invoked
    /// by interface manager just before sending or
    /// just after receiving it.
    /// @throw isc::Unexpected if timestamp update failed
    void updateTimestamp();

408 409
protected:

410 411 412 413 414 415 416 417
    /// converts DHCP message type to BOOTP op type
    ///
    /// @param dhcpType DHCP message type (e.g. DHCPDISCOVER)
    ///
    /// @return BOOTP type (BOOTREQUEST or BOOTREPLY)
    uint8_t
    DHCPTypeToBootpType(uint8_t dhcpType);

418 419 420 421 422 423 424 425 426 427 428
    /// local address (dst if receiving packet, src if sending packet)
    isc::asiolink::IOAddress local_addr_;

    /// remote address (src if receiving packet, dst if sending packet)
    isc::asiolink::IOAddress remote_addr_;

    /// name of the network interface the packet was received/to be sent over
    std::string iface_;

    /// @brief interface index
    ///
429 430 431
    /// Each network interface has assigned unique ifindex. It is functional
    /// equvalent of name, but sometimes more useful, e.g. when using crazy
    /// systems that allow spaces in interface names e.g. MS Windows)
432
    uint32_t ifindex_;
433 434

    /// local UDP port
435
    uint16_t local_port_;
436 437

    /// remote UDP port
438
    uint16_t remote_port_;
439

440
    /// @brief message operation code
441
    ///
442 443 444 445 446
    /// Note: This is legacy BOOTP field. There's no need to manipulate it
    /// directly. Its value is set based on DHCP message type. Note that
    /// DHCPv4 protocol reuses BOOTP message format, so this field is
    /// kept due to BOOTP format. This is NOT DHCPv4 type (DHCPv4 message
    /// type is kept in message type option).
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
    uint8_t op_;

    /// link-layer address type
    uint8_t htype_;

    /// link-layer address length
    uint8_t hlen_;

    /// Number of relay agents traversed
    uint8_t hops_;

    /// DHCPv4 transaction-id (32 bits, not 24 bits as in DHCPv6)
    uint32_t transid_;

    /// elapsed (number of seconds since beginning of transmission)
    uint16_t secs_;

    /// flags
    uint16_t flags_;

467
    /// ciaddr field (32 bits): Client's IP address
468 469
    isc::asiolink::IOAddress ciaddr_;

470
    /// yiaddr field (32 bits): Client's IP address ("your"), set by server
471 472
    isc::asiolink::IOAddress yiaddr_;

473
    /// siaddr field (32 bits): next server IP address in boot process(e.g.TFTP)
474 475
    isc::asiolink::IOAddress siaddr_;

476
    /// giaddr field (32 bits): Gateway IP address
477 478
    isc::asiolink::IOAddress giaddr_;

479 480 481 482 483
    /// Hardware address field (16 bytes)
    uint8_t chaddr_[MAX_CHADDR_LEN];

    /// sname field (64 bytes)
    uint8_t sname_[MAX_SNAME_LEN];
484

485 486
    /// file field (128 bytes)
    uint8_t file_[MAX_FILE_LEN];
487 488 489

    // end of real DHCPv4 fields

490
    /// output buffer (used during message transmission)
491 492
    isc::util::OutputBuffer bufferOut_;

493 494 495 496
    /// that's the data of input buffer used in RX packet. Note that
    /// InputBuffer does not store the data itself, but just expects that
    /// data will be valid for the whole life of InputBuffer. Therefore we
    /// need to keep the data around.
497 498
    std::vector<uint8_t> data_;

499
    /// message type (e.g. 1=DHCPDISCOVER)
500
    /// TODO: this will eventually be replaced with DHCP Message Type
501 502 503 504
    /// option (option 53)
    uint8_t msg_type_;

    /// collection of options present in this message
505
    isc::dhcp::Option::OptionCollection options_;
506 507

    /// packet timestamp
508
    boost::posix_time::ptime timestamp_;
509 510
}; // Pkt4 class

511 512
typedef boost::shared_ptr<Pkt4> Pkt4Ptr;

513 514 515 516 517
} // isc::dhcp namespace

} // isc namespace

#endif