utils.h

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2022 Felix Fietkau <nbd@nbd.name>
   4  */
   5 #ifndef __UNETD_UTILS_H
   6 #define __UNETD_UTILS_H
   7
   8 #include <string.h>
   9 #include <netinet/in.h>
  10 #include <libubox/utils.h>
  11
  12 struct nl_msg;
  13
  14 union network_addr {
  15         struct {
  16                 uint8_t network_id[8];
  17                 uint8_t host_addr[8];
  18         };
  19         struct in_addr in;
  20         struct in6_addr in6;
  21 };
  22
  23 union network_endpoint {
  24         struct sockaddr sa;
  25         struct sockaddr_in in;
  26         struct sockaddr_in6 in6;
  27 };
  28
  29 static inline void *
  30 network_endpoint_addr(union network_endpoint *ep, int *addr_len)
  31 {
  32         if (ep->sa.sa_family == AF_INET6) {
  33                 *addr_len = sizeof(ep->in6.sin6_addr);
  34                 return &ep->in6.sin6_addr;
  35         }
  36
  37         *addr_len = sizeof(ep->in.sin_addr);
  38         return &ep->in.sin_addr;
  39 }
  40
  41 static inline bool
  42 network_endpoint_addr_equal(union network_endpoint *ep1, union network_endpoint *ep2)
  43 {
  44         const void *a1, *a2;
  45         int len;
  46
  47         if (ep1->sa.sa_family != ep2->sa.sa_family)
  48                 return false;
  49
  50         a1 = network_endpoint_addr(ep1, &len);
  51         a2 = network_endpoint_addr(ep2, &len);
  52
  53         return !memcmp(a1, a2, len);
  54 }
  55
  56 int network_get_endpoint(union network_endpoint *dest, const char *str,
  57                          int default_port, int idx);
  58 int network_get_subnet(int af, union network_addr *addr, int *mask,
  59                        const char *str);
  60 int network_get_local_addr(void *local, const union network_endpoint *target);
  61
  62 #define DIV_ROUND_UP(n, d)      (((n) + (d) - 1) / (d))
  63
  64 #define bitmask_size(len)       (4 * DIV_ROUND_UP(len, 32))
  65
  66 static inline bool bitmask_test(uint32_t *mask, unsigned int i)
  67 {
  68         return mask[i / 32] & (1 << (i % 32));
  69 }
  70
  71 static inline void bitmask_set(uint32_t *mask, unsigned int i)
  72 {
  73         mask[i / 32] |= 1 << (i % 32);
  74 }
  75
  76 static inline void bitmask_clear(uint32_t *mask, unsigned int i)
  77 {
  78         mask[i / 32] &= ~(1 << (i % 32));
  79 }
  80
  81 static inline void bitmask_set_val(uint32_t *mask, unsigned int i, bool val)
  82 {
  83         if (val)
  84                 bitmask_set(mask, i);
  85         else
  86                 bitmask_clear(mask, i);
  87 }
  88
  89 static inline uint16_t get_unaligned_be16(const uint8_t *p)
  90 {
  91         return p[1] | p[0] << 8;
  92 }
  93
  94 static inline uint32_t get_unaligned_be32(const uint8_t *p)
  95 {
  96         return p[3] | p[2] << 8 | p[1] << 16 | p[0] << 24;
  97 }
  98
  99 static inline uint64_t get_unaligned_be64(const uint8_t *p)
 100 {
 101         return (uint64_t)get_unaligned_be32(p) << 32 |
 102                get_unaligned_be32(p + 4);
 103 }
 104
 105 static inline uint16_t get_unaligned_le16(const uint8_t *p)
 106 {
 107         return p[0] | p[1] << 8;
 108 }
 109
 110 static inline uint32_t get_unaligned_le32(const uint8_t *p)
 111 {
 112         return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
 113 }
 114
 115 static inline uint64_t get_unaligned_le64(const uint8_t *p)
 116 {
 117         return (uint64_t)get_unaligned_le32(p + 4) << 32 |
 118                get_unaligned_le32(p);
 119 }
 120
 121 int rtnl_init(void);
 122 int rtnl_call(struct nl_msg *msg);
 123
 124 #endif