2f3b16fc1
Denys Vlasenko
2026-04-12
Subject
libbb: rename two fields in ioloop_state, no logic changes
Binary
No binary (build failed)
Architecture & Compiler Flags
gcc -Wp,-MD,applets/.usage.d -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -Iinclude -Iinclude -o applets/usage applets/usage.c
Build Log
(log yok)
Commit Diff GitHub →
include/libbb.h+2 -2
| @@ -728,8 +728,8 @@ typedef struct ioloop_state { | |
| ioloop_state_t *io; \ | |
| int read_fd; \ | |
| int write_fd; \ | |
| - | int (*have_buffer_to_read_into)(void *this); \ |
| - | int (*have_data_to_write)(void *this); \ |
| + | int (*should_poll_read_fd)(void *this); \ |
| + | int (*should_poll_write_fd)(void *this); \ |
| int (*read)(void *this); \ | |
| int (*write)(void *this); \ | |
libbb/ioloop.c+15 -15
| @@ -76,19 +76,19 @@ void FAST_FUNC ioloop_close_fd_in_all_conns(ioloop_state_t *io, int fd) | |
| } | |
| #endif | |
| - | // have_data_to_write() - Do we have data to write? |
| + | // should_poll_write_fd() - Should ioloop poll write_fd for writability? |
| // May return error if knows that write side is closed, even if it has free buffer space. | |
| - | // > 0: Has data to write (or can generate such data) |
| + | // > 0: Yes, poll write_fd (has data to write, or can generate such data) |
| // In this case, write_fd must be valid! (it's a bug if it is < 0, can crash) | |
| - | // 0: No data to write currently |
| + | // 0: No, don't poll write_fd currently |
| // < 0: error, I probably freed myself (do not use my structure in this iteration, | |
| // on next iteration, if I indeed freed myself, you won't find me in the list). | |
| // | |
| - | // have_buffer_to_read_into() - Is there a buffer to read into? |
| + | // should_poll_read_fd() - Should ioloop poll read_fd for readability? |
| // May return error if knows that write side is closed, even if it has free buffer space. | |
| - | // > 0: Healthy, has buffer space, please poll read_fd |
| + | // > 0: Yes, poll read_fd (has buffer space, healthy) |
| // In this case, read_fd must be valid! (it's a bug if it is < 0) | |
| - | // 0: One of: |
| + | // 0: No, don't poll read_fd. One of: |
| // Buffer is full (hopefully write() will free some) | |
| // Got error/EOF, want to drain write buffer first | |
| // < 0: Error/EOF, I probably freed myself (do not use my structure) | |
| @@ -121,26 +121,26 @@ void FAST_FUNC ioloop_close_fd_in_all_conns(ioloop_state_t *io, int fd) | |
| // Putting "this connection is dead, close+remove+free" code into read function | |
| // is often inconvenient: if you got EOF/error on read, you still want to poll write side | |
| // and try to write out the buffered data to it. Which means read() can't "remove+free". | |
| - | // Instead, you can remember EOF/error and make future have_buffer_to_read_into() respond 0. |
| + | // Instead, you can remember EOF/error and make future should_poll_read_fd() respond 0. |
| // One way is to close (if possible) read_fd, set it to -1 and use as a flag. | |
| // | |
| // If need to support one-sided close, such as when HTTP/1.x client sends us | |
| // "GET / HTTP/1.1\r\n\r\n" and closes its writing side with shutdown(SHUT_WR), | |
| // the idiom is that when read() sees EOF, it sets conn->read_fd to -1 | |
| - | // and subsequently have_buffer_to_read_into() always return 0 (no more attempts to read); |
| + | // and subsequently should_poll_read_fd() always return 0 (no more attempts to read); |
| // write() flushes all remaining data to conn->write_fd and then signals EOF | |
| // to write_fd: shutdown(SHUT_WR) for sockets, close() for pipes | |
| // (how to do this for ptys!?). | |
| - | // After this, have_data_to_write() can return 0 if fd has to stay open (socket) |
| + | // After this, should_poll_write_fd() can return 0 if fd has to stay open (socket) |
| // or can return -1 and free itself if fd is closed. | |
| - | static ALWAYS_INLINE int have_data_to_write(connection_t *conn) |
| + | static ALWAYS_INLINE int should_poll_write_fd(connection_t *conn) |
| { | |
| - | return conn->have_data_to_write(conn); |
| + | return conn->should_poll_write_fd(conn); |
| } | |
| - | static ALWAYS_INLINE int have_buffer_to_read_into(connection_t *conn) |
| + | static ALWAYS_INLINE int should_poll_read_fd(connection_t *conn) |
| { | |
| - | return conn->have_buffer_to_read_into(conn); |
| + | return conn->should_poll_read_fd(conn); |
| } | |
| static ALWAYS_INLINE int write_from_buf(connection_t *conn) | |
| { | |
| @@ -177,7 +177,7 @@ int FAST_FUNC ioloop_run(ioloop_state_t *io) | |
| int rcw, rcr; | |
| next = conn->next; /* in case conn is freed */ | |
| - | rcw = have_data_to_write(conn); |
| + | rcw = should_poll_write_fd(conn); |
| if (rcw < 0) { | |
| /* often indicates that conn is gone (freed), do not use it anymore */ | |
| goto next; | |
| @@ -186,7 +186,7 @@ int FAST_FUNC ioloop_run(ioloop_state_t *io) | |
| * the *reader* may decide to abort (return rcr < 0)! | |
| * Check it first: | |
| */ | |
| - | rcr = have_buffer_to_read_into(conn); |
| + | rcr = should_poll_read_fd(conn); |
| if (rcr < 0) | |
| goto next; | |
| if (rcw > 0) { | |
networking/telnet.c+8 -8
| @@ -576,7 +576,7 @@ static void show_menu(void) | |
| cookmode(); | |
| } | |
| - | static int have_buffer_to_read_from_stdin(void *this) |
| + | static int should_poll_read_fd_stdin(void *this) |
| { | |
| stdin_to_net_t *conn = this; | |
| if (conn->read_fd < 0) | |
| @@ -656,7 +656,7 @@ static int read_from_stdin(void *this) | |
| return count; | |
| } | |
| - | static int have_data_to_write_to_net(void *this) |
| + | static int should_poll_write_fd_net(void *this) |
| { | |
| stdin_to_net_t *conn = this; | |
| if (conn->size == 0 && conn->read_fd < 0) { | |
| @@ -700,7 +700,7 @@ static int write_to_net(void *this) | |
| return count; | |
| } | |
| - | static int have_buffer_to_read_from_net(void *this) |
| + | static int should_poll_read_fd_net(void *this) |
| { | |
| net_to_stdout_t *conn = this; | |
| if (conn->read_fd < 0) | |
| @@ -897,7 +897,7 @@ static int read_from_net(void *this) | |
| return count; | |
| } | |
| - | static int have_data_to_write_to_stdout(void *this) |
| + | static int should_poll_write_fd_stdout(void *this) |
| { | |
| net_to_stdout_t *conn = this; | |
| if (conn->size == 0 && conn->read_fd < 0) { | |
| @@ -988,16 +988,16 @@ int telnet_main(int argc UNUSED_PARAM, char **argv) | |
| signal(SIGPIPE, SIG_IGN); | |
| // Initialize connections | |
| - | G.conn_stdin2net.have_buffer_to_read_into = have_buffer_to_read_from_stdin; |
| - | G.conn_stdin2net.have_data_to_write = have_data_to_write_to_net; |
| + | G.conn_stdin2net.should_poll_read_fd = should_poll_read_fd_stdin; |
| + | G.conn_stdin2net.should_poll_write_fd = should_poll_write_fd_net; |
| G.conn_stdin2net.read = read_from_stdin; | |
| G.conn_stdin2net.write = write_to_net; | |
| if (STDIN_FILENO != 0) | |
| G.conn_stdin2net.read_fd = STDIN_FILENO; | |
| G.conn_stdin2net.write_fd = netfd; | |
| - | G.conn_net2stdout.have_buffer_to_read_into = have_buffer_to_read_from_net; |
| - | G.conn_net2stdout.have_data_to_write = have_data_to_write_to_stdout; |
| + | G.conn_net2stdout.should_poll_read_fd = should_poll_read_fd_net; |
| + | G.conn_net2stdout.should_poll_write_fd = should_poll_write_fd_stdout; |
| G.conn_net2stdout.read = read_from_net; | |
| G.conn_net2stdout.write = write_to_stdout; | |
| G.conn_net2stdout.read_fd = netfd; | |
networking/telnetd.c+19 -19
| @@ -279,8 +279,8 @@ static void ALWAYS_INLINE remove_and_free_to_net(pty_to_net_t *ts) | |
| // Theory of operation | |
| // (AKA "when should I close fds? when should I detach from ioloop?"). | |
| // The fds are named read_fd and write_fd, but for clarity let's call them netfd and ptyfd. | |
| - | // net_to_pty::have_data_to_write |
| - | // net_to_pty::have_buffer_to_read_into |
| + | // net_to_pty::should_poll_write_fd |
| + | // net_to_pty::should_poll_read_fd |
| // if ptyfd < 0: //sibling told us ptyfd is down? | |
| // if sibling && sibling->netfd >= 0: netfd = -1; //do not close netfd, sibling uses it (if sibling exists)! | |
| // close_and_detach; | |
| @@ -308,7 +308,7 @@ static unsigned char read_byte_unescaping_IAC(int *iac_cnt, unsigned char **pp) | |
| return c; | |
| } | |
| - | static int net_to_pty__have_data_to_write(void *this) |
| + | static int net_to_pty__should_poll_write_fd(void *this) |
| { | |
| //connection_t *conn = this; | |
| net_to_pty_t *ts = this; | |
| @@ -471,7 +471,7 @@ static int net_to_pty__write(void *this) | |
| found = memchr(buf, IAC, wr); | |
| if (found == buf) { | |
| /* The first char is IAC. | |
| - | * have_data_to_write() ensures we are only called this way |
| + | * should_poll_write_fd() ensures we are only called this way |
| * if there are two IACs. | |
| * It also ensures the buffer is not wrapping within 7 chars. | |
| * Write one IAC. If that works, skip both. | |
| @@ -524,7 +524,7 @@ static int net_to_pty__write(void *this) | |
| } | |
| /* Check if buffer has space to read into */ | |
| - | static int net_to_pty__have_buffer_to_read_into(void *this) |
| + | static int net_to_pty__should_poll_read_fd(void *this) |
| { | |
| //connection_t *conn = this; | |
| net_to_pty_t *ts = this; | |
| @@ -619,17 +619,17 @@ static int net_to_pty__read(void *this) | |
| static net_to_pty_t *new_net_to_pty(int from, int to) | |
| { | |
| net_to_pty_t *this = xzalloc(sizeof(*this) + TO_PTY_BUFSIZE); | |
| - | this->have_buffer_to_read_into = net_to_pty__have_buffer_to_read_into; |
| - | this->have_data_to_write = net_to_pty__have_data_to_write; |
| - | this->read = net_to_pty__read; |
| - | this->write = net_to_pty__write; |
| + | this->should_poll_read_fd = net_to_pty__should_poll_read_fd; |
| + | this->should_poll_write_fd = net_to_pty__should_poll_write_fd; |
| + | this->read = net_to_pty__read; |
| + | this->write = net_to_pty__write; |
| this->read_fd = from; | |
| this->write_fd = to; | |
| /* indexes and size are all 0 */ | |
| return this; | |
| } | |
| - | static int pty_to_net__have_buffer_to_read_into(void *this) |
| + | static int pty_to_net__should_poll_read_fd(void *this) |
| { | |
| //connection_t *conn = this; | |
| pty_to_net_t *ts = this; | |
| @@ -725,7 +725,7 @@ static int pty_to_net__read(void *this) | |
| return count; | |
| } | |
| - | static int pty_to_net__have_data_to_write(void *this) |
| + | static int pty_to_net__should_poll_write_fd(void *this) |
| { | |
| pty_to_net_t *ts = this; | |
| if (ts->size == 0) { | |
| @@ -832,10 +832,10 @@ static int pty_to_net__write(void *this) | |
| static pty_to_net_t *new_pty_to_net(int from, int to) | |
| { | |
| pty_to_net_t *this = xzalloc(sizeof(*this) + TO_NET_BUFSIZE); | |
| - | this->have_buffer_to_read_into = pty_to_net__have_buffer_to_read_into; |
| - | this->have_data_to_write = pty_to_net__have_data_to_write; |
| - | this->read = pty_to_net__read; |
| - | this->write = pty_to_net__write; |
| + | this->should_poll_read_fd = pty_to_net__should_poll_read_fd; |
| + | this->should_poll_write_fd = pty_to_net__should_poll_write_fd; |
| + | this->read = pty_to_net__read; |
| + | this->write = pty_to_net__write; |
| this->read_fd = from; | |
| this->write_fd = to; | |
| /* indexes and size are all 0 */ | |
| @@ -1013,10 +1013,10 @@ static int accept_conn__return_zero(void *this UNUSED_PARAM) | |
| static struct accept_conn *new_accept_conn(int fd) | |
| { | |
| struct accept_conn *this = xzalloc(sizeof(*this)); | |
| - | this->have_buffer_to_read_into = accept_conn__can_accept; |
| - | this->have_data_to_write = accept_conn__return_zero; |
| - | this->read = accept_conn__accept; |
| - | //this->write = accept_conn__return_zero; //never called |
| + | this->should_poll_read_fd = accept_conn__can_accept; |
| + | this->should_poll_write_fd = accept_conn__return_zero; |
| + | this->read = accept_conn__accept; |
| + | //this->write = accept_conn__return_zero; //never called |
| this->read_fd = fd; | |
| this->write_fd = -1; | |
| return this; | |