Correct regression introduced by previous commit.

safe_recv(..., len), when used on a blocking fd, will attempt
to call recv and collect data until either EOF, a hard error,
or len bytes are collected.

The previous commit used safe_recv() in a blocking mode to read
a single byte into a buffer that was larger than a byte.  This
would cause ndhc to stall as safe_recv() would try to fill that
buffer when no more data would ever be sent.

This issue would only happen if ndhc is supposed to run a script.

Introduce and use safe_recv_once() that will correct this problem and
fill the semantic gap for blocking fds.  I add a new call because in
some cases the above behavior might be required for a blocking fd, too.

Note that the above issue is not a problem for nonblocking fds; the
EAGAIN or EWOULDBLOCK path will return a short read.
This commit is contained in:
Nicholas J. Kain 2022-09-07 17:08:43 -04:00
parent ebd2c4c01a
commit f7db9fd5e7
No known key found for this signature in database
3 changed files with 52 additions and 29 deletions

26
nk/io.c
View File

@ -1,10 +1,6 @@
// Copyright 2010-2018 Nicholas J. Kain <njkain at gmail dot com> // Copyright 2010-2022 Nicholas J. Kain <njkain at gmail dot com>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include "nk/io.h" #include "nk/io.h"
#include <limits.h>
// POSIX says read/write/etc() with len param > SSIZE_MAX is implementation defined. // POSIX says read/write/etc() with len param > SSIZE_MAX is implementation defined.
// So we avoid implementation-defined behavior with the bounding in each safe_* fn. // So we avoid implementation-defined behavior with the bounding in each safe_* fn.
@ -92,23 +88,3 @@ ssize_t safe_recv(int fd, char *buf, size_t len, int flags)
} }
return (ssize_t)s; return (ssize_t)s;
} }
ssize_t safe_recvmsg(int fd, struct msghdr *msg, int flags)
{
ssize_t r;
for (;;) {
r = recvmsg(fd, msg, flags);
if (r >= 0 || errno != EINTR) break;
}
return r;
}
int safe_ftruncate(int fd, off_t length)
{
int r;
for (;;) {
r = ftruncate(fd, length);
if (!r || errno != EINTR) break;
}
return r;
}

53
nk/io.h
View File

@ -1,17 +1,64 @@
// Copyright 2010-2015 Nicholas J. Kain <njkain at gmail dot com> // Copyright 2010-2022 Nicholas J. Kain <njkain at gmail dot com>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
#ifndef NCM_IO_H_ #ifndef NCM_IO_H_
#define NCM_IO_H_ #define NCM_IO_H_
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/types.h>
ssize_t safe_read(int fd, char *buf, size_t len); ssize_t safe_read(int fd, char *buf, size_t len);
// Same as above, but will only call read one time.
// Meant to be used with a blocking fd where we need <= len bytes.
static inline ssize_t safe_read_once(int fd, char *buf, size_t len)
{
if (len > SSIZE_MAX) len = SSIZE_MAX;
ssize_t r;
for (;;) {
r = read(fd, buf, len);
if (r >= 0 || errno != EINTR) break;
}
return r;
}
ssize_t safe_write(int fd, const char *buf, size_t len); ssize_t safe_write(int fd, const char *buf, size_t len);
ssize_t safe_sendto(int fd, const char *buf, size_t len, int flags, ssize_t safe_sendto(int fd, const char *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen); const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t safe_recv(int fd, char *buf, size_t len, int flags); ssize_t safe_recv(int fd, char *buf, size_t len, int flags);
ssize_t safe_recvmsg(int fd, struct msghdr *msg, int flags); // Same as above, but will only call read one time.
int safe_ftruncate(int fd, off_t length); // Meant to be used with a blocking fd where we need <= len bytes.
static inline ssize_t safe_recv_once(int fd, char *buf, size_t len, int flags)
{
if (len > SSIZE_MAX) len = SSIZE_MAX;
ssize_t r;
for (;;) {
r = recv(fd, buf, len, flags);
if (r >= 0 || errno != EINTR) break;
}
return r;
}
static inline ssize_t safe_recvmsg(int fd, struct msghdr *msg, int flags)
{
ssize_t r;
for (;;) {
r = recvmsg(fd, msg, flags);
if (r >= 0 || errno != EINTR) break;
}
return r;
}
static inline int safe_ftruncate(int fd, off_t length)
{
int r;
for (;;) {
r = ftruncate(fd, length);
if (!r || errno != EINTR) break;
}
return r;
}
#endif #endif

View File

@ -32,7 +32,7 @@ void request_scriptd_run(void)
suicide("%s: (%s) write failed: %zd", client_config.interface, suicide("%s: (%s) write failed: %zd", client_config.interface,
__func__, r); __func__, r);
char buf[16]; char buf[16];
r = safe_recv(scriptdSock[0], buf, sizeof buf, 0); r = safe_recv_once(scriptdSock[0], buf, sizeof buf, 0);
if (r == 0) { if (r == 0) {
// Remote end hung up. // Remote end hung up.
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);