Mercurial > dovecot > core-2.2
annotate src/lib/network.c @ 404:f25e575bf1ca HEAD
Created datastack_mempool which is used by at least a few temporary
IOBuffers. Some other minor speedups/cleanups in IOBuffer and elsewhere..
author | Timo Sirainen <tss@iki.fi> |
---|---|
date | Thu, 10 Oct 2002 05:01:34 +0300 |
parents | 792fc5b3daa4 |
children | 1f0e7229ee58 |
rev | line source |
---|---|
0 | 1 /* |
2 network.c : Network stuff with IPv6 support | |
3 | |
4 Copyright (c) 1999-2002 Timo Sirainen | |
5 | |
6 Permission is hereby granted, free of charge, to any person obtaining | |
7 a copy of this software and associated documentation files (the | |
8 "Software"), to deal in the Software without restriction, including | |
9 without limitation the rights to use, copy, modify, merge, publish, | |
10 distribute, sublicense, and/or sell copies of the Software, and to | |
11 permit persons to whom the Software is furnished to do so, subject to | |
12 the following conditions: | |
13 | |
14 The above copyright notice and this permission notice shall be | |
15 included in all copies or substantial portions of the Software. | |
16 | |
17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
18 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
20 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | |
21 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | |
22 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |
23 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
24 */ | |
25 | |
26 #include "lib.h" | |
27 #include "network.h" | |
28 | |
29 #include <unistd.h> | |
30 #include <fcntl.h> | |
31 #include <ctype.h> | |
32 #include <sys/un.h> | |
33 #include <netinet/tcp.h> | |
34 | |
35 #define LISTEN_BACKLOG 8 | |
36 | |
37 union sockaddr_union { | |
38 struct sockaddr sa; | |
39 struct sockaddr_in sin; | |
40 #ifdef HAVE_IPV6 | |
41 struct sockaddr_in6 sin6; | |
42 #endif | |
43 }; | |
44 | |
45 #ifdef HAVE_IPV6 | |
46 # define SIZEOF_SOCKADDR(so) ((so).sa.sa_family == AF_INET6 ? \ | |
47 sizeof(so.sin6) : sizeof(so.sin)) | |
48 #else | |
49 # define SIZEOF_SOCKADDR(so) (sizeof(so.sin)) | |
50 #endif | |
51 | |
52 int net_ip_compare(IPADDR *ip1, IPADDR *ip2) | |
53 { | |
54 if (ip1->family != ip2->family) | |
55 return 0; | |
56 | |
57 #ifdef HAVE_IPV6 | |
58 if (ip1->family == AF_INET6) | |
59 return memcmp(&ip1->ip, &ip2->ip, sizeof(ip1->ip)) == 0; | |
60 #endif | |
61 | |
62 return memcmp(&ip1->ip, &ip2->ip, 4) == 0; | |
63 } | |
64 | |
65 | |
66 /* copy IP to sockaddr */ | |
67 static inline void sin_set_ip(union sockaddr_union *so, const IPADDR *ip) | |
68 { | |
69 if (ip == NULL) { | |
70 #ifdef HAVE_IPV6 | |
71 so->sin6.sin6_family = AF_INET6; | |
72 so->sin6.sin6_addr = in6addr_any; | |
73 #else | |
74 so->sin.sin_family = AF_INET; | |
75 so->sin.sin_addr.s_addr = INADDR_ANY; | |
76 #endif | |
77 return; | |
78 } | |
79 | |
80 so->sin.sin_family = ip->family; | |
81 #ifdef HAVE_IPV6 | |
82 if (ip->family == AF_INET6) | |
83 memcpy(&so->sin6.sin6_addr, &ip->ip, sizeof(ip->ip)); | |
84 else | |
85 #endif | |
86 memcpy(&so->sin.sin_addr, &ip->ip, 4); | |
87 } | |
88 | |
89 static inline void sin_get_ip(const union sockaddr_union *so, IPADDR *ip) | |
90 { | |
91 ip->family = so->sin.sin_family; | |
92 | |
93 #ifdef HAVE_IPV6 | |
94 if (ip->family == AF_INET6) | |
95 memcpy(&ip->ip, &so->sin6.sin6_addr, sizeof(ip->ip)); | |
96 else | |
97 #endif | |
98 memcpy(&ip->ip, &so->sin.sin_addr, 4); | |
99 } | |
100 | |
349 | 101 static inline void sin_set_port(union sockaddr_union *so, unsigned int port) |
0 | 102 { |
103 #ifdef HAVE_IPV6 | |
104 if (so->sin.sin_family == AF_INET6) | |
105 so->sin6.sin6_port = htons((unsigned short) port); | |
106 else | |
107 #endif | |
108 so->sin.sin_port = htons((unsigned short) port); | |
109 } | |
110 | |
349 | 111 static inline unsigned int sin_get_port(union sockaddr_union *so) |
0 | 112 { |
113 #ifdef HAVE_IPV6 | |
114 if (so->sin.sin_family == AF_INET6) | |
115 return ntohs(so->sin6.sin6_port); | |
116 #endif | |
117 return ntohs(so->sin.sin_port); | |
118 } | |
119 | |
120 static inline void close_save_errno(int fd) | |
121 { | |
122 int old_errno = errno; | |
123 close(fd); | |
124 errno = old_errno; | |
125 } | |
126 | |
127 /* Connect to socket with ip address */ | |
349 | 128 int net_connect_ip(IPADDR *ip, unsigned int port, IPADDR *my_ip) |
0 | 129 { |
130 union sockaddr_union so; | |
131 int fd, ret, opt = 1; | |
132 | |
133 if (my_ip != NULL && ip->family != my_ip->family) { | |
134 i_warning("net_connect_ip(): ip->family != my_ip->family"); | |
135 my_ip = NULL; | |
136 } | |
137 | |
138 /* create the socket */ | |
139 memset(&so, 0, sizeof(so)); | |
140 so.sin.sin_family = ip->family; | |
141 fd = socket(ip->family, SOCK_STREAM, 0); | |
142 | |
143 if (fd == -1) | |
144 return -1; | |
145 | |
146 /* set socket options */ | |
147 net_set_nonblock(fd, TRUE); | |
148 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); | |
149 setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt)); | |
150 | |
151 /* set our own address */ | |
152 if (my_ip != NULL) { | |
153 sin_set_ip(&so, my_ip); | |
154 if (bind(fd, &so.sa, SIZEOF_SOCKADDR(so)) == -1) { | |
155 /* failed, set it back to INADDR_ANY */ | |
156 sin_set_ip(&so, NULL); | |
157 bind(fd, &so.sa, SIZEOF_SOCKADDR(so)); | |
158 } | |
159 } | |
160 | |
161 /* connect */ | |
162 sin_set_ip(&so, ip); | |
163 sin_set_port(&so, port); | |
164 ret = connect(fd, &so.sa, SIZEOF_SOCKADDR(so)); | |
165 | |
166 #ifndef WIN32 | |
167 if (ret < 0 && errno != EINPROGRESS) | |
168 #else | |
169 if (ret < 0 && WSAGetLastError() != WSAEWOULDBLOCK) | |
170 #endif | |
171 { | |
172 close_save_errno(fd); | |
173 return -1; | |
174 } | |
175 | |
176 return fd; | |
177 } | |
178 | |
179 int net_connect_unix(const char *path) | |
180 { | |
181 struct sockaddr_un sa; | |
182 int fd, ret; | |
183 | |
184 if (strlen(path) > sizeof(sa.sun_path)-1) { | |
185 /* too long path */ | |
186 errno = EINVAL; | |
187 return -1; | |
188 } | |
189 | |
190 /* create the socket */ | |
191 fd = socket(PF_UNIX, SOCK_STREAM, 0); | |
192 if (fd == -1) | |
193 return -1; | |
194 | |
195 /* set socket options */ | |
196 net_set_nonblock(fd, TRUE); | |
197 | |
198 /* connect */ | |
199 memset(&sa, 0, sizeof(sa)); | |
200 sa.sun_family = AF_UNIX; | |
201 strcpy(sa.sun_path, path); | |
202 | |
203 ret = connect(fd, (struct sockaddr *) &sa, sizeof(sa)); | |
204 if (ret < 0 && errno != EINPROGRESS) { | |
205 close_save_errno(fd); | |
206 return -1; | |
207 } | |
208 | |
209 return fd; | |
210 } | |
211 | |
212 /* Disconnect socket */ | |
213 void net_disconnect(int fd) | |
214 { | |
388
792fc5b3daa4
Send error message if close() fails in net_disconnect().
Timo Sirainen <tss@iki.fi>
parents:
349
diff
changeset
|
215 if (close(fd) < 0) |
792fc5b3daa4
Send error message if close() fails in net_disconnect().
Timo Sirainen <tss@iki.fi>
parents:
349
diff
changeset
|
216 i_error("net_disconnect() failed: %m"); |
0 | 217 } |
218 | |
219 /* Set socket blocking/nonblocking */ | |
34
a3d77e73f99b
fixed compile warnings with some systems
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
220 void net_set_nonblock(int fd __attr_unused__, int nonblock __attr_unused__) |
0 | 221 { |
222 #ifdef HAVE_FCNTL | |
223 if (fcntl(fd, F_SETFL, nonblock ? O_NONBLOCK : 0) < 0) | |
224 i_fatal("net_send_nonblock() failed: %m"); | |
225 #endif | |
226 } | |
227 | |
34
a3d77e73f99b
fixed compile warnings with some systems
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
228 void net_set_cork(int fd __attr_unused__, int cork __attr_unused__) |
0 | 229 { |
230 #ifdef TCP_CORK | |
404
f25e575bf1ca
Created datastack_mempool which is used by at least a few temporary
Timo Sirainen <tss@iki.fi>
parents:
388
diff
changeset
|
231 if (setsockopt(fd, SOL_TCP, TCP_CORK, &cork, sizeof(cork)) < 0) |
f25e575bf1ca
Created datastack_mempool which is used by at least a few temporary
Timo Sirainen <tss@iki.fi>
parents:
388
diff
changeset
|
232 i_error("setsockopt(TCP_CORK) failed: %m"); |
0 | 233 #endif |
234 } | |
235 | |
236 /* Listen for connections on a socket. if `my_ip' is NULL, listen in any | |
237 address. */ | |
349 | 238 int net_listen(IPADDR *my_ip, unsigned int *port) |
0 | 239 { |
240 union sockaddr_union so; | |
241 int ret, fd, opt = 1; | |
242 socklen_t len; | |
243 | |
244 i_assert(port != NULL); | |
245 | |
246 memset(&so, 0, sizeof(so)); | |
247 sin_set_port(&so, *port); | |
248 sin_set_ip(&so, my_ip); | |
249 | |
250 /* create the socket */ | |
251 fd = socket(so.sin.sin_family, SOCK_STREAM, 0); | |
252 #ifdef HAVE_IPV6 | |
253 if (fd == -1 && (errno == EINVAL || errno == EAFNOSUPPORT)) { | |
254 /* IPv6 is not supported by OS */ | |
255 so.sin.sin_family = AF_INET; | |
256 so.sin.sin_addr.s_addr = INADDR_ANY; | |
257 | |
258 fd = socket(AF_INET, SOCK_STREAM, 0); | |
259 } | |
260 #endif | |
261 if (fd == -1) | |
262 return -1; | |
263 | |
264 /* set socket options */ | |
265 net_set_nonblock(fd, TRUE); | |
266 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); | |
267 setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt)); | |
268 | |
269 /* specify the address/port we want to listen in */ | |
270 ret = bind(fd, &so.sa, SIZEOF_SOCKADDR(so)); | |
271 if (ret >= 0) { | |
272 /* get the actual port we started listen */ | |
273 len = SIZEOF_SOCKADDR(so); | |
274 ret = getsockname(fd, &so.sa, &len); | |
275 if (ret >= 0) { | |
276 *port = sin_get_port(&so); | |
277 | |
278 /* start listening */ | |
279 if (listen(fd, LISTEN_BACKLOG) >= 0) | |
280 return fd; | |
281 } | |
282 | |
283 } | |
284 | |
285 /* error */ | |
286 close_save_errno(fd); | |
287 return -1; | |
288 } | |
289 | |
290 int net_listen_unix(const char *path) | |
291 { | |
292 struct sockaddr_un sa; | |
293 int fd; | |
294 | |
295 if (strlen(path) > sizeof(sa.sun_path)-1) { | |
296 /* too long path */ | |
297 errno = EINVAL; | |
298 return -1; | |
299 } | |
300 | |
301 /* create the socket */ | |
302 fd = socket(PF_UNIX, SOCK_STREAM, 0); | |
303 if (fd == -1) | |
304 return -1; | |
305 | |
306 /* set socket options */ | |
307 net_set_nonblock(fd, TRUE); | |
308 | |
309 /* bind */ | |
310 memset(&sa, 0, sizeof(sa)); | |
311 sa.sun_family = AF_UNIX; | |
312 strcpy(sa.sun_path, path); | |
313 | |
314 if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) == 0) { | |
315 /* start listening */ | |
316 if (listen(fd, LISTEN_BACKLOG) == 0) | |
317 return fd; | |
318 } | |
319 | |
320 close_save_errno(fd); | |
321 return -1; | |
322 } | |
323 | |
324 /* Accept a connection on a socket */ | |
349 | 325 int net_accept(int fd, IPADDR *addr, unsigned int *port) |
0 | 326 { |
327 union sockaddr_union so; | |
328 int ret; | |
329 socklen_t addrlen; | |
330 | |
331 i_assert(fd >= 0); | |
332 | |
333 addrlen = sizeof(so); | |
334 ret = accept(fd, &so.sa, &addrlen); | |
335 | |
336 if (ret < 0) | |
337 return -1; | |
338 | |
339 if (addr != NULL) sin_get_ip(&so, addr); | |
340 if (port != NULL) *port = sin_get_port(&so); | |
341 | |
159
e0193106a95d
net_accept() set listening socket nonblocking, not the new socket. thanks to
Timo Sirainen <tss@iki.fi>
parents:
64
diff
changeset
|
342 net_set_nonblock(ret, TRUE); |
0 | 343 return ret; |
344 } | |
345 | |
346 /* Read data from socket, return number of bytes read, -1 = error */ | |
183
4a7ab9e94f25
size_t fixes for lib/. Changed OFF_T_FORMAT to PRIuOFF_T which is more
Timo Sirainen <tss@iki.fi>
parents:
159
diff
changeset
|
347 ssize_t net_receive(int fd, void *buf, size_t len) |
0 | 348 { |
183
4a7ab9e94f25
size_t fixes for lib/. Changed OFF_T_FORMAT to PRIuOFF_T which is more
Timo Sirainen <tss@iki.fi>
parents:
159
diff
changeset
|
349 ssize_t ret; |
0 | 350 |
351 i_assert(fd >= 0); | |
352 i_assert(buf != NULL); | |
183
4a7ab9e94f25
size_t fixes for lib/. Changed OFF_T_FORMAT to PRIuOFF_T which is more
Timo Sirainen <tss@iki.fi>
parents:
159
diff
changeset
|
353 i_assert(len <= SSIZE_T_MAX); |
0 | 354 |
355 ret = recv(fd, buf, len, 0); | |
356 if (ret == 0) | |
357 return -1; /* disconnected */ | |
358 | |
359 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) | |
360 return 0; | |
361 | |
362 return ret; | |
363 } | |
364 | |
365 /* Transmit data, return number of bytes sent, -1 = error */ | |
183
4a7ab9e94f25
size_t fixes for lib/. Changed OFF_T_FORMAT to PRIuOFF_T which is more
Timo Sirainen <tss@iki.fi>
parents:
159
diff
changeset
|
366 ssize_t net_transmit(int fd, const void *data, size_t len) |
0 | 367 { |
183
4a7ab9e94f25
size_t fixes for lib/. Changed OFF_T_FORMAT to PRIuOFF_T which is more
Timo Sirainen <tss@iki.fi>
parents:
159
diff
changeset
|
368 ssize_t ret; |
0 | 369 |
370 i_assert(fd >= 0); | |
371 i_assert(data != NULL); | |
183
4a7ab9e94f25
size_t fixes for lib/. Changed OFF_T_FORMAT to PRIuOFF_T which is more
Timo Sirainen <tss@iki.fi>
parents:
159
diff
changeset
|
372 i_assert(len <= SSIZE_T_MAX); |
0 | 373 |
64
83ae914a583a
added t_strdup_noconst() which can be used instead of (char *) t_strdup().
Timo Sirainen <tss@iki.fi>
parents:
34
diff
changeset
|
374 ret = send(fd, data, len, 0); |
0 | 375 if (ret == -1 && (errno == EINTR || errno == EPIPE || errno == EAGAIN)) |
376 return 0; | |
377 | |
378 return ret; | |
379 } | |
380 | |
381 /* Get IP addresses for host. ips contains ips_count of IPs, they don't need | |
382 to be free'd. Returns 0 = ok, others = error code for net_gethosterror() */ | |
383 int net_gethostbyname(const char *addr, IPADDR **ips, int *ips_count) | |
384 { | |
385 #ifdef HAVE_IPV6 | |
386 union sockaddr_union *so; | |
387 struct addrinfo hints, *ai, *origai; | |
388 char hbuf[NI_MAXHOST]; | |
389 int host_error; | |
390 #else | |
391 struct hostent *hp; | |
392 #endif | |
393 int count; | |
394 | |
395 i_assert(addr != NULL); | |
396 i_assert(ips != NULL); | |
397 i_assert(ips_count != NULL); | |
398 | |
399 *ips = NULL; | |
400 *ips_count = 0; | |
401 | |
402 #ifdef HAVE_IPV6 | |
403 memset(&hints, 0, sizeof(struct addrinfo)); | |
404 hints.ai_socktype = SOCK_STREAM; | |
405 | |
406 /* save error to host_error for later use */ | |
407 host_error = getaddrinfo(addr, NULL, &hints, &ai); | |
408 if (host_error != 0) | |
409 return host_error; | |
410 | |
411 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, hbuf, | |
412 sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0) | |
413 return 1; | |
414 | |
415 | |
416 /* get number of IPs */ | |
417 origai = ai; | |
418 for (count = 0; ai != NULL; ai = ai->ai_next) | |
419 count++; | |
420 | |
421 *ips_count = count; | |
422 *ips = t_malloc(sizeof(IPADDR) * count); | |
423 | |
424 count = 0; | |
425 for (ai = origai; ai != NULL; ai = ai->ai_next, count++) { | |
426 so = (union sockaddr_union *) ai->ai_addr; | |
427 | |
428 sin_get_ip(so, ips[count]); | |
429 } | |
430 freeaddrinfo(origai); | |
431 #else | |
432 hp = gethostbyname(addr); | |
433 if (hp == NULL) | |
434 return h_errno; | |
435 | |
436 /* get number of IPs */ | |
437 count = 0; | |
438 while (hp->h_addr_list[count] != NULL) | |
439 count++; | |
440 | |
441 *ips_count = count; | |
442 *ips = t_malloc(sizeof(IPADDR) * count); | |
443 | |
444 while (count > 0) { | |
445 count--; | |
446 | |
447 (*ips)[count].family = AF_INET; | |
448 memcpy(&(*ips)[count].ip, hp->h_addr_list[count], 4); | |
449 } | |
450 #endif | |
451 | |
452 return 0; | |
453 } | |
454 | |
455 /* Get socket address/port */ | |
349 | 456 int net_getsockname(int fd, IPADDR *addr, unsigned int *port) |
0 | 457 { |
458 union sockaddr_union so; | |
459 socklen_t addrlen; | |
460 | |
461 i_assert(fd >= 0); | |
462 | |
463 addrlen = sizeof(so); | |
464 if (getsockname(fd, (struct sockaddr *) &so, &addrlen) == -1) | |
465 return -1; | |
466 | |
467 if (addr != NULL) sin_get_ip(&so, addr); | |
468 if (port != NULL) *port = sin_get_port(&so); | |
469 | |
470 return 0; | |
471 } | |
472 | |
473 int net_ip2host(IPADDR *ip, char *host) | |
474 { | |
475 #ifdef HAVE_IPV6 | |
476 if (!inet_ntop(ip->family, &ip->ip, host, MAX_IP_LEN)) | |
477 return -1; | |
478 #else | |
479 unsigned long ip4; | |
480 | |
481 if (ip->family != AF_INET) { | |
482 strcpy(host, "0.0.0.0"); | |
483 return -1; | |
484 } | |
485 | |
486 ip4 = ntohl(ip->ip.s_addr); | |
487 i_snprintf(host, MAX_IP_LEN, "%lu.%lu.%lu.%lu", | |
488 (ip4 & 0xff000000UL) >> 24, | |
489 (ip4 & 0x00ff0000) >> 16, | |
490 (ip4 & 0x0000ff00) >> 8, | |
491 (ip4 & 0x000000ff)); | |
492 #endif | |
493 return 0; | |
494 } | |
495 | |
496 int net_host2ip(const char *host, IPADDR *ip) | |
497 { | |
498 if (strchr(host, ':') != NULL) { | |
499 /* IPv6 */ | |
500 ip->family = AF_INET6; | |
501 #ifdef HAVE_IPV6 | |
502 if (inet_pton(AF_INET6, host, &ip->ip) == 0) | |
503 return -1; | |
504 #else | |
505 ip->ip.s_addr = 0; | |
506 #endif | |
507 } else { | |
508 /* IPv4 */ | |
509 ip->family = AF_INET; | |
510 if (inet_aton(host, (struct in_addr *) &ip->ip) == 0) | |
511 return -1; | |
512 } | |
513 | |
514 return 0; | |
515 } | |
516 | |
517 /* Get socket error */ | |
518 int net_geterror(int fd) | |
519 { | |
520 int data; | |
521 socklen_t len = sizeof(data); | |
522 | |
523 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &data, &len) == -1) | |
524 return -1; | |
525 | |
526 return data; | |
527 } | |
528 | |
529 /* get error of net_gethostname() */ | |
530 const char *net_gethosterror(int error) | |
531 { | |
532 #ifdef HAVE_IPV6 | |
533 i_assert(error != 0); | |
534 | |
535 if (error == 1) { | |
536 /* getnameinfo() failed */ | |
537 return strerror(errno); | |
538 } | |
539 | |
540 return gai_strerror(error); | |
541 #else | |
542 switch (error) { | |
543 case HOST_NOT_FOUND: | |
544 return "Host not found"; | |
545 case NO_ADDRESS: | |
546 return "No IP address found for name"; | |
547 case NO_RECOVERY: | |
548 return "A non-recovable name server error occurred"; | |
549 case TRY_AGAIN: | |
550 return "A temporary error on an authoritative name server"; | |
551 } | |
552 | |
553 /* unknown error */ | |
554 return NULL; | |
555 #endif | |
556 } | |
557 | |
558 /* return TRUE if host lookup failed because it didn't exist (ie. not | |
559 some error with name server) */ | |
560 int net_hosterror_notfound(int error) | |
561 { | |
562 #ifdef HAVE_IPV6 | |
563 return error != 1 && (error == EAI_NONAME || error == EAI_NODATA); | |
564 #else | |
565 return error == HOST_NOT_FOUND || error == NO_ADDRESS; | |
566 #endif | |
567 } | |
568 | |
569 /* Get name of TCP service */ | |
349 | 570 char *net_getservbyport(unsigned short port) |
0 | 571 { |
572 struct servent *entry; | |
573 | |
349 | 574 entry = getservbyport(htons(port), "tcp"); |
0 | 575 return entry == NULL ? NULL : entry->s_name; |
576 } | |
577 | |
578 int is_ipv4_address(const char *host) | |
579 { | |
580 while (*host != '\0') { | |
581 if (*host != '.' && !i_isdigit(*host)) | |
582 return 0; | |
583 host++; | |
584 } | |
585 | |
586 return 1; | |
587 } | |
588 | |
589 int is_ipv6_address(const char *host) | |
590 { | |
591 while (*host != '\0') { | |
592 if (*host != ':' && !i_isxdigit(*host)) | |
593 return 0; | |
594 host++; | |
595 } | |
596 | |
597 return 1; | |
598 } |