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 void *unet_read_file(const char *name, size_t *len);
  63
  64 #define DIV_ROUND_UP(n, d)      (((n) + (d) - 1) / (d))
  65
  66 #define bitmask_size(len)       (4 * DIV_ROUND_UP(len, 32))
  67
  68 static inline bool bitmask_test(uint32_t *mask, unsigned int i)
  69 {
  70         return mask[i / 32] & (1 << (i % 32));
  71 }
  72
  73 static inline void bitmask_set(uint32_t *mask, unsigned int i)
  74 {
  75         mask[i / 32] |= 1 << (i % 32);
  76 }
  77
  78 static inline void bitmask_clear(uint32_t *mask, unsigned int i)
  79 {
  80         mask[i / 32] &= ~(1 << (i % 32));
  81 }
  82
  83 static inline void bitmask_set_val(uint32_t *mask, unsigned int i, bool val)
  84 {
  85         if (val)
  86                 bitmask_set(mask, i);
  87         else
  88                 bitmask_clear(mask, i);
  89 }
  90
  91 static inline uint16_t get_unaligned_be16(const uint8_t *p)
  92 {
  93         return p[1] | p[0] << 8;
  94 }
  95
  96 static inline uint32_t get_unaligned_be32(const uint8_t *p)
  97 {
  98         return p[3] | p[2] << 8 | p[1] << 16 | p[0] << 24;
  99 }
 100
 101 static inline uint64_t get_unaligned_be64(const uint8_t *p)
 102 {
 103         return (uint64_t)get_unaligned_be32(p) << 32 |
 104                get_unaligned_be32(p + 4);
 105 }
 106
 107 static inline uint16_t get_unaligned_le16(const uint8_t *p)
 108 {
 109         return p[0] | p[1] << 8;
 110 }
 111
 112 static inline uint32_t get_unaligned_le32(const uint8_t *p)
 113 {
 114         return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
 115 }
 116
 117 static inline uint64_t get_unaligned_le64(const uint8_t *p)
 118 {
 119         return (uint64_t)get_unaligned_le32(p + 4) << 32 |
 120                get_unaligned_le32(p);
 121 }
 122
 123 int rtnl_init(void);
 124 int rtnl_call(struct nl_msg *msg);
 125
 126 #endif