9pfs/solanum-vs-hackint-and-charybdis
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

(Mostly) exorcise select()

Browse source 
Sadly, this just sends it to purgatory. It's still around for the
socketpair() emulation and the nanosleep() emulation.

socketpair() obviously only selects() on 2 FDs, so not a huge deal.
nanosleep() only uses it for the timeout, so also not a huge deal.

socketpair() is SUSv3 (2001) and nanosleep() is SUSv2 (1997), so maybe
it's OK to remove those emulations.  If so, then we can also remove the
sys/select.h check in configure.ac
This commit is contained in:
jailbird777 2021-06-25 02:21:02 -05:00 committed by Ed Kellett
parent 81531536aa
commit e370888264
3 changed files with 0 additions and 303 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
librb/src/Makefile.am
View file

@ -33,7 +33,6 @@ librb_la_SOURCES = \
poll.c \ poll.c \
ports.c \ ports.c \
sigio.c \ sigio.c \
select.c \
kqueue.c \ kqueue.c \
rawbuf.c \ rawbuf.c \
patricia.c \ patricia.c \

26
librb/src/commio.c
View file

@ -2215,25 +2215,6 @@ try_win32(void)
return -1; return -1;
} }
static int
try_select(void)
{
if(!rb_init_netio_select())
{
setselect_handler = rb_setselect_select;
select_handler = rb_select_select;
setup_fd_handler = rb_setup_fd_select;
io_sched_event = NULL;
io_unsched_event = NULL;
io_init_event = NULL;
io_supports_event = rb_unsupported_event;
rb_strlcpy(iotype, "select", sizeof(iotype));
return 0;
}
return -1;
}
int int
rb_io_sched_event(struct ev_entry *ev, int when) rb_io_sched_event(struct ev_entry *ev, int when)
{ {
@ -2306,11 +2287,6 @@ rb_init_netio(void)
if(!try_sigio()) if(!try_sigio())
return; return;
} }
else if(!strcmp("select", ioenv))
{
if(!try_select())
return;
}
if(!strcmp("win32", ioenv)) if(!strcmp("win32", ioenv))
{ {
if(!try_win32()) if(!try_win32())
@ -2333,8 +2309,6 @@ rb_init_netio(void)
return; return;
if(!try_win32()) if(!try_win32())
return; return;
if(!try_select())
return;
rb_lib_log("rb_init_netio: Could not find any io handlers...giving up"); rb_lib_log("rb_init_netio: Could not find any io handlers...giving up");

276
librb/src/select.c
View file

@ -1,276 +0,0 @@
/*
* ircd-ratbox: A slightly useful ircd.
* select.c: select() compatible network routines.
*
* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
* Copyright (C) 1996-2002 Hybrid Development Team
* Copyright (C) 2001 Adrian Chadd <adrian@creative.net.au>
* Copyright (C) 2002-2005 ircd-ratbox development team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
* USA
*
*/
#define FD_SETSIZE 65535
#include <librb_config.h>
#include <rb_lib.h>
#include <commio-int.h>
#if defined(HAVE_SELECT) || defined(_WIN32)
#ifdef _WIN32
#define MY_FD_SET(x, y) FD_SET((SOCKET)x, y)
#define MY_FD_CLR(x, y) FD_CLR((SOCKET)x, y)
#else
#define MY_FD_SET(x, y) FD_SET(x, y)
#define MY_FD_CLR(x, y) FD_CLR(x, y)
#endif
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
/*
* Note that this is only a single list - multiple lists is kinda pointless
* under select because the list size is a function of the highest FD :-)
* -- adrian
*/
static fd_set select_readfds;
static fd_set select_writefds;
/*
* You know, I'd rather have these local to rb_select but for some
* reason my gcc decides that I can't modify them at all..
* -- adrian
*/
static fd_set tmpreadfds;
static fd_set tmpwritefds;
static int rb_maxfd = -1;
static void select_update_selectfds(rb_fde_t *F, short event, PF * handler);
/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
/* Private functions */
/*
* set and clear entries in the select array ..
*/
static void
select_update_selectfds(rb_fde_t *F, short event, PF * handler)
{
/* Update the read / write set */
if(event & RB_SELECT_READ)
{
if(handler)
{
MY_FD_SET(F->fd, &select_readfds);
F->pflags |= RB_SELECT_READ;
}
else
{
MY_FD_CLR(F->fd, &select_readfds);
F->pflags &= ~RB_SELECT_READ;
}
}
if(event & RB_SELECT_WRITE)
{
if(handler)
{
MY_FD_SET(F->fd, &select_writefds);
F->pflags |= RB_SELECT_WRITE;
}
else
{
MY_FD_CLR(F->fd, &select_writefds);
F->pflags &= ~RB_SELECT_WRITE;
}
}
if(F->pflags & (RB_SELECT_READ | RB_SELECT_WRITE))
{
if(F->fd > rb_maxfd)
{
rb_maxfd = F->fd;
}
}
else if(F->fd <= rb_maxfd)
{
while(rb_maxfd >= 0 && !FD_ISSET(rb_maxfd, &select_readfds)
&& !FD_ISSET(rb_maxfd, &select_writefds))
rb_maxfd--;
}
}
/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
/* Public functions */
int
rb_setup_fd_select(rb_fde_t *F __attribute__((unused)))
{
return 0;
}
/*
* rb_init_netio
*
* This is a needed exported function which will be called to initialise
* the network loop code.
*/
extern int rb_maxconnections;
int
rb_init_netio_select(void)
{
if(rb_maxconnections > FD_SETSIZE)
rb_maxconnections = FD_SETSIZE; /* override this */
FD_ZERO(&select_readfds);
FD_ZERO(&select_writefds);
return 0;
}
/*
* rb_setselect
*
* This is a needed exported function which will be called to register
* and deregister interest in a pending IO state for a given FD.
*/
void
rb_setselect_select(rb_fde_t *F, unsigned int type, PF * handler, void *client_data)
{
lrb_assert(IsFDOpen(F));
if(type & RB_SELECT_READ)
{
F->read_handler = handler;
F->read_data = client_data;
select_update_selectfds(F, RB_SELECT_READ, handler);
}
if(type & RB_SELECT_WRITE)
{
F->write_handler = handler;
F->write_data = client_data;
select_update_selectfds(F, RB_SELECT_WRITE, handler);
}
}
/*
* Check all connections for new connections and input data that is to be
* processed. Also check for connections with data queued and whether we can
* write it out.
*/
/*
* rb_select
*
* Do IO events
*/
int
rb_select_select(long delay)
{
int num;
int fd;
PF *hdl;
rb_fde_t *F;
struct timeval to;
/* Copy over the read/write sets so we don't have to rebuild em */
memcpy(&tmpreadfds, &select_readfds, sizeof(fd_set));
memcpy(&tmpwritefds, &select_writefds, sizeof(fd_set));
for(;;)
{
to.tv_sec = 0;
to.tv_usec = delay * 1000;
num = select(rb_maxfd + 1, &tmpreadfds, &tmpwritefds, NULL, &to);
if(num >= 0)
break;
if(rb_ignore_errno(errno))
continue;
rb_set_time();
/* error! */
return -1;
/* NOTREACHED */
}
rb_set_time();
if(num == 0)
return 0;
/* XXX we *could* optimise by falling out after doing num fds ... */
for(fd = 0; fd < rb_maxfd + 1; fd++)
{
F = rb_find_fd(fd);
if(F == NULL)
continue;
if(FD_ISSET(fd, &tmpreadfds))
{
hdl = F->read_handler;
F->read_handler = NULL;
if(hdl)
hdl(F, F->read_data);
}
if(!IsFDOpen(F))
continue; /* Read handler closed us..go on */
if(FD_ISSET(fd, &tmpwritefds))
{
hdl = F->write_handler;
F->write_handler = NULL;
if(hdl)
hdl(F, F->write_data);
}
if(F->read_handler == NULL)
select_update_selectfds(F, RB_SELECT_READ, NULL);
if(F->write_handler == NULL)
select_update_selectfds(F, RB_SELECT_WRITE, NULL);
}
return 0;
}
#else /* select not supported..what sort of garbage is this? */
int
rb_init_netio_select(void)
{
return ENOSYS;
}
void
rb_setselect_select(rb_fde_t *F __attribute__((unused)), unsigned int type __attribute__((unused)), PF * handler __attribute__((unused)), void *client_data __attribute__((unused)))
{
errno = ENOSYS;
return;
}
int
rb_select_select(long delay __attribute__((unused)))
{
errno = ENOSYS;
return -1;
}
int
rb_setup_fd_select(rb_fde_t *F __attribute__((unused)))
{
errno = ENOSYS;
return -1;
}
#endif