shared,platform: add "shared/nm-platform" library

NetworkManager core is huge. We should try to split out
parts that are independent.

Platform code is already mostly independent. But due to having it
under "src/", there is no strict separation/layering which determines
the parts that can work independently. So, while the code is mostly
independent (in practice), that is not obvious from looking at the
source tree. It thus still contributes to cognitive load.

Add a shared library "shared/nm-platform", which should have no
dependencies on libnm-core or NetworkManager core.

In a first step, move the netlink code there. More should follow.

1 files changed, 0 insertions, 616 deletions

diff --git a/src/platform/nm-netlink.h b/src/platform/nm-netlink.h
deleted file mode 100644
index 8de42531d3..0000000000
--- a/src/platform/nm-netlink.h
+++ /dev/null
@@ -1,616 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/*
- * Copyright (C) 2018 Red Hat, Inc.
- */
-
-#ifndef __NM_NETLINK_H__
-#define __NM_NETLINK_H__
-
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-#include <linux/genetlink.h>
-
-#include "nm-std-aux/unaligned.h"
-
-/*****************************************************************************/
-
-#define NLMSGERR_ATTR_UNUSED 0
-#define NLMSGERR_ATTR_MSG    1
-#define NLMSGERR_ATTR_OFFS   2
-#define NLMSGERR_ATTR_COOKIE 3
-#define NLMSGERR_ATTR_MAX    3
-
-#ifndef NLM_F_ACK_TLVS
-    #define NLM_F_ACK_TLVS 0x200
-#endif
-
-/*****************************************************************************/
-
-/* Basic attribute data types */
-enum {
-    NLA_UNSPEC, /* Unspecified type, binary data chunk */
-    NLA_U8,     /* 8 bit integer */
-    NLA_U16,    /* 16 bit integer */
-    NLA_U32,    /* 32 bit integer */
-    NLA_U64,    /* 64 bit integer */
-    NLA_STRING, /* NUL terminated character string */
-    NLA_FLAG,   /* Flag */
-    NLA_MSECS,  /* Micro seconds (64bit) */
-    NLA_NESTED, /* Nested attributes */
-    NLA_NESTED_COMPAT,
-    NLA_NUL_STRING,
-    NLA_BINARY,
-    NLA_S8,
-    NLA_S16,
-    NLA_S32,
-    NLA_S64,
-    __NLA_TYPE_MAX,
-};
-
-#define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
-
-struct nl_msg;
-
-/*****************************************************************************/
-
-const char *nl_nlmsgtype2str(int type, char *buf, size_t size);
-
-const char *nl_nlmsg_flags2str(int flags, char *buf, size_t len);
-
-const char *nl_nlmsghdr_to_str(const struct nlmsghdr *hdr, char *buf, gsize len);
-
-/*****************************************************************************/
-
-struct nla_policy {
-    /* Type of attribute or NLA_UNSPEC */
-    uint16_t type;
-
-    /* Minimal length of payload required */
-    uint16_t minlen;
-
-    /* Maximal length of payload allowed */
-    uint16_t maxlen;
-};
-
-/*****************************************************************************/
-
-/* static asserts that @tb and @policy are suitable arguments to nla_parse(). */
-#define _nl_static_assert_tb(tb, policy)                                                      \
-    G_STMT_START                                                                              \
-    {                                                                                         \
-        G_STATIC_ASSERT_EXPR(G_N_ELEMENTS(tb) > 0);                                           \
-                                                                                              \
-        /* We allow @policy to be either a C array or NULL. The sizeof()
-         * must either match the expected array size or the sizeof(NULL),
-         * but not both. */                      \
-        G_STATIC_ASSERT_EXPR((sizeof(policy) == G_N_ELEMENTS(tb) * sizeof(struct nla_policy)) \
-                             ^ (sizeof(policy) == sizeof(NULL)));                             \
-    }                                                                                         \
-    G_STMT_END
-
-/*****************************************************************************/
-
-static inline int
-nla_attr_size(int payload)
-{
-    nm_assert(payload >= 0);
-
-    return NLA_HDRLEN + payload;
-}
-
-static inline int
-nla_total_size(int payload)
-{
-    return NLA_ALIGN(nla_attr_size(payload));
-}
-
-static inline int
-nla_padlen(int payload)
-{
-    return nla_total_size(payload) - nla_attr_size(payload);
-}
-
-struct nlattr *nla_reserve(struct nl_msg *msg, int attrtype, int attrlen);
-
-static inline int
-nla_len(const struct nlattr *nla)
-{
-    nm_assert(nla);
-    nm_assert(nla->nla_len >= NLA_HDRLEN);
-
-    return ((int) nla->nla_len) - NLA_HDRLEN;
-}
-
-static inline int
-nla_type(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= 0);
-
-    return nla->nla_type & NLA_TYPE_MASK;
-}
-
-static inline void *
-nla_data(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= 0);
-
-    return &(((char *) nla)[NLA_HDRLEN]);
-}
-
-#define nla_data_as(type, nla)                                          \
-    ({                                                                  \
-        const struct nlattr *_nla = (nla);                              \
-                                                                        \
-        nm_assert(nla_len(_nla) >= sizeof(type));                       \
-                                                                        \
-        /* note that casting the pointer is undefined behavior in C, if
-         * the data has wrong alignment. Netlink data is aligned to 4 bytes,
-         * that means, if the alignment is larger than 4, this is invalid. */ \
-        G_STATIC_ASSERT_EXPR(_nm_alignof(type) <= NLA_ALIGNTO);         \
-                                                                        \
-        (type *) nla_data(_nla);                                        \
-    })
-
-static inline uint8_t
-nla_get_u8(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(uint8_t));
-
-    return *((const uint8_t *) nla_data(nla));
-}
-
-static inline int8_t
-nla_get_s8(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(int8_t));
-
-    return *((const int8_t *) nla_data(nla));
-}
-
-static inline uint8_t
-nla_get_u8_cond(/*const*/ struct nlattr *const *tb, int attr, uint8_t default_val)
-{
-    nm_assert(tb);
-    nm_assert(attr >= 0);
-
-    return tb[attr] ? nla_get_u8(tb[attr]) : default_val;
-}
-
-static inline uint16_t
-nla_get_u16(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(uint16_t));
-
-    return *((const uint16_t *) nla_data(nla));
-}
-
-static inline uint32_t
-nla_get_u32(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(uint32_t));
-
-    return *((const uint32_t *) nla_data(nla));
-}
-
-static inline int32_t
-nla_get_s32(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(int32_t));
-
-    return *((const int32_t *) nla_data(nla));
-}
-
-static inline uint64_t
-nla_get_u64(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(uint64_t));
-
-    return unaligned_read_ne64(nla_data(nla));
-}
-
-static inline uint64_t
-nla_get_be64(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= sizeof(uint64_t));
-
-    return unaligned_read_be64(nla_data(nla));
-}
-
-static inline char *
-nla_get_string(const struct nlattr *nla)
-{
-    nm_assert(nla_len(nla) >= 0);
-
-    return (char *) nla_data(nla);
-}
-
-size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
-
-size_t nla_memcpy(void *dst, const struct nlattr *nla, size_t dstsize);
-
-#define nla_memcpy_checked_size(dst, nla, dstsize)                       \
-    G_STMT_START                                                         \
-    {                                                                    \
-        void *const                _dst     = (dst);                     \
-        const struct nlattr *const _nla     = (nla);                     \
-        const size_t               _dstsize = (dstsize);                 \
-        size_t                     _srcsize;                             \
-                                                                         \
-        /* assert that, if @nla is given, that it has the exact expected
-         * size. This implies that the caller previously verified the length
-         * of the attribute (via minlen/maxlen at nla_parse()). */ \
-                                                                         \
-        if (_nla) {                                                      \
-            _srcsize = nla_memcpy(_dst, _nla, _dstsize);                 \
-            nm_assert(_srcsize == _dstsize);                             \
-        }                                                                \
-    }                                                                    \
-    G_STMT_END
-
-int nla_put(struct nl_msg *msg, int attrtype, int datalen, const void *data);
-
-static inline int
-nla_put_string(struct nl_msg *msg, int attrtype, const char *str)
-{
-    nm_assert(str);
-
-    return nla_put(msg, attrtype, strlen(str) + 1, str);
-}
-
-static inline int
-nla_put_uint8(struct nl_msg *msg, int attrtype, uint8_t val)
-{
-    return nla_put(msg, attrtype, sizeof(val), &val);
-}
-
-static inline int
-nla_put_uint16(struct nl_msg *msg, int attrtype, uint16_t val)
-{
-    return nla_put(msg, attrtype, sizeof(val), &val);
-}
-
-static inline int
-nla_put_uint32(struct nl_msg *msg, int attrtype, uint32_t val)
-{
-    return nla_put(msg, attrtype, sizeof(val), &val);
-}
-
-#define NLA_PUT(msg, attrtype, attrlen, data)          \
-    G_STMT_START                                       \
-    {                                                  \
-        if (nla_put(msg, attrtype, attrlen, data) < 0) \
-            goto nla_put_failure;                      \
-    }                                                  \
-    G_STMT_END
-
-#define NLA_PUT_TYPE(msg, type, attrtype, value)          \
-    G_STMT_START                                          \
-    {                                                     \
-        type __nla_tmp = value;                           \
-        NLA_PUT(msg, attrtype, sizeof(type), &__nla_tmp); \
-    }                                                     \
-    G_STMT_END
-
-#define NLA_PUT_U8(msg, attrtype, value) NLA_PUT_TYPE(msg, uint8_t, attrtype, value)
-
-#define NLA_PUT_S8(msg, attrtype, value) NLA_PUT_TYPE(msg, int8_t, attrtype, value)
-
-#define NLA_PUT_U16(msg, attrtype, value) NLA_PUT_TYPE(msg, uint16_t, attrtype, value)
-
-#define NLA_PUT_U32(msg, attrtype, value) NLA_PUT_TYPE(msg, uint32_t, attrtype, value)
-
-#define NLA_PUT_S32(msg, attrtype, value) NLA_PUT_TYPE(msg, int32_t, attrtype, value)
-
-#define NLA_PUT_U64(msg, attrtype, value) NLA_PUT_TYPE(msg, uint64_t, attrtype, value)
-
-#define NLA_PUT_STRING(msg, attrtype, value) NLA_PUT(msg, attrtype, (int) strlen(value) + 1, value)
-
-#define NLA_PUT_FLAG(msg, attrtype) NLA_PUT(msg, attrtype, 0, NULL)
-
-struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
-
-static inline int
-nla_ok(const struct nlattr *nla, int remaining)
-{
-    return remaining >= (int) sizeof(*nla) && nla->nla_len >= sizeof(*nla)
-           && nla->nla_len <= remaining;
-}
-
-static inline struct nlattr *
-nla_next(const struct nlattr *nla, int *remaining)
-{
-    int totlen = NLA_ALIGN(nla->nla_len);
-
-    *remaining -= totlen;
-    return (struct nlattr *) ((char *) nla + totlen);
-}
-
-#define nla_for_each_attr(pos, head, len, rem) \
-    for (pos = head, rem = len; nla_ok(pos, rem); pos = nla_next(pos, &(rem)))
-
-#define nla_for_each_nested(pos, nla, rem)                                            \
-    for (pos = (struct nlattr *) nla_data(nla), rem = nla_len(nla); nla_ok(pos, rem); \
-         pos = nla_next(pos, &(rem)))
-
-void           nla_nest_cancel(struct nl_msg *msg, const struct nlattr *attr);
-struct nlattr *nla_nest_start(struct nl_msg *msg, int attrtype);
-int            nla_nest_end(struct nl_msg *msg, struct nlattr *start);
-
-int nla_parse(struct nlattr *          tb[],
-              int                      maxtype,
-              struct nlattr *          head,
-              int                      len,
-              const struct nla_policy *policy);
-
-#define nla_parse_arr(tb, head, len, policy)                            \
-    ({                                                                  \
-        _nl_static_assert_tb((tb), (policy));                           \
-                                                                        \
-        nla_parse((tb), G_N_ELEMENTS(tb) - 1, (head), (len), (policy)); \
-    })
-
-static inline int
-nla_parse_nested(struct nlattr *          tb[],
-                 int                      maxtype,
-                 struct nlattr *          nla,
-                 const struct nla_policy *policy)
-{
-    return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
-}
-
-#define nla_parse_nested_arr(tb, nla, policy)                          \
-    ({                                                                 \
-        _nl_static_assert_tb((tb), (policy));                          \
-                                                                       \
-        nla_parse_nested((tb), G_N_ELEMENTS(tb) - 1, (nla), (policy)); \
-    })
-
-/*****************************************************************************/
-
-struct nl_msg *nlmsg_alloc(void);
-
-struct nl_msg *nlmsg_alloc_size(size_t max);
-
-struct nl_msg *nlmsg_alloc_convert(struct nlmsghdr *hdr);
-
-struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags);
-
-void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad);
-
-int nlmsg_append(struct nl_msg *n, const void *data, size_t len, int pad);
-
-#define nlmsg_append_struct(n, data) nlmsg_append(n, (data), sizeof(*(data)), NLMSG_ALIGNTO)
-
-void nlmsg_free(struct nl_msg *msg);
-
-static inline int
-nlmsg_size(int payload)
-{
-    nm_assert(payload >= 0 && payload < G_MAXINT - NLMSG_HDRLEN - 4);
-    return NLMSG_HDRLEN + payload;
-}
-
-static inline int
-nlmsg_total_size(int payload)
-{
-    return NLMSG_ALIGN(nlmsg_size(payload));
-}
-
-static inline int
-nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
-{
-    return (remaining >= (int) sizeof(struct nlmsghdr) && nlh->nlmsg_len >= sizeof(struct nlmsghdr)
-            && nlh->nlmsg_len <= remaining);
-}
-
-static inline struct nlmsghdr *
-nlmsg_next(struct nlmsghdr *nlh, int *remaining)
-{
-    int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
-
-    *remaining -= totlen;
-
-    return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
-}
-
-int  nlmsg_get_proto(struct nl_msg *msg);
-void nlmsg_set_proto(struct nl_msg *msg, int protocol);
-
-void nlmsg_set_src(struct nl_msg *msg, struct sockaddr_nl *addr);
-
-struct ucred *nlmsg_get_creds(struct nl_msg *msg);
-void          nlmsg_set_creds(struct nl_msg *msg, struct ucred *creds);
-
-static inline void
-_nm_auto_nl_msg_cleanup(struct nl_msg **ptr)
-{
-    nlmsg_free(*ptr);
-}
-#define nm_auto_nlmsg nm_auto(_nm_auto_nl_msg_cleanup)
-
-static inline void *
-nlmsg_data(const struct nlmsghdr *nlh)
-{
-    return (unsigned char *) nlh + NLMSG_HDRLEN;
-}
-
-static inline void *
-nlmsg_tail(const struct nlmsghdr *nlh)
-{
-    return (unsigned char *) nlh + NLMSG_ALIGN(nlh->nlmsg_len);
-}
-
-struct nlmsghdr *nlmsg_hdr(struct nl_msg *n);
-
-static inline int
-nlmsg_valid_hdr(const struct nlmsghdr *nlh, int hdrlen)
-{
-    if (nlh->nlmsg_len < nlmsg_size(hdrlen))
-        return 0;
-
-    return 1;
-}
-
-static inline int
-nlmsg_datalen(const struct nlmsghdr *nlh)
-{
-    return nlh->nlmsg_len - NLMSG_HDRLEN;
-}
-
-static inline int
-nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
-{
-    return NM_MAX((int) (nlmsg_datalen(nlh) - NLMSG_ALIGN(hdrlen)), 0);
-}
-
-static inline struct nlattr *
-nlmsg_attrdata(const struct nlmsghdr *nlh, int hdrlen)
-{
-    unsigned char *data = nlmsg_data(nlh);
-    return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
-}
-
-static inline struct nlattr *
-nlmsg_find_attr(struct nlmsghdr *nlh, int hdrlen, int attrtype)
-{
-    return nla_find(nlmsg_attrdata(nlh, hdrlen), nlmsg_attrlen(nlh, hdrlen), attrtype);
-}
-
-int nlmsg_parse(struct nlmsghdr *        nlh,
-                int                      hdrlen,
-                struct nlattr *          tb[],
-                int                      maxtype,
-                const struct nla_policy *policy);
-
-#define nlmsg_parse_arr(nlh, hdrlen, tb, policy)                            \
-    ({                                                                      \
-        _nl_static_assert_tb((tb), (policy));                               \
-        G_STATIC_ASSERT_EXPR((hdrlen) >= 0);                                \
-                                                                            \
-        nlmsg_parse((nlh), (hdrlen), (tb), G_N_ELEMENTS(tb) - 1, (policy)); \
-    })
-
-struct nlmsghdr *
-nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq, int type, int payload, int flags);
-
-/*****************************************************************************/
-
-#define NL_AUTO_PORT 0
-#define NL_AUTO_SEQ  0
-
-struct nl_sock;
-
-struct nl_sock *nl_socket_alloc(void);
-
-void nl_socket_free(struct nl_sock *sk);
-
-int nl_socket_get_fd(const struct nl_sock *sk);
-
-struct sockaddr_nl *nlmsg_get_dst(struct nl_msg *msg);
-
-size_t nl_socket_get_msg_buf_size(struct nl_sock *sk);
-int    nl_socket_set_msg_buf_size(struct nl_sock *sk, size_t bufsize);
-
-int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf);
-
-int nl_socket_set_passcred(struct nl_sock *sk, int state);
-
-int nl_socket_set_nonblocking(const struct nl_sock *sk);
-
-void nl_socket_disable_msg_peek(struct nl_sock *sk);
-
-uint32_t nl_socket_get_local_port(const struct nl_sock *sk);
-
-int nl_socket_add_memberships(struct nl_sock *sk, int group, ...);
-
-int nl_connect(struct nl_sock *sk, int protocol);
-
-int nl_recv(struct nl_sock *    sk,
-            struct sockaddr_nl *nla,
-            unsigned char **    buf,
-            struct ucred *      out_creds,
-            gboolean *          out_creds_has);
-
-int nl_send(struct nl_sock *sk, struct nl_msg *msg);
-
-int nl_send_auto(struct nl_sock *sk, struct nl_msg *msg);
-
-/*****************************************************************************/
-
-enum nl_cb_action {
-    /* Proceed with wathever would come next */
-    NL_OK,
-    /* Skip this message */
-    NL_SKIP,
-    /* Stop parsing altogether and discard remaining messages */
-    NL_STOP,
-};
-
-typedef int (*nl_recvmsg_msg_cb_t)(struct nl_msg *msg, void *arg);
-
-typedef int (*nl_recvmsg_err_cb_t)(struct sockaddr_nl *nla, struct nlmsgerr *nlerr, void *arg);
-
-struct nl_cb {
-    nl_recvmsg_msg_cb_t valid_cb;
-    void *              valid_arg;
-
-    nl_recvmsg_msg_cb_t finish_cb;
-    void *              finish_arg;
-
-    nl_recvmsg_msg_cb_t ack_cb;
-    void *              ack_arg;
-
-    nl_recvmsg_err_cb_t err_cb;
-    void *              err_arg;
-};
-
-int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr);
-
-int nl_send_iovec(struct nl_sock *sk, struct nl_msg *msg, struct iovec *iov, unsigned iovlen);
-
-void nl_complete_msg(struct nl_sock *sk, struct nl_msg *msg);
-
-int nl_recvmsgs(struct nl_sock *sk, const struct nl_cb *cb);
-
-int nl_wait_for_ack(struct nl_sock *sk, const struct nl_cb *cb);
-
-int nl_socket_set_ext_ack(struct nl_sock *sk, gboolean enable);
-
-/*****************************************************************************/
-
-void *             genlmsg_put(struct nl_msg *msg,
-                               uint32_t       port,
-                               uint32_t       seq,
-                               int            family,
-                               int            hdrlen,
-                               int            flags,
-                               uint8_t        cmd,
-                               uint8_t        version);
-void *             genlmsg_data(const struct genlmsghdr *gnlh);
-void *             genlmsg_user_hdr(const struct genlmsghdr *gnlh);
-struct genlmsghdr *genlmsg_hdr(struct nlmsghdr *nlh);
-void *             genlmsg_user_data(const struct genlmsghdr *gnlh, const int hdrlen);
-struct nlattr *    genlmsg_attrdata(const struct genlmsghdr *gnlh, int hdrlen);
-int                genlmsg_len(const struct genlmsghdr *gnlh);
-int                genlmsg_attrlen(const struct genlmsghdr *gnlh, int hdrlen);
-int                genlmsg_valid_hdr(struct nlmsghdr *nlh, int hdrlen);
-
-int genlmsg_parse(struct nlmsghdr *        nlh,
-                  int                      hdrlen,
-                  struct nlattr *          tb[],
-                  int                      maxtype,
-                  const struct nla_policy *policy);
-
-#define genlmsg_parse_arr(nlh, hdrlen, tb, policy)                            \
-    ({                                                                        \
-        _nl_static_assert_tb((tb), (policy));                                 \
-        G_STATIC_ASSERT_EXPR((hdrlen) >= 0);                                  \
-                                                                              \
-        genlmsg_parse((nlh), (hdrlen), (tb), G_N_ELEMENTS(tb) - 1, (policy)); \
-    })
-
-int genl_ctrl_resolve(struct nl_sock *sk, const char *name);
-
-/*****************************************************************************/
-
-#endif /* __NM_NETLINK_H__ */