Mercurial > dovecot > core-2.2
annotate src/lib/network.c @ 780:1cc947617c8b HEAD
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
"::" as "all IPv6 interfaces, plus all IPv4 interfaces if supported by OS".
Added a few consts to network API and added functions to get inaddr_any for
ipv4/ipv6.
| author | Timo Sirainen <tss@iki.fi> |
|---|---|
| date | Thu, 12 Dec 2002 20:33:32 +0200 |
| parents | 84e398270f7f |
| children | 9cb7022749e7 |
| 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 | |
|
780
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
52 int net_ip_compare(const IPADDR *ip1, const IPADDR *ip2) |
| 0 | 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 */ | |
|
780
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
128 int net_connect_ip(const IPADDR *ip, unsigned int port, const 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) | |
| 628 | 224 i_fatal("net_set_nonblock() failed: %m"); |
| 0 | 225 #endif |
| 226 } | |
| 227 | |
|
410
1f0e7229ee58
Split IOBuffer into mmaped IBuffer, file IBuffer, memory data IBuffer and
Timo Sirainen <tss@iki.fi>
parents:
404
diff
changeset
|
228 int net_set_cork(int fd __attr_unused__, int cork __attr_unused__) |
| 0 | 229 { |
| 230 #ifdef TCP_CORK | |
|
410
1f0e7229ee58
Split IOBuffer into mmaped IBuffer, file IBuffer, memory data IBuffer and
Timo Sirainen <tss@iki.fi>
parents:
404
diff
changeset
|
231 return setsockopt(fd, SOL_TCP, TCP_CORK, &cork, sizeof(cork)); |
|
1f0e7229ee58
Split IOBuffer into mmaped IBuffer, file IBuffer, memory data IBuffer and
Timo Sirainen <tss@iki.fi>
parents:
404
diff
changeset
|
232 #else |
|
1f0e7229ee58
Split IOBuffer into mmaped IBuffer, file IBuffer, memory data IBuffer and
Timo Sirainen <tss@iki.fi>
parents:
404
diff
changeset
|
233 errno = ENOPROTOOPT; |
|
1f0e7229ee58
Split IOBuffer into mmaped IBuffer, file IBuffer, memory data IBuffer and
Timo Sirainen <tss@iki.fi>
parents:
404
diff
changeset
|
234 return -1; |
| 0 | 235 #endif |
| 236 } | |
| 237 | |
|
780
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
238 void net_get_ip_any4(IPADDR *ip) |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
239 { |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
240 struct in_addr *in_ip = (struct in_addr *) &ip->ip; |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
241 |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
242 ip->family = AF_INET; |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
243 in_ip->s_addr = INADDR_ANY; |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
244 } |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
245 |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
246 void net_get_ip_any6(IPADDR *ip) |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
247 { |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
248 #ifdef HAVE_IPV6 |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
249 ip->family = AF_INET6; |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
250 ip->ip = in6addr_any; |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
251 #else |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
252 memset(ip, 0, sizeof(IPADDR)); |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
253 #endif |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
254 } |
|
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
255 |
| 0 | 256 /* Listen for connections on a socket. if `my_ip' is NULL, listen in any |
| 257 address. */ | |
|
780
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
258 int net_listen(const IPADDR *my_ip, unsigned int *port) |
| 0 | 259 { |
| 260 union sockaddr_union so; | |
| 261 int ret, fd, opt = 1; | |
| 262 socklen_t len; | |
| 263 | |
| 264 i_assert(port != NULL); | |
| 265 | |
| 266 memset(&so, 0, sizeof(so)); | |
| 267 sin_set_port(&so, *port); | |
| 268 sin_set_ip(&so, my_ip); | |
| 269 | |
| 270 /* create the socket */ | |
| 271 fd = socket(so.sin.sin_family, SOCK_STREAM, 0); | |
| 272 #ifdef HAVE_IPV6 | |
| 273 if (fd == -1 && (errno == EINVAL || errno == EAFNOSUPPORT)) { | |
| 274 /* IPv6 is not supported by OS */ | |
| 275 so.sin.sin_family = AF_INET; | |
| 276 so.sin.sin_addr.s_addr = INADDR_ANY; | |
| 277 | |
| 278 fd = socket(AF_INET, SOCK_STREAM, 0); | |
| 279 } | |
| 280 #endif | |
| 281 if (fd == -1) | |
| 282 return -1; | |
| 283 | |
| 284 /* set socket options */ | |
| 285 net_set_nonblock(fd, TRUE); | |
| 286 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); | |
| 287 setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt)); | |
| 288 | |
| 289 /* specify the address/port we want to listen in */ | |
| 290 ret = bind(fd, &so.sa, SIZEOF_SOCKADDR(so)); | |
| 291 if (ret >= 0) { | |
| 292 /* get the actual port we started listen */ | |
| 293 len = SIZEOF_SOCKADDR(so); | |
| 294 ret = getsockname(fd, &so.sa, &len); | |
| 295 if (ret >= 0) { | |
| 296 *port = sin_get_port(&so); | |
| 297 | |
| 298 /* start listening */ | |
| 299 if (listen(fd, LISTEN_BACKLOG) >= 0) | |
| 300 return fd; | |
| 301 } | |
| 302 | |
| 303 } | |
| 304 | |
| 305 /* error */ | |
| 306 close_save_errno(fd); | |
| 307 return -1; | |
| 308 } | |
| 309 | |
| 310 int net_listen_unix(const char *path) | |
| 311 { | |
| 312 struct sockaddr_un sa; | |
| 313 int fd; | |
| 314 | |
| 315 if (strlen(path) > sizeof(sa.sun_path)-1) { | |
| 316 /* too long path */ | |
| 317 errno = EINVAL; | |
| 318 return -1; | |
| 319 } | |
| 320 | |
| 321 /* create the socket */ | |
| 322 fd = socket(PF_UNIX, SOCK_STREAM, 0); | |
| 323 if (fd == -1) | |
| 324 return -1; | |
| 325 | |
| 326 /* set socket options */ | |
| 327 net_set_nonblock(fd, TRUE); | |
| 328 | |
| 329 /* bind */ | |
| 330 memset(&sa, 0, sizeof(sa)); | |
| 331 sa.sun_family = AF_UNIX; | |
| 332 strcpy(sa.sun_path, path); | |
| 333 | |
| 334 if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) == 0) { | |
| 335 /* start listening */ | |
| 336 if (listen(fd, LISTEN_BACKLOG) == 0) | |
| 337 return fd; | |
| 338 } | |
| 339 | |
| 340 close_save_errno(fd); | |
| 341 return -1; | |
| 342 } | |
| 343 | |
| 344 /* Accept a connection on a socket */ | |
| 349 | 345 int net_accept(int fd, IPADDR *addr, unsigned int *port) |
| 0 | 346 { |
| 347 union sockaddr_union so; | |
| 348 int ret; | |
| 349 socklen_t addrlen; | |
| 350 | |
| 351 i_assert(fd >= 0); | |
| 352 | |
| 353 addrlen = sizeof(so); | |
| 354 ret = accept(fd, &so.sa, &addrlen); | |
| 355 | |
|
680
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
356 if (ret < 0) { |
|
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
357 if (errno == EBADF || errno == ENOTSOCK || |
|
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
358 errno == EOPNOTSUPP || errno == EFAULT || errno == EINVAL) |
|
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
359 return -2; |
|
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
360 else |
|
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
361 return -1; |
|
84e398270f7f
net_accept() returns now -2 for fatal failures.
Timo Sirainen <tss@iki.fi>
parents:
628
diff
changeset
|
362 } |
| 0 | 363 |
| 364 if (addr != NULL) sin_get_ip(&so, addr); | |
| 365 if (port != NULL) *port = sin_get_port(&so); | |
| 366 | |
|
159
e0193106a95d
net_accept() set listening socket nonblocking, not the new socket. thanks to
Timo Sirainen <tss@iki.fi>
parents:
64
diff
changeset
|
367 net_set_nonblock(ret, TRUE); |
| 0 | 368 return ret; |
| 369 } | |
| 370 | |
| 371 /* 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
|
372 ssize_t net_receive(int fd, void *buf, size_t len) |
| 0 | 373 { |
|
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
|
374 ssize_t ret; |
| 0 | 375 |
| 376 i_assert(fd >= 0); | |
| 377 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
|
378 i_assert(len <= SSIZE_T_MAX); |
| 0 | 379 |
| 380 ret = recv(fd, buf, len, 0); | |
| 381 if (ret == 0) | |
| 382 return -1; /* disconnected */ | |
| 383 | |
| 384 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) | |
| 385 return 0; | |
| 386 | |
| 387 return ret; | |
| 388 } | |
| 389 | |
| 390 /* 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
|
391 ssize_t net_transmit(int fd, const void *data, size_t len) |
| 0 | 392 { |
|
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
|
393 ssize_t ret; |
| 0 | 394 |
| 395 i_assert(fd >= 0); | |
| 396 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
|
397 i_assert(len <= SSIZE_T_MAX); |
| 0 | 398 |
|
64
83ae914a583a
added t_strdup_noconst() which can be used instead of (char *) t_strdup().
Timo Sirainen <tss@iki.fi>
parents:
34
diff
changeset
|
399 ret = send(fd, data, len, 0); |
| 0 | 400 if (ret == -1 && (errno == EINTR || errno == EPIPE || errno == EAGAIN)) |
| 401 return 0; | |
| 402 | |
| 403 return ret; | |
| 404 } | |
| 405 | |
| 406 /* Get IP addresses for host. ips contains ips_count of IPs, they don't need | |
| 407 to be free'd. Returns 0 = ok, others = error code for net_gethosterror() */ | |
| 408 int net_gethostbyname(const char *addr, IPADDR **ips, int *ips_count) | |
| 409 { | |
| 410 #ifdef HAVE_IPV6 | |
| 411 union sockaddr_union *so; | |
| 412 struct addrinfo hints, *ai, *origai; | |
| 413 char hbuf[NI_MAXHOST]; | |
| 414 int host_error; | |
| 415 #else | |
| 416 struct hostent *hp; | |
| 417 #endif | |
| 418 int count; | |
| 419 | |
| 420 i_assert(addr != NULL); | |
| 421 i_assert(ips != NULL); | |
| 422 i_assert(ips_count != NULL); | |
| 423 | |
| 424 *ips = NULL; | |
| 425 *ips_count = 0; | |
| 426 | |
| 427 #ifdef HAVE_IPV6 | |
| 428 memset(&hints, 0, sizeof(struct addrinfo)); | |
| 429 hints.ai_socktype = SOCK_STREAM; | |
| 430 | |
| 431 /* save error to host_error for later use */ | |
| 432 host_error = getaddrinfo(addr, NULL, &hints, &ai); | |
| 433 if (host_error != 0) | |
| 434 return host_error; | |
| 435 | |
| 436 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, hbuf, | |
| 437 sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0) | |
| 438 return 1; | |
| 439 | |
| 440 | |
| 441 /* get number of IPs */ | |
| 442 origai = ai; | |
| 443 for (count = 0; ai != NULL; ai = ai->ai_next) | |
| 444 count++; | |
| 445 | |
| 446 *ips_count = count; | |
| 447 *ips = t_malloc(sizeof(IPADDR) * count); | |
| 448 | |
| 449 count = 0; | |
| 450 for (ai = origai; ai != NULL; ai = ai->ai_next, count++) { | |
| 451 so = (union sockaddr_union *) ai->ai_addr; | |
| 452 | |
| 453 sin_get_ip(so, ips[count]); | |
| 454 } | |
| 455 freeaddrinfo(origai); | |
| 456 #else | |
| 457 hp = gethostbyname(addr); | |
| 458 if (hp == NULL) | |
| 459 return h_errno; | |
| 460 | |
| 461 /* get number of IPs */ | |
| 462 count = 0; | |
| 463 while (hp->h_addr_list[count] != NULL) | |
| 464 count++; | |
| 465 | |
| 466 *ips_count = count; | |
| 467 *ips = t_malloc(sizeof(IPADDR) * count); | |
| 468 | |
| 469 while (count > 0) { | |
| 470 count--; | |
| 471 | |
| 472 (*ips)[count].family = AF_INET; | |
| 473 memcpy(&(*ips)[count].ip, hp->h_addr_list[count], 4); | |
| 474 } | |
| 475 #endif | |
| 476 | |
| 477 return 0; | |
| 478 } | |
| 479 | |
| 480 /* Get socket address/port */ | |
| 349 | 481 int net_getsockname(int fd, IPADDR *addr, unsigned int *port) |
| 0 | 482 { |
| 483 union sockaddr_union so; | |
| 484 socklen_t addrlen; | |
| 485 | |
| 486 i_assert(fd >= 0); | |
| 487 | |
| 488 addrlen = sizeof(so); | |
| 489 if (getsockname(fd, (struct sockaddr *) &so, &addrlen) == -1) | |
| 490 return -1; | |
| 491 | |
| 492 if (addr != NULL) sin_get_ip(&so, addr); | |
| 493 if (port != NULL) *port = sin_get_port(&so); | |
| 494 | |
| 495 return 0; | |
| 496 } | |
| 497 | |
|
780
1cc947617c8b
imap_listen and imaps_listen accepts now "*" as "all IPv4 interfaces" and
Timo Sirainen <tss@iki.fi>
parents:
680
diff
changeset
|
498 int net_ip2host(const IPADDR *ip, char *host) |
| 0 | 499 { |
| 500 #ifdef HAVE_IPV6 | |
| 501 if (!inet_ntop(ip->family, &ip->ip, host, MAX_IP_LEN)) | |
| 502 return -1; | |
| 503 #else | |
| 504 unsigned long ip4; | |
| 505 | |
| 506 if (ip->family != AF_INET) { | |
| 507 strcpy(host, "0.0.0.0"); | |
| 508 return -1; | |
| 509 } | |
| 510 | |
| 511 ip4 = ntohl(ip->ip.s_addr); | |
| 512 i_snprintf(host, MAX_IP_LEN, "%lu.%lu.%lu.%lu", | |
| 513 (ip4 & 0xff000000UL) >> 24, | |
| 514 (ip4 & 0x00ff0000) >> 16, | |
| 515 (ip4 & 0x0000ff00) >> 8, | |
| 516 (ip4 & 0x000000ff)); | |
| 517 #endif | |
| 518 return 0; | |
| 519 } | |
| 520 | |
| 521 int net_host2ip(const char *host, IPADDR *ip) | |
| 522 { | |
| 523 if (strchr(host, ':') != NULL) { | |
| 524 /* IPv6 */ | |
| 525 ip->family = AF_INET6; | |
| 526 #ifdef HAVE_IPV6 | |
| 527 if (inet_pton(AF_INET6, host, &ip->ip) == 0) | |
| 528 return -1; | |
| 529 #else | |
| 530 ip->ip.s_addr = 0; | |
| 531 #endif | |
| 532 } else { | |
| 533 /* IPv4 */ | |
| 534 ip->family = AF_INET; | |
| 535 if (inet_aton(host, (struct in_addr *) &ip->ip) == 0) | |
| 536 return -1; | |
| 537 } | |
| 538 | |
| 539 return 0; | |
| 540 } | |
| 541 | |
| 542 /* Get socket error */ | |
| 543 int net_geterror(int fd) | |
| 544 { | |
| 545 int data; | |
| 546 socklen_t len = sizeof(data); | |
| 547 | |
| 548 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &data, &len) == -1) | |
| 549 return -1; | |
| 550 | |
| 551 return data; | |
| 552 } | |
| 553 | |
| 554 /* get error of net_gethostname() */ | |
| 555 const char *net_gethosterror(int error) | |
| 556 { | |
| 557 #ifdef HAVE_IPV6 | |
| 558 i_assert(error != 0); | |
| 559 | |
| 560 if (error == 1) { | |
| 561 /* getnameinfo() failed */ | |
| 562 return strerror(errno); | |
| 563 } | |
| 564 | |
| 565 return gai_strerror(error); | |
| 566 #else | |
| 567 switch (error) { | |
| 568 case HOST_NOT_FOUND: | |
| 569 return "Host not found"; | |
| 570 case NO_ADDRESS: | |
| 571 return "No IP address found for name"; | |
| 572 case NO_RECOVERY: | |
| 573 return "A non-recovable name server error occurred"; | |
| 574 case TRY_AGAIN: | |
| 575 return "A temporary error on an authoritative name server"; | |
| 576 } | |
| 577 | |
| 578 /* unknown error */ | |
| 579 return NULL; | |
| 580 #endif | |
| 581 } | |
| 582 | |
| 583 /* return TRUE if host lookup failed because it didn't exist (ie. not | |
| 584 some error with name server) */ | |
| 585 int net_hosterror_notfound(int error) | |
| 586 { | |
| 587 #ifdef HAVE_IPV6 | |
| 588 return error != 1 && (error == EAI_NONAME || error == EAI_NODATA); | |
| 589 #else | |
| 590 return error == HOST_NOT_FOUND || error == NO_ADDRESS; | |
| 591 #endif | |
| 592 } | |
| 593 | |
| 594 /* Get name of TCP service */ | |
| 349 | 595 char *net_getservbyport(unsigned short port) |
| 0 | 596 { |
| 597 struct servent *entry; | |
| 598 | |
| 349 | 599 entry = getservbyport(htons(port), "tcp"); |
| 0 | 600 return entry == NULL ? NULL : entry->s_name; |
| 601 } | |
| 602 | |
| 603 int is_ipv4_address(const char *host) | |
| 604 { | |
| 605 while (*host != '\0') { | |
| 606 if (*host != '.' && !i_isdigit(*host)) | |
| 607 return 0; | |
| 608 host++; | |
| 609 } | |
| 610 | |
| 611 return 1; | |
| 612 } | |
| 613 | |
| 614 int is_ipv6_address(const char *host) | |
| 615 { | |
| 616 while (*host != '\0') { | |
| 617 if (*host != ':' && !i_isxdigit(*host)) | |
| 618 return 0; | |
| 619 host++; | |
| 620 } | |
| 621 | |
| 622 return 1; | |
| 623 } |