]> git.meshlink.io Git - meshlink/blob - src/netutl.c
Handle EINTR when reading/writing to AIO fds.
[meshlink] / src / netutl.c
1 /*
2     netutl.c -- some supporting network utility code
3     Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License along
16     with this program; if not, write to the Free Software Foundation, Inc.,
17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include "system.h"
21
22 #include "net.h"
23 #include "netutl.h"
24 #include "logger.h"
25 #include "utils.h"
26 #include "xalloc.h"
27
28 /*
29   Turn a string into a struct addrinfo.
30   Return NULL on failure.
31 */
32 struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype) {
33         struct addrinfo *ai;
34         int err;
35
36         struct addrinfo hint = {
37                 .ai_family = AF_UNSPEC,
38                 .ai_socktype = socktype,
39         };
40
41         err = getaddrinfo(address, service, &hint, &ai);
42
43         if(err) {
44                 logger(NULL, MESHLINK_WARNING, "Error looking up %s port %s: %s", address, service, err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
45                 return NULL;
46         }
47
48         return ai;
49 }
50
51 sockaddr_t str2sockaddr(const char *address, const char *port) {
52         struct addrinfo *ai;
53         sockaddr_t result;
54         int err;
55
56         memset(&result, 0, sizeof(result));
57
58         struct addrinfo hint = {
59                 .ai_family = AF_UNSPEC,
60                 .ai_flags = NI_NUMERICHOST | NI_NUMERICSERV,
61                 .ai_socktype = SOCK_STREAM,
62         };
63
64         err = getaddrinfo(address, port, &hint, &ai);
65
66         if(err || !ai) {
67                 logger(NULL, MESHLINK_DEBUG, "Unknown type address %s port %s", address, port);
68                 result.sa.sa_family = AF_UNKNOWN;
69                 result.unknown.address = xstrdup(address);
70                 result.unknown.port = xstrdup(port);
71                 return result;
72         }
73
74         memcpy(&result, ai->ai_addr, ai->ai_addrlen);
75         freeaddrinfo(ai);
76
77         return result;
78 }
79
80 void sockaddr2str(const sockaddr_t *sa, char **addrstr, char **portstr) {
81         char address[NI_MAXHOST];
82         char port[NI_MAXSERV];
83         char *scopeid;
84         int err;
85
86         if(sa->sa.sa_family == AF_UNKNOWN) {
87                 if(addrstr) {
88                         *addrstr = xstrdup(sa->unknown.address);
89                 }
90
91                 if(portstr) {
92                         *portstr = xstrdup(sa->unknown.port);
93                 }
94
95                 return;
96         }
97
98         err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
99
100         if(err) {
101                 logger(NULL, MESHLINK_ERROR, "Error while translating addresses: %s", err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
102                 abort();
103         }
104
105         scopeid = strchr(address, '%');
106
107         if(scopeid) {
108                 *scopeid = '\0';        /* Descope. */
109         }
110
111         if(addrstr) {
112                 *addrstr = xstrdup(address);
113         }
114
115         if(portstr) {
116                 *portstr = xstrdup(port);
117         }
118 }
119
120 char *sockaddr2hostname(const sockaddr_t *sa) {
121         char *str;
122         char address[NI_MAXHOST] = "unknown";
123         char port[NI_MAXSERV] = "unknown";
124         int err;
125
126         if(sa->sa.sa_family == AF_UNKNOWN) {
127                 xasprintf(&str, "%s port %s", sa->unknown.address, sa->unknown.port);
128                 return str;
129         }
130
131         err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
132
133         if(err) {
134                 logger(NULL, MESHLINK_ERROR, "Error while looking up hostname: %s", err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
135                 abort();
136         }
137
138         xasprintf(&str, "%s port %s", address, port);
139
140         return str;
141 }
142
143 int sockaddrcmp_noport(const sockaddr_t *a, const sockaddr_t *b) {
144         int result;
145
146         result = a->sa.sa_family - b->sa.sa_family;
147
148         if(result) {
149                 return result;
150         }
151
152         switch(a->sa.sa_family) {
153         case AF_UNSPEC:
154                 return 0;
155
156         case AF_UNKNOWN:
157                 return strcmp(a->unknown.address, b->unknown.address);
158
159         case AF_INET:
160                 return memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a->in.sin_addr));
161
162         case AF_INET6:
163                 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr));
164
165         default:
166                 logger(NULL, MESHLINK_ERROR, "sockaddrcmp() was called with unknown address family %d, exitting!",
167                        a->sa.sa_family);
168                 abort();
169         }
170 }
171
172 int sockaddrcmp(const sockaddr_t *a, const sockaddr_t *b) {
173         int result;
174
175         result = a->sa.sa_family - b->sa.sa_family;
176
177         if(result) {
178                 return result;
179         }
180
181         switch(a->sa.sa_family) {
182         case AF_UNSPEC:
183                 return 0;
184
185         case AF_UNKNOWN:
186                 result = strcmp(a->unknown.address, b->unknown.address);
187
188                 if(result) {
189                         return result;
190                 }
191
192                 return strcmp(a->unknown.port, b->unknown.port);
193
194         case AF_INET:
195                 result = memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a)->in.sin_addr);
196
197                 if(result) {
198                         return result;
199                 }
200
201                 return memcmp(&a->in.sin_port, &b->in.sin_port, sizeof(a)->in.sin_port);
202
203         case AF_INET6:
204                 result = memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a)->in6.sin6_addr);
205
206                 if(result) {
207                         return result;
208                 }
209
210                 return memcmp(&a->in6.sin6_port, &b->in6.sin6_port, sizeof(a)->in6.sin6_port);
211
212         default:
213                 logger(NULL, MESHLINK_ERROR, "sockaddrcmp() was called with unknown address family %d, exitting!",
214                        a->sa.sa_family);
215                 abort();
216         }
217 }
218
219 void sockaddrcpy(sockaddr_t *a, const sockaddr_t *b) {
220         if(b->sa.sa_family != AF_UNKNOWN) {
221                 *a = *b;
222         } else {
223                 a->unknown.family = AF_UNKNOWN;
224                 a->unknown.address = xstrdup(b->unknown.address);
225                 a->unknown.port = xstrdup(b->unknown.port);
226         }
227 }
228
229 void sockaddrcpy_setport(sockaddr_t *a, const sockaddr_t *b, uint16_t port) {
230         sockaddrcpy(a, b);
231
232         switch(b->sa.sa_family) {
233         case AF_INET:
234                 a->in.sin_port = htons(port);
235                 break;
236
237         case AF_INET6:
238                 a->in6.sin6_port = htons(port);
239                 break;
240
241         default:
242                 break;
243         }
244 }
245
246 void sockaddrfree(sockaddr_t *a) {
247         if(a->sa.sa_family == AF_UNKNOWN) {
248                 free(a->unknown.address);
249                 free(a->unknown.port);
250         }
251 }
252
253 void sockaddrunmap(sockaddr_t *sa) {
254         if(sa->sa.sa_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&sa->in6.sin6_addr)) {
255                 sa->in.sin_addr.s_addr = ((uint32_t *) & sa->in6.sin6_addr)[3];
256                 sa->in.sin_family = AF_INET;
257         }
258 }
259
260 void packmsg_add_sockaddr(packmsg_output_t *out, const sockaddr_t *sa) {
261         switch(sa->sa.sa_family) {
262         case AF_INET: {
263                 uint8_t buf[6];
264                 memcpy(buf + 0, &sa->in.sin_port, 2);
265                 memcpy(buf + 2, &sa->in.sin_addr, 4);
266                 packmsg_add_ext(out, 4, buf, sizeof(buf));
267                 break;
268         }
269
270         case AF_INET6: {
271                 uint8_t buf[18];
272                 memcpy(buf + 0, &sa->in6.sin6_port, 2);
273                 memcpy(buf + 2, &sa->in6.sin6_addr, 16);
274                 packmsg_add_ext(out, 6, buf, sizeof(buf));
275                 break;
276         }
277
278         default:
279                 packmsg_output_invalidate(out);
280                 break;
281         }
282 }
283
284 sockaddr_t packmsg_get_sockaddr(packmsg_input_t *in) {
285         sockaddr_t sa = {0};
286
287         int8_t type;
288         const void *data;
289         uint32_t len = packmsg_get_ext_raw(in, &type, &data);
290
291         switch(type) {
292         case 4:
293                 if(len != 6) {
294                         packmsg_input_invalidate(in);
295                         return sa;
296                 }
297
298                 sa.sa.sa_family = AF_INET;
299                 memcpy(&sa.in.sin_port, (uint8_t *)data + 0, 2);
300                 memcpy(&sa.in.sin_addr, (uint8_t *)data + 2, 4);
301                 break;
302
303         case 6:
304                 if(len != 18) {
305                         packmsg_input_invalidate(in);
306                         return sa;
307                 }
308
309                 sa.sa.sa_family = AF_INET6;
310                 memcpy(&sa.in6.sin6_port, (uint8_t *)data + 0, 2);
311                 memcpy(&sa.in6.sin6_addr, (uint8_t *)data + 2, 16);
312                 break;
313
314         default:
315                 packmsg_input_invalidate(in);
316                 return sa;
317         }
318
319         return sa;
320 }