The following changes since commit 27ddbfa09b22911d5cefb42a44f894e6eb48216e:
Fix potential oops in file unlocking at free time (2014-01-22 16:27:32 -0800)
are available in the git repository at:
git://git.kernel.dk/fio.git master
Jens Axboe (4):
engine: basic support for IPv6 in the net IO engine
engine: IPv6 net engine updates
engine: pass in right protocol family on host lookup
server: make the connect code fully IPv6
HOWTO | 2 +
engines/falloc.c | 5 +-
engines/net.c | 277 ++++++++++++++++++++++++++++++++++++++++++++----------
fio.1 | 6 +
fio.h | 4 +-
server.c | 51 ++++++----
6 files changed, 270 insertions(+), 75 deletions(-)
---
Diff of recent changes:
diff --git a/HOWTO b/HOWTO
index c3672d8..e69cf41 100644
--- a/HOWTO
+++ b/HOWTO
@@ -1496,7 +1496,9 @@ that defines them is selected.
[net] proto=str The network protocol to use. Accepted values are:
tcp Transmission control protocol
+ tcpv6 Transmission control protocol V6
udp User datagram protocol
+ udpv6 User datagram protocol V6
unix UNIX domain socket
When the protocol is TCP or UDP, the port must also be given,
diff --git a/engines/falloc.c b/engines/falloc.c
index 8025085..17a901a 100644
--- a/engines/falloc.c
+++ b/engines/falloc.c
@@ -43,9 +43,10 @@ open_again:
if (f->fd == -1) {
char buf[FIO_VERROR_SIZE];
- int __e = errno;
+ int e = errno;
+
snprintf(buf, sizeof(buf), "open(%s)", f->file_name);
- td_verror(td, __e, buf);
+ td_verror(td, e, buf);
}
if (!from_hash && f->fd != -1) {
diff --git a/engines/net.c b/engines/net.c
index 52cc8a7..5fdc88c 100644
--- a/engines/net.c
+++ b/engines/net.c
@@ -27,6 +27,7 @@ struct netio_data {
int use_splice;
int pipes[2];
struct sockaddr_in addr;
+ struct sockaddr_in6 addr6;
struct sockaddr_un addr_un;
};
@@ -54,6 +55,8 @@ enum {
FIO_TYPE_TCP = 1,
FIO_TYPE_UDP = 2,
FIO_TYPE_UNIX = 3,
+ FIO_TYPE_TCP_V6 = 4,
+ FIO_TYPE_UDP_V6 = 5,
};
static int str_hostname_cb(void *data, const char *input);
@@ -91,10 +94,18 @@ static struct fio_option options[] = {
.oval = FIO_TYPE_TCP,
.help = "Transmission Control Protocol",
},
+ { .ival = "tcpv6",
+ .oval = FIO_TYPE_TCP_V6,
+ .help = "Transmission Control Protocol V6",
+ },
{ .ival = "udp",
.oval = FIO_TYPE_UDP,
.help = "User Datagram Protocol",
},
+ { .ival = "udpv6",
+ .oval = FIO_TYPE_UDP_V6,
+ .help = "User Datagram Protocol V6",
+ },
{ .ival = "unix",
.oval = FIO_TYPE_UNIX,
.help = "UNIX domain socket",
@@ -155,6 +166,21 @@ static struct fio_option options[] = {
},
};
+static inline int is_udp(struct netio_options *o)
+{
+ return o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_UDP_V6;
+}
+
+static inline int is_tcp(struct netio_options *o)
+{
+ return o->proto == FIO_TYPE_TCP || o->proto == FIO_TYPE_TCP_V6;
+}
+
+static inline int is_ipv6(struct netio_options *o)
+{
+ return o->proto == FIO_TYPE_UDP_V6 || o->proto == FIO_TYPE_TCP_V6;
+}
+
/*
* Return -1 for error and 'nr events' for a positive number
* of events
@@ -207,7 +233,7 @@ static int fio_netio_prep(struct thread_data *td, struct
io_u *io_u)
/*
* Make sure we don't see spurious reads to a receiver, and vice versa
*/
- if (o->proto == FIO_TYPE_TCP)
+ if (is_tcp(o))
return 0;
if ((o->listen && io_u->ddir == DDIR_WRITE) ||
@@ -361,12 +387,20 @@ static int fio_netio_send(struct thread_data *td, struct
io_u *io_u)
int ret, flags = 0;
do {
- if (o->proto == FIO_TYPE_UDP) {
- struct sockaddr *to = (struct sockaddr *) &nd->addr;
+ if (is_udp(o)) {
+ struct sockaddr *to;
+ socklen_t len;
+
+ if (is_ipv6(o)) {
+ to = (struct sockaddr *) &nd->addr6;
+ len = sizeof(nd->addr6);
+ } else {
+ to = (struct sockaddr *) &nd->addr;
+ len = sizeof(nd->addr);
+ }
ret = sendto(io_u->file->fd, io_u->xfer_buf,
- io_u->xfer_buflen, flags, to,
- sizeof(*to));
+ io_u->xfer_buflen, flags, to, len);
} else {
/*
* if we are going to write more, set MSG_MORE
@@ -413,14 +447,18 @@ static int fio_netio_recv(struct thread_data *td, struct
io_u *io_u)
int ret, flags = 0;
do {
- if (o->proto == FIO_TYPE_UDP) {
- socklen_t l;
- socklen_t *len = &l;
+ if (is_udp(o)) {
struct sockaddr *from;
+ socklen_t l, *len = &l;
if (o->listen) {
- from = (struct sockaddr *) &nd->addr;
- *len = sizeof(nd->addr);
+ if (!is_ipv6(o)) {
+ from = (struct sockaddr *) &nd->addr;
+ *len = sizeof(nd->addr);
+ } else {
+ from = (struct sockaddr *) &nd->addr6;
+ *len = sizeof(nd->addr6);
+ }
} else {
from = NULL;
len = NULL;
@@ -458,13 +496,13 @@ static int __fio_netio_queue(struct thread_data *td,
struct io_u *io_u,
int ret;
if (ddir == DDIR_WRITE) {
- if (!nd->use_splice || o->proto == FIO_TYPE_UDP ||
+ if (!nd->use_splice || is_udp(o) ||
o->proto == FIO_TYPE_UNIX)
ret = fio_netio_send(td, io_u);
else
ret = fio_netio_splice_out(td, io_u);
} else if (ddir == DDIR_READ) {
- if (!nd->use_splice || o->proto == FIO_TYPE_UDP ||
+ if (!nd->use_splice || is_udp(o) ||
o->proto == FIO_TYPE_UNIX)
ret = fio_netio_recv(td, io_u);
else
@@ -524,9 +562,15 @@ static int fio_netio_connect(struct thread_data *td,
struct fio_file *f)
if (o->proto == FIO_TYPE_TCP) {
domain = AF_INET;
type = SOCK_STREAM;
+ } else if (o->proto == FIO_TYPE_TCP_V6) {
+ domain = AF_INET6;
+ type = SOCK_STREAM;
} else if (o->proto == FIO_TYPE_UDP) {
domain = AF_INET;
type = SOCK_DGRAM;
+ } else if (o->proto == FIO_TYPE_UDP_V6) {
+ domain = AF_INET6;
+ type = SOCK_DGRAM;
} else if (o->proto == FIO_TYPE_UNIX) {
domain = AF_UNIX;
type = SOCK_STREAM;
@@ -543,7 +587,7 @@ static int fio_netio_connect(struct thread_data *td, struct
fio_file *f)
}
#ifdef CONFIG_TCP_NODELAY
- if (o->nodelay && o->proto == FIO_TYPE_TCP) {
+ if (o->nodelay && is_tcp(o)) {
int optval = 1;
if (setsockopt(f->fd, IPPROTO_TCP, TCP_NODELAY, (void *)
&optval, sizeof(int)) < 0) {
@@ -553,12 +597,18 @@ static int fio_netio_connect(struct thread_data *td,
struct fio_file *f)
}
#endif
- if (o->proto == FIO_TYPE_UDP) {
+ if (is_udp(o)) {
if (!fio_netio_is_multicast(td->o.filename))
return 0;
+ if (is_ipv6(o)) {
+ log_err("fio: multicast not supported on IPv6\n");
+ close(f->fd);
+ return 1;
+ }
if (o->intfc) {
struct in_addr interface_addr;
+
if (inet_aton(o->intfc, &interface_addr) == 0) {
log_err("fio: interface not valid interface
IP\n");
close(f->fd);
@@ -584,6 +634,15 @@ static int fio_netio_connect(struct thread_data *td,
struct fio_file *f)
close(f->fd);
return 1;
}
+ } else if (o->proto == FIO_TYPE_TCP_V6) {
+ socklen_t len = sizeof(nd->addr6);
+
+ if (connect(f->fd, (struct sockaddr *) &nd->addr6, len) < 0) {
+ td_verror(td, errno, "connect");
+ close(f->fd);
+ return 1;
+ }
+
} else {
struct sockaddr_un *addr = &nd->addr_un;
socklen_t len;
@@ -604,10 +663,10 @@ static int fio_netio_accept(struct thread_data *td,
struct fio_file *f)
{
struct netio_data *nd = td->io_ops->data;
struct netio_options *o = td->eo;
- socklen_t socklen = sizeof(nd->addr);
+ socklen_t socklen;
int state;
- if (o->proto == FIO_TYPE_UDP) {
+ if (is_udp(o)) {
f->fd = nd->listenfd;
return 0;
}
@@ -620,14 +679,21 @@ static int fio_netio_accept(struct thread_data *td,
struct fio_file *f)
if (poll_wait(td, nd->listenfd, POLLIN) < 0)
goto err;
- f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr, &socklen);
+ if (o->proto == FIO_TYPE_TCP) {
+ socklen = sizeof(nd->addr);
+ f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr,
&socklen);
+ } else {
+ socklen = sizeof(nd->addr6);
+ f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr6,
&socklen);
+ }
+
if (f->fd < 0) {
td_verror(td, errno, "accept");
goto err;
}
#ifdef CONFIG_TCP_NODELAY
- if (o->nodelay && o->proto == FIO_TYPE_TCP) {
+ if (o->nodelay && is_tcp(o)) {
int optval = 1;
if (setsockopt(f->fd, IPPROTO_TCP, TCP_NODELAY, (void *)
&optval, sizeof(int)) < 0) {
@@ -648,15 +714,24 @@ err:
static void fio_netio_udp_close(struct thread_data *td, struct fio_file *f)
{
struct netio_data *nd = td->io_ops->data;
+ struct netio_options *o = td->eo;
struct udp_close_msg msg;
- struct sockaddr *to = (struct sockaddr *) &nd->addr;
+ struct sockaddr *to;
+ socklen_t len;
int ret;
+ if (is_ipv6(o)) {
+ to = (struct sockaddr *) &nd->addr6;
+ len = sizeof(nd->addr6);
+ } else {
+ to = (struct sockaddr *) &nd->addr;
+ len = sizeof(nd->addr);
+ }
+
msg.magic = htonl(FIO_LINK_OPEN_CLOSE_MAGIC);
msg.cmd = htonl(FIO_LINK_CLOSE);
- ret = sendto(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to,
- sizeof(nd->addr));
+ ret = sendto(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to, len);
if (ret < 0)
td_verror(td, errno, "sendto udp link close");
}
@@ -669,7 +744,7 @@ static int fio_netio_close_file(struct thread_data *td,
struct fio_file *f)
* If this is an UDP connection, notify the receiver that we are
* closing down the link
*/
- if (o->proto == FIO_TYPE_UDP)
+ if (is_udp(o))
fio_netio_udp_close(td, f);
return generic_close_file(td, f);
@@ -678,11 +753,20 @@ static int fio_netio_close_file(struct thread_data *td,
struct fio_file *f)
static int fio_netio_udp_recv_open(struct thread_data *td, struct fio_file *f)
{
struct netio_data *nd = td->io_ops->data;
+ struct netio_options *o = td->eo;
struct udp_close_msg msg;
- struct sockaddr *to = (struct sockaddr *) &nd->addr;
- socklen_t len = sizeof(nd->addr);
+ struct sockaddr *to;
+ socklen_t len;
int ret;
+ if (is_ipv6(o)) {
+ len = sizeof(nd->addr6);
+ to = (struct sockaddr *) &nd->addr6;
+ } else {
+ len = sizeof(nd->addr);
+ to = (struct sockaddr *) &nd->addr;
+ }
+
ret = recvfrom(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to,
&len);
if (ret < 0) {
td_verror(td, errno, "recvfrom udp link open");
@@ -702,15 +786,24 @@ static int fio_netio_udp_recv_open(struct thread_data
*td, struct fio_file *f)
static int fio_netio_udp_send_open(struct thread_data *td, struct fio_file *f)
{
struct netio_data *nd = td->io_ops->data;
+ struct netio_options *o = td->eo;
struct udp_close_msg msg;
- struct sockaddr *to = (struct sockaddr *) &nd->addr;
+ struct sockaddr *to;
+ socklen_t len;
int ret;
+ if (is_ipv6(o)) {
+ len = sizeof(nd->addr6);
+ to = (struct sockaddr *) &nd->addr6;
+ } else {
+ len = sizeof(nd->addr);
+ to = (struct sockaddr *) &nd->addr;
+ }
+
msg.magic = htonl(FIO_LINK_OPEN_CLOSE_MAGIC);
msg.cmd = htonl(FIO_LINK_OPEN);
- ret = sendto(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to,
- sizeof(nd->addr));
+ ret = sendto(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to, len);
if (ret < 0) {
td_verror(td, errno, "sendto udp link open");
return ret;
@@ -734,7 +827,7 @@ static int fio_netio_open_file(struct thread_data *td,
struct fio_file *f)
return ret;
}
- if (o->proto == FIO_TYPE_UDP) {
+ if (is_udp(o)) {
if (td_write(td))
ret = fio_netio_udp_send_open(td, f);
else {
@@ -753,10 +846,52 @@ static int fio_netio_open_file(struct thread_data *td,
struct fio_file *f)
return ret;
}
+static int fio_fill_addr(struct thread_data *td, const char *host, int af,
+ void *dst, struct addrinfo **res)
+{
+ struct netio_options *o = td->eo;
+ struct addrinfo hints;
+ int ret;
+
+ if (inet_pton(af, host, dst))
+ return 0;
+
+ memset(&hints, 0, sizeof(hints));
+
+ if (is_tcp(o))
+ hints.ai_socktype = SOCK_STREAM;
+ else
+ hints.ai_socktype = SOCK_DGRAM;
+
+ if (is_ipv6(o))
+ hints.ai_family = AF_INET6;
+ else
+ hints.ai_family = AF_INET;
+
+ ret = getaddrinfo(host, NULL, &hints, res);
+ if (ret) {
+ int e = EINVAL;
+ char str[128];
+
+ if (ret == EAI_SYSTEM)
+ e = errno;
+
+ snprintf(str, sizeof(str), "getaddrinfo: %s",
gai_strerror(ret));
+ td_verror(td, e, str);
+ return 1;
+ }
+
+ return 0;
+}
+
static int fio_netio_setup_connect_inet(struct thread_data *td,
const char *host, unsigned short port)
{
struct netio_data *nd = td->io_ops->data;
+ struct netio_options *o = td->eo;
+ struct addrinfo *res = NULL;
+ void *dst, *src;
+ int af, len;
if (!host) {
log_err("fio: connect with no host to connect to.\n");
@@ -769,19 +904,33 @@ static int fio_netio_setup_connect_inet(struct
thread_data *td,
nd->addr.sin_family = AF_INET;
nd->addr.sin_port = htons(port);
+ nd->addr6.sin6_family = AF_INET6;
+ nd->addr6.sin6_port = htons(port);
- if (inet_aton(host, &nd->addr.sin_addr) != 1) {
- struct hostent *hent;
+ if (is_ipv6(o)) {
+ af = AF_INET6;
+ dst = &nd->addr6;
+ } else {
+ af = AF_INET;
+ dst = &nd->addr;
+ }
- hent = gethostbyname(host);
- if (!hent) {
- td_verror(td, errno, "gethostbyname");
- return 1;
- }
+ if (fio_fill_addr(td, host, af, dst, &res))
+ return 1;
+
+ if (!res)
+ return 0;
- memcpy(&nd->addr.sin_addr, hent->h_addr, 4);
+ if (is_ipv6(o)) {
+ len = sizeof(nd->addr6.sin6_addr);
+ src = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
+ } else {
+ len = sizeof(nd->addr.sin_addr);
+ src = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
}
+ memcpy(dst, src, len);
+ freeaddrinfo(res);
return 0;
}
@@ -800,7 +949,7 @@ static int fio_netio_setup_connect(struct thread_data *td)
{
struct netio_options *o = td->eo;
- if (o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_TCP)
+ if (is_udp(o) || is_tcp(o))
return fio_netio_setup_connect_inet(td, td->o.filename,o->port);
else
return fio_netio_setup_connect_unix(td, td->o.filename);
@@ -845,15 +994,32 @@ static int fio_netio_setup_listen_inet(struct thread_data
*td, short port)
struct netio_options *o = td->eo;
struct ip_mreq mr;
struct sockaddr_in sin;
- int fd, opt, type;
+ struct sockaddr_in6 sin6;
+ struct sockaddr *saddr;
+ int fd, opt, type, domain;
+ socklen_t len;
memset(&sin, 0, sizeof(sin));
- if (o->proto == FIO_TYPE_TCP)
+ memset(&sin6, 0, sizeof(sin6));
+
+ if (o->proto == FIO_TYPE_TCP) {
type = SOCK_STREAM;
- else
+ domain = AF_INET;
+ } else if (o->proto == FIO_TYPE_TCP_V6) {
+ type = SOCK_STREAM;
+ domain = AF_INET6;
+ } else if (o->proto == FIO_TYPE_UDP) {
type = SOCK_DGRAM;
+ domain = AF_INET;
+ } else if (o->proto == FIO_TYPE_UDP_V6) {
+ type = SOCK_DGRAM;
+ domain = AF_INET6;
+ } else {
+ log_err("fio: unknown proto %d\n", o->proto);
+ return 1;
+ }
- fd = socket(AF_INET, type, 0);
+ fd = socket(domain, type, 0);
if (fd < 0) {
td_verror(td, errno, "socket");
return 1;
@@ -874,8 +1040,7 @@ static int fio_netio_setup_listen_inet(struct thread_data
*td, short port)
#endif
if (td->o.filename){
- if(o->proto != FIO_TYPE_UDP ||
- !fio_netio_is_multicast(td->o.filename)) {
+ if (!is_udp(o) || !fio_netio_is_multicast(td->o.filename)) {
log_err("fio: hostname not valid for non-multicast
inbound network IO\n");
close(fd);
return 1;
@@ -900,11 +1065,23 @@ static int fio_netio_setup_listen_inet(struct
thread_data *td, short port)
}
}
- nd->addr.sin_family = AF_INET;
- nd->addr.sin_addr.s_addr = sin.sin_addr.s_addr ? sin.sin_addr.s_addr :
htonl(INADDR_ANY);
- nd->addr.sin_port = htons(port);
+ if (!is_ipv6(o)) {
+ saddr = (struct sockaddr *) &nd->addr;
+ len = sizeof(nd->addr);
+
+ nd->addr.sin_family = AF_INET;
+ nd->addr.sin_addr.s_addr = sin.sin_addr.s_addr ?
sin.sin_addr.s_addr : htonl(INADDR_ANY);
+ nd->addr.sin_port = htons(port);
+ } else {
+ saddr = (struct sockaddr *) &nd->addr6;
+ len = sizeof(nd->addr6);
+
+ nd->addr6.sin6_family = AF_INET6;
+ nd->addr6.sin6_addr = sin6.sin6_addr.s6_addr ? sin6.sin6_addr :
in6addr_any;
+ nd->addr6.sin6_port = htons(port);
+ }
- if (bind(fd, (struct sockaddr *) &nd->addr, sizeof(nd->addr)) < 0) {
+ if (bind(fd, saddr, len) < 0) {
td_verror(td, errno, "bind");
return 1;
}
@@ -919,14 +1096,14 @@ static int fio_netio_setup_listen(struct thread_data *td)
struct netio_options *o = td->eo;
int ret;
- if (o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_TCP)
+ if (is_udp(o) || is_tcp(o))
ret = fio_netio_setup_listen_inet(td, o->port);
else
ret = fio_netio_setup_listen_unix(td, td->o.filename);
if (ret)
return ret;
- if (o->proto == FIO_TYPE_UDP)
+ if (is_udp(o))
return 0;
if (listen(nd->listenfd, 10) < 0) {
@@ -961,7 +1138,7 @@ static int fio_netio_init(struct thread_data *td)
return 1;
}
- if (o->proto != FIO_TYPE_TCP) {
+ if (!is_tcp(o)) {
if (o->listen) {
log_err("fio: listen only valid for TCP proto IO\n");
return 1;
diff --git a/fio.1 b/fio.1
index 82d05b7..b5ff80c 100644
--- a/fio.1
+++ b/fio.1
@@ -1333,9 +1333,15 @@ The network protocol to use. Accepted values are:
.B tcp
Transmission control protocol
.TP
+.B tcpv6
+Transmission control protocol V6
+.TP
.B udp
User datagram protocol
.TP
+.B udpv6
+User datagram protocol V6
+.TP
.B unix
UNIX domain socket
.RE
diff --git a/fio.h b/fio.h
index a0927bd..719b2f3 100644
--- a/fio.h
+++ b/fio.h
@@ -343,10 +343,10 @@ enum {
#define __td_verror(td, err, msg, func)
\
do { \
- int e = (err); \
+ int __e = (err);
\
if ((td)->error) \
break; \
- (td)->error = e; \
+ (td)->error = __e; \
if (!(td)->first_error) \
snprintf(td->verror, sizeof(td->verror), "file:%s:%d,
func=%s, error=%s", __FILE__, __LINE__, (func), (msg)); \
} while (0)
diff --git a/server.c b/server.c
index 6e96b77..9b13df8 100644
--- a/server.c
+++ b/server.c
@@ -840,7 +840,8 @@ static int handle_connection(int sk)
static int accept_loop(int listen_sk)
{
struct sockaddr_in addr;
- socklen_t len = sizeof(addr);
+ struct sockaddr_in6 addr6;
+ socklen_t len = use_ipv6 ? sizeof(addr6) : sizeof(addr);
struct pollfd pfd;
int ret = 0, sk, flags, exitval = 0;
FLIST_HEAD(conn_list);
@@ -852,6 +853,8 @@ static int accept_loop(int listen_sk)
fcntl(listen_sk, F_SETFL, flags);
while (!exit_backend) {
+ const char *from;
+ char buf[64];
pid_t pid;
pfd.fd = listen_sk;
@@ -882,13 +885,22 @@ static int accept_loop(int listen_sk)
if (exit_backend || ret < 0)
break;
- sk = accept(listen_sk, (struct sockaddr *) &addr, &len);
+ if (use_ipv6)
+ sk = accept(listen_sk, (struct sockaddr *) &addr6,
&len);
+ else
+ sk = accept(listen_sk, (struct sockaddr *) &addr, &len);
+
if (sk < 0) {
log_err("fio: accept: %s\n", strerror(errno));
return -1;
}
- dprint(FD_NET, "server: connect from %s\n",
inet_ntoa(addr.sin_addr));
+ if (use_ipv6)
+ from = inet_ntop(AF_INET6, (struct sockaddr *)
&addr6.sin6_addr, buf, sizeof(buf));
+ else
+ from = inet_ntop(AF_INET, (struct sockaddr *)
&addr.sin_addr, buf, sizeof(buf));
+
+ dprint(FD_NET, "server: connect from %s\n", from);
pid = fork();
if (pid) {
@@ -1392,29 +1404,26 @@ int fio_server_parse_host(const char *host, int *ipv6,
struct in_addr *inp,
ret = inet_pton(AF_INET, host, inp);
if (ret != 1) {
- struct hostent *hent;
+ struct addrinfo hints, *res;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = *ipv6 ? AF_INET6 : AF_INET;
+ hints.ai_socktype = SOCK_STREAM;
- hent = gethostbyname(host);
- if (!hent) {
- log_err("fio: failed to resolve <%s>\n", host);
+ ret = getaddrinfo(host, NULL, &hints, &res);
+ if (ret) {
+ log_err("fio: failed to resolve <%s> (%s)\n", host,
+ gai_strerror(ret));
return 0;
}
- if (*ipv6) {
- if (hent->h_addrtype != AF_INET6) {
- log_info("fio: falling back to IPv4\n");
- *ipv6 = 0;
- } else
- memcpy(inp6, hent->h_addr_list[0], 16);
- }
- if (!*ipv6) {
- if (hent->h_addrtype != AF_INET) {
- log_err("fio: lookup type mismatch\n");
- return 0;
- }
- memcpy(inp, hent->h_addr_list[0], 4);
- }
+ if (*ipv6)
+ memcpy(inp6, &((struct sockaddr_in6 *)
res->ai_addr)->sin6_addr, sizeof(*inp6));
+ else
+ memcpy(inp, &((struct sockaddr_in *)
res->ai_addr)->sin_addr, sizeof(*inp));
+
ret = 1;
+ freeaddrinfo(res);
}
return !(ret == 1);
--
To unsubscribe from this list: send the line "unsubscribe fio" in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
