src/basic/socket-util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2010 Lennart Poettering
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <netinet/ether.h>
  24 #include <netinet/in.h>
  25 #include <stdbool.h>
  26 #include <stddef.h>
  27 #include <sys/socket.h>
  28 #include <sys/types.h>
  29 #include <sys/un.h>
  30 #include <linux/netlink.h>
  31 #include <linux/if_infiniband.h>
  32 #include <linux/if_packet.h>
  33
  34 #include "macro.h"
  35 #include "missing.h"
  36 #include "util.h"
  37
  38 union sockaddr_union {
  39         /* The minimal, abstract version */
  40         struct sockaddr sa;
  41
  42         /* The libc provided version that allocates "enough room" for every protocol */
  43         struct sockaddr_storage storage;
  44
  45         /* Protoctol-specific implementations */
  46         struct sockaddr_in in;
  47         struct sockaddr_in6 in6;
  48         struct sockaddr_un un;
  49         struct sockaddr_nl nl;
  50         struct sockaddr_ll ll;
  51         struct sockaddr_vm vm;
  52
  53         /* Ensure there is enough space to store Infiniband addresses */
  54         uint8_t ll_buffer[offsetof(struct sockaddr_ll, sll_addr) + CONST_MAX(ETH_ALEN, INFINIBAND_ALEN)];
  55
  56         /* Ensure there is enough space after the AF_UNIX sun_path for one more NUL byte, just to be sure that the path
  57          * component is always followed by at least one NUL byte. */
  58         uint8_t un_buffer[sizeof(struct sockaddr_un) + 1];
  59 };
  60
  61 typedef struct SocketAddress {
  62         union sockaddr_union sockaddr;
  63
  64         /* We store the size here explicitly due to the weird
  65          * sockaddr_un semantics for abstract sockets */
  66         socklen_t size;
  67
  68         /* Socket type, i.e. SOCK_STREAM, SOCK_DGRAM, ... */
  69         int type;
  70
  71         /* Socket protocol, IPPROTO_xxx, usually 0, except for netlink */
  72         int protocol;
  73 } SocketAddress;
  74
  75 typedef enum SocketAddressBindIPv6Only {
  76         SOCKET_ADDRESS_DEFAULT,
  77         SOCKET_ADDRESS_BOTH,
  78         SOCKET_ADDRESS_IPV6_ONLY,
  79         _SOCKET_ADDRESS_BIND_IPV6_ONLY_MAX,
  80         _SOCKET_ADDRESS_BIND_IPV6_ONLY_INVALID = -1
  81 } SocketAddressBindIPv6Only;
  82
  83 #define socket_address_family(a) ((a)->sockaddr.sa.sa_family)
  84
  85 const char* socket_address_type_to_string(int t) _const_;
  86 int socket_address_type_from_string(const char *s) _pure_;
  87
  88 int socket_address_parse(SocketAddress *a, const char *s);
  89 int socket_address_parse_and_warn(SocketAddress *a, const char *s);
  90 int socket_address_parse_netlink(SocketAddress *a, const char *s);
  91 int socket_address_print(const SocketAddress *a, char **p);
  92 int socket_address_verify(const SocketAddress *a) _pure_;
  93 int socket_address_unlink(SocketAddress *a);
  94
  95 bool socket_address_can_accept(const SocketAddress *a) _pure_;
  96
  97 int socket_address_listen(
  98                 const SocketAddress *a,
  99                 int flags,
 100                 int backlog,
 101                 SocketAddressBindIPv6Only only,
 102                 const char *bind_to_device,
 103                 bool reuse_port,
 104                 bool free_bind,
 105                 bool transparent,
 106                 mode_t directory_mode,
 107                 mode_t socket_mode,
 108                 const char *label);
 109 int make_socket_fd(int log_level, const char* address, int type, int flags);
 110
 111 bool socket_address_is(const SocketAddress *a, const char *s, int type);
 112 bool socket_address_is_netlink(const SocketAddress *a, const char *s);
 113
 114 bool socket_address_matches_fd(const SocketAddress *a, int fd);
 115
 116 bool socket_address_equal(const SocketAddress *a, const SocketAddress *b) _pure_;
 117
 118 const char* socket_address_get_path(const SocketAddress *a);
 119
 120 bool socket_ipv6_is_supported(void);
 121
 122 int sockaddr_port(const struct sockaddr *_sa, unsigned *port);
 123
 124 int sockaddr_pretty(const struct sockaddr *_sa, socklen_t salen, bool translate_ipv6, bool include_port, char **ret);
 125 int getpeername_pretty(int fd, bool include_port, char **ret);
 126 int getsockname_pretty(int fd, char **ret);
 127
 128 int socknameinfo_pretty(union sockaddr_union *sa, socklen_t salen, char **_ret);
 129 int getnameinfo_pretty(int fd, char **ret);
 130
 131 const char* socket_address_bind_ipv6_only_to_string(SocketAddressBindIPv6Only b) _const_;
 132 SocketAddressBindIPv6Only socket_address_bind_ipv6_only_from_string(const char *s) _pure_;
 133 SocketAddressBindIPv6Only parse_socket_address_bind_ipv6_only_or_bool(const char *s);
 134
 135 int netlink_family_to_string_alloc(int b, char **s);
 136 int netlink_family_from_string(const char *s) _pure_;
 137
 138 bool sockaddr_equal(const union sockaddr_union *a, const union sockaddr_union *b);
 139
 140 int fd_inc_sndbuf(int fd, size_t n);
 141 int fd_inc_rcvbuf(int fd, size_t n);
 142
 143 int ip_tos_to_string_alloc(int i, char **s);
 144 int ip_tos_from_string(const char *s);
 145
 146 bool ifname_valid(const char *p);
 147 bool address_label_valid(const char *p);
 148
 149 int getpeercred(int fd, struct ucred *ucred);
 150 int getpeersec(int fd, char **ret);
 151 int getpeergroups(int fd, gid_t **ret);
 152
 153 int send_one_fd_sa(int transport_fd,
 154                    int fd,
 155                    const struct sockaddr *sa, socklen_t len,
 156                    int flags);
 157 #define send_one_fd(transport_fd, fd, flags) send_one_fd_sa(transport_fd, fd, NULL, 0, flags)
 158 int receive_one_fd(int transport_fd, int flags);
 159
 160 ssize_t next_datagram_size_fd(int fd);
 161
 162 int flush_accept(int fd);
 163
 164 #define CMSG_FOREACH(cmsg, mh)                                          \
 165         for ((cmsg) = CMSG_FIRSTHDR(mh); (cmsg); (cmsg) = CMSG_NXTHDR((mh), (cmsg)))
 166
 167 struct cmsghdr* cmsg_find(struct msghdr *mh, int level, int type, socklen_t length);
 168
 169 /*
 170  * Certain hardware address types (e.g Infiniband) do not fit into sll_addr
 171  * (8 bytes) and run over the structure. This macro returns the correct size that
 172  * must be passed to kernel.
 173  */
 174 #define SOCKADDR_LL_LEN(sa)                                             \
 175         ({                                                              \
 176                 const struct sockaddr_ll *_sa = &(sa);                  \
 177                 size_t _mac_len = sizeof(_sa->sll_addr);                \
 178                 assert(_sa->sll_family == AF_PACKET);                   \
 179                 if (be16toh(_sa->sll_hatype) == ARPHRD_ETHER)           \
 180                         _mac_len = MAX(_mac_len, (size_t) ETH_ALEN);    \
 181                 if (be16toh(_sa->sll_hatype) == ARPHRD_INFINIBAND)      \
 182                         _mac_len = MAX(_mac_len, (size_t) INFINIBAND_ALEN); \
 183                 offsetof(struct sockaddr_ll, sll_addr) + _mac_len;      \
 184         })
 185
 186 /* Covers only file system and abstract AF_UNIX socket addresses, but not unnamed socket addresses. */
 187 #define SOCKADDR_UN_LEN(sa)                                             \
 188         ({                                                              \
 189                 const struct sockaddr_un *_sa = &(sa);                  \
 190                 assert(_sa->sun_family == AF_UNIX);                     \
 191                 offsetof(struct sockaddr_un, sun_path) +                \
 192                         (_sa->sun_path[0] == 0 ?                        \
 193                          1 + strnlen(_sa->sun_path+1, sizeof(_sa->sun_path)-1) : \
 194                          strnlen(_sa->sun_path, sizeof(_sa->sun_path))); \
 195         })
 196
 197 int socket_ioctl_fd(void);