cfg.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-3.0-or-later
   SPDX-FileCopyrightText: Copyright © 2021 Erez Geva <ErezGeva2@gmail.com> */
 
#ifndef __PTPMGMT_CFG_H
#define __PTPMGMT_CFG_H
 
#ifdef __cplusplus
#include <map>
#include "bin.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
class ConfigFile;
class SaFile;
 
#ifndef SWIG
class ConfigSection
{
  protected:
    enum {
        val_base_val,
        transportSpecific_val = val_base_val,
        domainNumber_val,
        udp6_scope_val,
        udp_ttl_val,
        socket_priority_val,
        network_transport_val,
        active_key_id_val,
        spp_val,
        allow_unauth_val,
        str_base_val,
        uds_address_val = str_base_val,
        sa_file_val,
        bin_base_val,
        ptp_dst_mac_val = bin_base_val,
        p2p_dst_mac_val,
        last_val,
    };
    /* new values must be add to ranges[] */
    struct range_t {
        const char *name;
        const char *defStr;
        uint32_t defVal;
        uint32_t min;
        uint32_t max;
    };
    /* ranges and default value */
    static const range_t ranges[];
    /* String values */
    std::string m_str_vals[bin_base_val - str_base_val];
    /* Binaries values */
    Binary m_bin_vals[last_val - bin_base_val];
    /* integer values */
    uint32_t m_vals[str_base_val - val_base_val];
    /* Determine if a value is set in the configuration file.
     * Relevant for non global sections. */
    bool m_set[last_val] = { false };
 
    friend class ConfigFile;
    void setGlobal();
    bool set_val(char *line);
};
#endif /* SWIG */
 
class ConfigFile
{
  private:
    std::map<std::string, ConfigSection> cfgSec;
    ConfigSection *cfgGlobal; /* Not the owner, just a shortcut */
    void clear_sections();
 
    uint32_t get_num(int idx, const std::string &section) const;
    const std::string &get_str(int idx, const std::string &section) const;
    const Binary &get_bin(int idx, const std::string &section) const;
    bool is_global(int idx, const std::string &section) const;
 
  public:
    ConfigFile() { clear_sections(); }
    bool read_cfg(const std::string &file);
    uint8_t transportSpecific(const std::string &section = "") const;
    uint8_t domainNumber(const std::string &section = "") const;
    uint8_t udp6_scope(const std::string &section = "") const;
    uint8_t udp_ttl(const std::string &section = "") const;
    uint8_t socket_priority(const std::string &section = "") const;
    uint8_t network_transport(const std::string &section = "") const;
    uint32_t active_key_id(const std::string &section = "") const;
    uint8_t spp(const std::string &section = "") const;
    uint8_t allow_unauth(const std::string &section = "") const;
    bool haveSpp(const std::string &section = "") const;
    const std::string &uds_address(const std::string &section = "") const;
    const std::string &sa_file(const std::string &section = "") const;
    const Binary &ptp_dst_mac(const std::string &section = "") const;
    const Binary &p2p_dst_mac(const std::string &section = "") const;
};
 
enum HMAC_t {
    HMAC_SHA256, 
    HMAC_AES128,
    HMAC_AES256
};
 
class Spp
{
  private:
    #ifndef SWIG
    struct key_t {
        HMAC_t type = HMAC_SHA256;
        Binary key;
        size_t mac_size = 0;
        void operator()(HMAC_t _t, Binary _k, size_t _m) {
            type = _t;
            key = _k;
            mac_size = _m;
        }
    };
    std::map<uint32_t, key_t> m_keys;
    int8_t m_own_id;
  protected:
    bool set_val(char *line);
    void set(long id) { m_own_id = (uint8_t)id; m_keys.clear(); }
    friend class SaFile;
    #endif
  public:
    bool addKey(uint32_t id, HMAC_t type, Binary &value, size_t digest,
        bool replace = true);
    bool have(uint32_t key) const { return key > 0 && m_keys.count(key) > 0; }
    size_t mac_size(uint32_t key) const;
    const Binary &key(uint32_t key) const;
    size_t keys() const { return m_keys.size(); }
    HMAC_t htype(uint32_t key) const;
    uint8_t ownID() const { return m_own_id; }
    Spp(uint8_t id) : m_own_id(id) {}
    Spp() : m_own_id(-1) {}
};
 
class SaFile
{
  private:
    std::map<uint8_t, Spp> m_spps;
  public:
    bool read_sa(const std::string &file);
    bool read_sa(const ConfigFile &cfg, const std::string &section = "");
    bool have(uint8_t spp) const { return m_spps.count(spp) > 0; }
    bool have(uint8_t spp, uint32_t key) const {
        return have(spp) && m_spps.at(spp).have(key);
    }
    const Spp &spp(uint8_t spp) const;
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/cfg.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_CFG_H */