llc.h

/*
 * Copyright (c) 2017, Matias Fontanini
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef TINS_IEEE8022_H
#define TINS_IEEE8022_H
 
#include <vector>
#include <stdint.h>
#include <tins/macros.h>
#include <tins/pdu.h>
#include <tins/endianness.h>
 
namespace Tins {

class TINS_API LLC : public PDU {
public:
    static const PDU::PDUType pdu_flag = PDU::LLC;

    static const uint8_t GLOBAL_DSAP_ADDR;
    
    static const uint8_t NULL_ADDR;

    enum Format {
        INFORMATION = 0,
        SUPERVISORY = 1,
        UNNUMBERED = 3
    };

    enum ModifierFunctions {
        UI = 0x00,
        XID = 0x1D,
        TEST = 0x07,
        SABME = 0x1E,
        DISC = 0x02,
        UA = 0x06,
        DM = 0x18,
        FRMR = 0x11
    };

    enum SupervisoryFunctions {
        RECEIVE_READY = 0,
        REJECT = 2,
        RECEIVE_NOT_READY = 1
    };

    LLC();

    LLC(uint8_t dsap, uint8_t ssap);

    LLC(const uint8_t* buffer, uint32_t total_sz);
 
    /* Setters */

    void group(bool value);

    void dsap(uint8_t new_dsap);

    void response(bool value);

    void ssap(uint8_t new_ssap);

    void type(Format type);

    void send_seq_number(uint8_t seq_number);

    void receive_seq_number(uint8_t seq_number);

    void poll_final(bool value);

    void supervisory_function(SupervisoryFunctions new_func);

    void modifier_function(ModifierFunctions mod_func);

    void add_xid_information(uint8_t xid_id, 
                             uint8_t llc_type_class,
                             uint8_t receive_window);
 
    //TODO: Add Acknowledged connectionless information
 
    /* Getters */

    bool group() {
        return header_.dsap & 0x01;
    }

    uint8_t dsap() {
        return header_.dsap;
    }

    bool response() {
        return (header_.ssap & 0x01);
    }

    uint8_t ssap() {
        return header_.ssap;
    }

    uint8_t type() {
        return static_cast<uint8_t>(type_);
    }

    uint8_t send_seq_number() {
        return static_cast<uint8_t>((type() == INFORMATION) ? (control_field.info.send_seq_num) : 0);
    }

    uint8_t receive_seq_number() {
        switch (type()) {
            case INFORMATION:
                return control_field.info.recv_seq_num;
            case SUPERVISORY:
                return control_field.super.recv_seq_num;
            case UNNUMBERED:
                return 0;
            default:
                return 0;
        }
    }

    bool poll_final() {
        switch (type()) {
            case UNNUMBERED:
                return control_field.unnumbered.poll_final_bit;
            case INFORMATION:
                return control_field.info.poll_final_bit;
            case SUPERVISORY:
                return control_field.super.poll_final_bit;
            default:
                return false;
        }
    }

    uint8_t supervisory_function() {
        if (type() == SUPERVISORY) {
            return control_field.super.supervisory_func;
        }
        return 0;
    }

    uint8_t modifier_function() {
        if (type() == UNNUMBERED) {
            return (control_field.unnumbered.mod_func1 << 3) + control_field.unnumbered.mod_func2;
        }
        return 0;
    }

    uint32_t header_size() const;

    PDUType pdu_type() const {
        return pdu_flag;
    }

    void clear_information_fields();

    LLC* clone() const {
        return new LLC(*this);
    }
private:
    TINS_BEGIN_PACK
    struct llchdr {
        uint8_t dsap;
        uint8_t ssap;
    } TINS_END_PACK;
 
    #if TINS_IS_LITTLE_ENDIAN
        TINS_BEGIN_PACK
        struct info_control_field {
            uint16_t
                        type_bit:1,
                        send_seq_num:7,
                        poll_final_bit:1,
                        recv_seq_num:7;
        } TINS_END_PACK;
 
        TINS_BEGIN_PACK
        struct super_control_field {
            uint16_t    type_bit:2,
                        supervisory_func:2,
                        unused:4,
                        poll_final_bit:1,
                        recv_seq_num:7;
        } TINS_END_PACK;
 
        TINS_BEGIN_PACK
        struct un_control_field {
            uint8_t     type_bits:2,
                        mod_func1:2,
                        poll_final_bit:1,
                        mod_func2:3;
        } TINS_END_PACK;
    #elif TINS_IS_BIG_ENDIAN
        TINS_BEGIN_PACK
        struct info_control_field {
            uint16_t    send_seq_num:7,
                        type_bit:1,
                        recv_seq_num:7,
                        poll_final_bit:1;
        } TINS_END_PACK;
 
        TINS_BEGIN_PACK
        struct super_control_field {
            uint16_t    unused:4,
                        supervisory_func:2,
                        type_bit:2,
                        recv_seq_num:7,
                        poll_final_bit:1;
        } TINS_END_PACK;
 
        TINS_BEGIN_PACK
        struct un_control_field {
            uint8_t     mod_func2:3,
                        poll_final_bit:1,
                        mod_func1:2,
                        type_bits:2;
        } TINS_END_PACK;
    #endif
    
    typedef std::vector<uint8_t> field_type;
    typedef std::vector<field_type> field_list;
 
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
    llchdr header_;
    uint8_t control_field_length_;
    union {
        info_control_field info;
        super_control_field super;
        un_control_field unnumbered;
    } control_field;
    Format type_;
    uint8_t information_field_length_;
    field_list information_fields_;
};
 
} // Tins
 
#endif // TINS_IEEE8022_H