sock.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_SOCK_H
#define __PTPMGMT_SOCK_H
 
#ifdef __cplusplus
#include "buf.h"
#ifdef __PTPMGMT_HAVE_SYS_UN_H
#include <sys/un.h>
#endif
#ifdef __PTPMGMT_HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef __linux__
#include <linux/if_packet.h>
#endif
#include "cfg.h"
#include "ptp.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
class SockBase
{
  protected:
    int m_fd = -1;
    bool m_isInit = false;
    SockBase() = default;
    bool sendReply(ssize_t cnt, size_t len) const;
    virtual bool sendBase(const void *msg, size_t len) = 0;
    virtual ssize_t rcvBase(void *buf, size_t bufSize, bool block) = 0;
    virtual bool initBase() = 0;
    virtual void closeChild() {}
    void closeBase();
 
  public:
    virtual ~SockBase() { closeBase(); }
    void close() { closeBase(); }
    bool init() { return initBase(); }
    bool send(const void *msg, size_t len)
    { return sendBase(msg, len); }
    bool send(Buf &buf, size_t len)
    { return sendBase(buf.get(), len); }
    bool sendBuf(Buf &buf, size_t len)
    { return sendBase(buf.get(), len); }
    ssize_t rcv(void *buf, size_t bufSize, bool block = false)
    { return rcvBase(buf, bufSize, block); }
    ssize_t rcv(Buf &buf, bool block = false)
    { return rcvBase(buf.get(), buf.size(), block); }
    ssize_t rcvBuf(Buf &buf, bool block = false)
    { return rcvBase(buf.get(), buf.size(), block); }
    int getFd() const { return m_fd; }
    int fileno() const { return m_fd; }
    #ifdef __PTPMGMT_SWIG_THREAD_START
    __PTPMGMT_SWIG_THREAD_START;
    #endif
    bool poll(uint64_t timeout_ms = 0) const;
    bool tpoll(uint64_t &timeout_ms) const; /* poll with timeout update */
    #ifdef __PTPMGMT_SWIG_THREAD_END
    __PTPMGMT_SWIG_THREAD_END;
    #endif
};
 
class SockUnix : public SockBase
{
  private:
    std::string m_me, m_peer, m_homeDir, m_lastFrom;
    sockaddr_un m_peerAddr;
    bool setPeerInternal(const std::string &str, bool useAbstract);
    bool sendAny(const void *msg, size_t len, const sockaddr_un &addr) const;
    static void setUnixAddr(sockaddr_un &addr, const std::string &str);
  protected:
    bool sendBase(const void *msg, size_t len) override final;
    ssize_t rcvBase(void *buf, size_t bufSize, bool block) override final;
    bool initBase() override final;
    void closeChild() override final;
  public:
    SockUnix() { setUnixAddr(m_peerAddr, m_peer); }
    const std::string &getPeerAddress() const { return m_peer; }
    const char *getPeerAddress_c() const { return m_peer.c_str(); }
    bool isPeerAddressAbstract() const { return isAddressAbstract(m_peer); }
    bool setPeerAddress(const std::string &string, bool useAbstract = false) {
        return setPeerInternal(string, useAbstract);
    }
    bool setPeerAddress(const ConfigFile &cfg, const std::string &section = "") {
        return setPeerInternal(cfg.uds_address(section), false);
    }
    const std::string &getSelfAddress() const { return m_me; }
    const char *getSelfAddress_c() const { return m_me.c_str(); }
    bool isSelfAddressAbstract() const { return isAddressAbstract(m_me); }
    bool setSelfAddress(const std::string &string);
    bool setSelfAddress(const std::string &string, bool useAbstract);
    bool setDefSelfAddress(const std::string &rootBase = "",
        const std::string &useDef = "");
    const std::string &getHomeDir();
    const char *getHomeDir_c();
    bool sendTo(const void *msg, size_t len, const std::string &addrStr) const;
    bool sendTo(const void *msg, size_t len, const std::string &addrStr,
        bool useAbstract) const;
    bool sendTo(Buf &buf, size_t len, const std::string &addrStr,
        bool useAbstract = false) const
    { return sendTo(buf.get(), len, addrStr, useAbstract); }
    ssize_t rcvFrom(void *buf, size_t bufSize, std::string &from,
        bool block = false) const;
    ssize_t rcvFrom(Buf &buf, std::string &from, bool block = false) const
    { return rcvFrom(buf.get(), buf.size(), from, block); }
    ssize_t rcvFrom(void *buf, size_t bufSize, bool block = false)
    { return rcvFrom(buf, bufSize, m_lastFrom, block); }
    ssize_t rcvFrom(Buf &buf, bool block = false)
    { return rcvFrom(buf.get(), buf.size(), m_lastFrom, block); }
    ssize_t rcvBufFrom(Buf &buf, bool block = false)
    { return rcvFrom(buf.get(), buf.size(), m_lastFrom, block); }
    const std::string &getLastFrom() const { return m_lastFrom; }
    const char *getLastFrom_c() const { return m_lastFrom.c_str(); }
    bool isLastFromAbstract() const { return isAddressAbstract(m_lastFrom); }
    static bool isAddressAbstract(const std::string &addr) {
        return !addr.empty() && addr[0] == 0;
    }
};
 
class SockBaseIf : public SockBase
{
  protected:
    std::string m_ifName; /* interface to use */
    Binary m_mac;
    int m_ifIndex;
    bool m_have_if = false;
    bool setInt(const IfInfo &ifObj);
    SockBaseIf() = default;
    virtual bool setAllBase(const ConfigFile &cfg, const std::string &section) = 0;
  public:
    bool setIfUsingName(const std::string &ifName);
    bool setIfUsingIndex(int ifIndex);
    bool setIf(const IfInfo &ifObj);
    bool setAll(const IfInfo &ifObj, const ConfigFile &cfg,
        const std::string &section = "") {
        return setIf(ifObj) && setAllBase(cfg, section);
    }
    bool setAllInit(const IfInfo &ifObj, const ConfigFile &cfg,
        const std::string &section = "") {
        return setAll(ifObj, cfg, section) && initBase();
    }
};
 
class SockIp : public SockBaseIf
{
  protected:
    int m_domain, m_udp_ttl = -1;
    /* First for bind then for send */
    sockaddr *m_addr;
    size_t m_addr_len;
    const char *m_mcast_str; /* string form */
    Binary m_mcast;
    SockIp(int domain, const char *mcast, sockaddr *addr, size_t len);
    virtual bool initIp() = 0;
    bool sendBase(const void *msg, size_t len) override final;
    ssize_t rcvBase(void *buf, size_t bufSize, bool block) override final;
    bool initBase() override final;
  public:
    bool setUdpTtl(uint8_t udp_ttl);
    bool setUdpTtl(const ConfigFile &cfg, const std::string &section = "");
};
 
class SockIp4 : public SockIp
{
  private:
    sockaddr_in m_addr4;
 
  protected:
    bool initIp() override final;
    bool setAllBase(const ConfigFile &cfg,
        const std::string &section) override final;
 
  public:
    SockIp4();
};
 
class SockIp6 : public SockIp
{
  private:
    sockaddr_in6 m_addr6;
    int m_udp6_scope = -1;
 
  protected:
    bool initIp() override final;
    bool setAllBase(const ConfigFile &cfg,
        const std::string &section) override final;
 
  public:
    SockIp6();
    bool setScope(uint8_t udp6_scope);
    bool setScope(const ConfigFile &cfg, const std::string &section = "");
};
 
class SockRaw : public SockBaseIf
{
  private:
    Binary m_ptp_dst_mac;
    int m_socket_priority = -1;
    sockaddr_ll m_addr = {0};
    iovec m_iov_tx[2] = {{0}, {0}}, m_iov_rx[2] = {{0}, {0}};
    msghdr m_msg_tx = {0}, m_msg_rx = {0};
    ethhdr m_hdr;
    uint8_t m_rx_buf[sizeof(ethhdr)];
 
  protected:
    bool setAllBase(const ConfigFile &cfg,
        const std::string &section) override final;
    bool sendBase(const void *msg, size_t len) override final;
    ssize_t rcvBase(void *buf, size_t bufSize, bool block) override final;
    bool initBase() override final;
 
  public:
    SockRaw();
    bool setPtpDstMacStr(const std::string &string);
    bool setPtpDstMac(const Binary &ptp_dst_mac);
    bool setPtpDstMac(const void *ptp_dst_mac, size_t len);
    bool setPtpDstMac(const uint8_t *ptp_dst_mac, size_t len);
    bool setPtpDstMac(const ConfigFile &cfg, const std::string &section = "");
    bool setSocketPriority(uint8_t socket_priority);
    bool setSocketPriority(const ConfigFile &cfg, const std::string &section = "");
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/sock.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_SOCK_H */