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