From 0d47952611198ef6b1163f366dc03922d20b1475 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 09:42:04 +0200 Subject: Adding upstream version 7.94+git20230807.3be01efb1+dfsg. Signed-off-by: Daniel Baumann --- nsock/src/engine_select.c | 395 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 395 insertions(+) create mode 100644 nsock/src/engine_select.c (limited to 'nsock/src/engine_select.c') diff --git a/nsock/src/engine_select.c b/nsock/src/engine_select.c new file mode 100644 index 0000000..edf1b3d --- /dev/null +++ b/nsock/src/engine_select.c @@ -0,0 +1,395 @@ +/*************************************************************************** + * engine_select.c -- select(2) based IO engine. * + * * + ***********************IMPORTANT NSOCK LICENSE TERMS*********************** + * + * The nsock parallel socket event library is (C) 1999-2023 Nmap Software LLC + * This library is free software; you may redistribute and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation; Version 2. This guarantees your right to use, modify, and + * redistribute this software under certain conditions. If this license is + * unacceptable to you, Nmap Software LLC may be willing to sell alternative + * licenses (contact sales@nmap.com ). + * + * As a special exception to the GPL terms, Nmap Software LLC grants permission + * to link the code of this program with any version of the OpenSSL library + * which is distributed under a license identical to that listed in the included + * docs/licenses/OpenSSL.txt file, and distribute linked combinations including + * the two. You must obey the GNU GPL in all respects for all of the code used + * other than OpenSSL. If you modify this file, you may extend this exception to + * your version of the file, but you are not obligated to do so. + * + * If you received these files with a written license agreement stating terms + * other than the (GPL) terms above, then that alternative license agreement + * takes precedence over this comment. + * + * Source is provided to this software because we believe users have a right to + * know exactly what a program is going to do before they run it. This also + * allows you to audit the software for security holes. + * + * Source code also allows you to port Nmap to new platforms, fix bugs, and add + * new features. You are highly encouraged to send your changes to the + * dev@nmap.org mailing list for possible incorporation into the main + * distribution. By sending these changes to Fyodor or one of the Insecure.Org + * development mailing lists, or checking them into the Nmap source code + * repository, it is understood (unless you specify otherwise) that you are + * offering the Nmap Project (Nmap Software LLC) the unlimited, non-exclusive + * right to reuse, modify, and relicense the code. Nmap will always be available + * Open Source, but this is important because the inability to relicense code + * has caused devastating problems for other Free Software projects (such as KDE + * and NASM). We also occasionally relicense the code to third parties as + * discussed above. If you wish to specify special license conditions of your + * contributions, just say so when you send them. + * + * 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 v2.0 for more + * details (http://www.gnu.org/licenses/gpl-2.0.html). + * + ***************************************************************************/ + +/* $Id$ */ + +#ifndef WIN32 +#include +#endif + +#include + +#include "nsock_internal.h" +#include "nsock_log.h" + +#if HAVE_PCAP +#include "nsock_pcap.h" +#endif + +extern struct io_operations posix_io_operations; + + +/* --- ENGINE INTERFACE PROTOTYPES --- */ +static int select_init(struct npool *nsp); +static void select_destroy(struct npool *nsp); +static int select_iod_register(struct npool *nsp, struct niod *iod, struct nevent *nse, int ev); +static int select_iod_unregister(struct npool *nsp, struct niod *iod); +static int select_iod_modify(struct npool *nsp, struct niod *iod, struct nevent *nse, int ev_set, int ev_clr); +static int select_loop(struct npool *nsp, int msec_timeout); + + +/* ---- ENGINE DEFINITION ---- */ +struct io_engine engine_select = { + "select", + select_init, + select_destroy, + select_iod_register, + select_iod_unregister, + select_iod_modify, + select_loop, + &posix_io_operations +}; + + +/* --- INTERNAL PROTOTYPES --- */ +static void iterate_through_event_lists(struct npool *nsp); + +/* defined in nsock_core.c */ +void process_event(struct npool *nsp, gh_list_t *evlist, struct nevent *nse, int ev); +void process_iod_events(struct npool *nsp, struct niod *nsi, int ev); +void process_expired_events(struct npool *nsp); + +#if HAVE_PCAP +#ifndef PCAP_CAN_DO_SELECT +int pcap_read_on_nonselect(struct npool *nsp); +#endif +#endif + +/* defined in nsock_event.c */ +void update_first_events(struct nevent *nse); + + +extern struct timeval nsock_tod; + + +/* + * Engine specific data structure + */ +struct select_engine_info { + /* Descriptors which have pending READ events */ + fd_set fds_master_r; + + /* Descriptors we are trying to WRITE to */ + fd_set fds_master_w; + + /* Looking for exceptional events -- used with connect */ + fd_set fds_master_x; + + /* For keeping track of the select results */ + fd_set fds_results_r, fds_results_w, fds_results_x; + + /* The highest sd we have set in any of our fd_set's (max_sd + 1 is used in + * select() calls). Note that it can be -1, when there are no valid sockets */ + int max_sd; +}; + + +int select_init(struct npool *nsp) { + struct select_engine_info *sinfo; + + sinfo = (struct select_engine_info *)safe_malloc(sizeof(struct select_engine_info)); + + FD_ZERO(&sinfo->fds_master_r); + FD_ZERO(&sinfo->fds_master_w); + FD_ZERO(&sinfo->fds_master_x); + + sinfo->max_sd = -1; + + nsp->engine_data = (void *)sinfo; + + return 1; +} + +void select_destroy(struct npool *nsp) { + assert(nsp->engine_data != NULL); + free(nsp->engine_data); +} + +int select_iod_register(struct npool *nsp, struct niod *iod, struct nevent *nse, int ev) { + assert(!IOD_PROPGET(iod, IOD_REGISTERED)); + + iod->watched_events = ev; + select_iod_modify(nsp, iod, nse, ev, EV_NONE); + IOD_PROPSET(iod, IOD_REGISTERED); + return 1; +} + +int select_iod_unregister(struct npool *nsp, struct niod *iod) { + struct select_engine_info *sinfo = (struct select_engine_info *)nsp->engine_data; + + iod->watched_events = EV_NONE; + + /* some IODs can be unregistered here if they're associated to an event that was + * immediately completed */ + if (IOD_PROPGET(iod, IOD_REGISTERED)) { +#if HAVE_PCAP + if (iod->pcap) { + int sd = ((mspcap *)iod->pcap)->pcap_desc; + if (sd >= 0) { + checked_fd_clr(sd, &sinfo->fds_master_r); + checked_fd_clr(sd, &sinfo->fds_results_r); + } + } else +#endif + { + checked_fd_clr(iod->sd, &sinfo->fds_master_r); + checked_fd_clr(iod->sd, &sinfo->fds_master_w); + checked_fd_clr(iod->sd, &sinfo->fds_master_x); + checked_fd_clr(iod->sd, &sinfo->fds_results_r); + checked_fd_clr(iod->sd, &sinfo->fds_results_w); + checked_fd_clr(iod->sd, &sinfo->fds_results_x); + } + + if (sinfo->max_sd == iod->sd) + sinfo->max_sd--; + + IOD_PROPCLR(iod, IOD_REGISTERED); + } + return 1; +} + +int select_iod_modify(struct npool *nsp, struct niod *iod, struct nevent *nse, int ev_set, int ev_clr) { + int sd; + struct select_engine_info *sinfo = (struct select_engine_info *)nsp->engine_data; + + assert((ev_set & ev_clr) == 0); + + iod->watched_events |= ev_set; + iod->watched_events &= ~ev_clr; + + ev_set |= EV_EXCEPT; + ev_clr &= ~EV_EXCEPT; + + sd = nsock_iod_get_sd(iod); + + /* -- set events -- */ + if (ev_set & EV_READ) + checked_fd_set(sd, &sinfo->fds_master_r); + + if (ev_set & EV_WRITE) + checked_fd_set(sd, &sinfo->fds_master_w); + + if (ev_set & EV_EXCEPT) + checked_fd_set(sd, &sinfo->fds_master_x); + + /* -- clear events -- */ + if (ev_clr & EV_READ) + checked_fd_clr(sd, &sinfo->fds_master_r); + + if (ev_clr & EV_WRITE) + checked_fd_clr(sd, &sinfo->fds_master_w); + + if (ev_clr & EV_EXCEPT) + checked_fd_clr(sd, &sinfo->fds_master_x); + + + /* -- update max_sd -- */ + if (ev_set != EV_NONE) + sinfo->max_sd = MAX(sinfo->max_sd, sd); + else if (ev_clr != EV_NONE && iod->events_pending == 1 && (sinfo->max_sd == sd)) + sinfo->max_sd--; + + return 1; +} + +int select_loop(struct npool *nsp, int msec_timeout) { + int results_left = 0; + int event_msecs; /* msecs before an event goes off */ + int combined_msecs; + int sock_err = 0; + struct timeval select_tv; + struct timeval *select_tv_p; + struct select_engine_info *sinfo = (struct select_engine_info *)nsp->engine_data; + + assert(msec_timeout >= -1); + + if (nsp->events_pending == 0) + return 0; /* No need to wait on 0 events ... */ + + do { + struct nevent *nse; + + nsock_log_debug_all("wait for events"); + + nse = next_expirable_event(nsp); + if (!nse) + event_msecs = -1; /* None of the events specified a timeout */ + else + event_msecs = MAX(0, TIMEVAL_MSEC_SUBTRACT(nse->timeout, nsock_tod)); + +#if HAVE_PCAP +#ifndef PCAP_CAN_DO_SELECT + /* Force a low timeout when capturing packets on systems where + * the pcap descriptor is not select()able. */ + if (gh_list_count(&nsp->pcap_read_events)) + if (event_msecs > PCAP_POLL_INTERVAL) + event_msecs = PCAP_POLL_INTERVAL; +#endif +#endif + + /* We cast to unsigned because we want -1 to be very high (since it means no + * timeout) */ + combined_msecs = MIN((unsigned)event_msecs, (unsigned)msec_timeout); + + /* Set up the timeval pointer we will give to select() */ + memset(&select_tv, 0, sizeof(select_tv)); + if (combined_msecs > 0) { + select_tv.tv_sec = combined_msecs / 1000; + select_tv.tv_usec = (combined_msecs % 1000) * 1000; + select_tv_p = &select_tv; + } else if (combined_msecs == 0) { + /* we want the tv_sec and tv_usec to be zero but they already are from bzero */ + select_tv_p = &select_tv; + } else { + assert(combined_msecs == -1); + select_tv_p = NULL; + } + +#if HAVE_PCAP +#ifndef PCAP_CAN_DO_SELECT + /* do non-blocking read on pcap devices that doesn't support select() + * If there is anything read, just leave this loop. */ + if (pcap_read_on_nonselect(nsp)) { + /* okay, something was read. */ + } else +#endif +#endif + { + /* Set up the descriptors for select */ + sinfo->fds_results_r = sinfo->fds_master_r; + sinfo->fds_results_w = sinfo->fds_master_w; + sinfo->fds_results_x = sinfo->fds_master_x; + + results_left = fselect(sinfo->max_sd + 1, &sinfo->fds_results_r, + &sinfo->fds_results_w, &sinfo->fds_results_x, select_tv_p); + + if (results_left == -1) + sock_err = socket_errno(); + } + + gettimeofday(&nsock_tod, NULL); /* Due to select delay */ + } while (results_left == -1 && sock_err == EINTR); /* repeat only if signal occurred */ + + if (results_left == -1 && sock_err != EINTR) { + nsock_log_error("nsock_loop error %d: %s", sock_err, socket_strerror(sock_err)); + nsp->errnum = sock_err; + return -1; + } + + iterate_through_event_lists(nsp); + + return 1; +} + + +/* ---- INTERNAL FUNCTIONS ---- */ + +static inline int get_evmask(const struct npool *nsp, const struct niod *nsi) { + struct select_engine_info *sinfo = (struct select_engine_info *)nsp->engine_data; + int sd, evmask; + + evmask = EV_NONE; + +#if HAVE_PCAP +#ifndef PCAP_CAN_DO_SELECT + if (nsi->pcap) { + /* Always assume readable for a non-blocking read. We can't check checked_fd_isset + because we don't have a pcap_desc. */ + evmask |= EV_READ; + return evmask; + } +#endif +#endif + +#if HAVE_PCAP + if (nsi->pcap) + sd = ((mspcap *)nsi->pcap)->pcap_desc; + else +#endif + sd = nsi->sd; + + assert(sd >= 0); + + if (checked_fd_isset(sd, &sinfo->fds_results_r)) + evmask |= EV_READ; + if (checked_fd_isset(sd, &sinfo->fds_results_w)) + evmask |= EV_WRITE; + if (checked_fd_isset(sd, &sinfo->fds_results_x)) + evmask |= EV_EXCEPT; + + return evmask; +} + +/* Iterate through all the event lists (such as connect_events, read_events, + * timer_events, etc) and take action for those that have completed (due to + * timeout, i/o, etc) */ +void iterate_through_event_lists(struct npool *nsp) { + gh_lnode_t *current, *next, *last; + + last = gh_list_last_elem(&nsp->active_iods); + + for (current = gh_list_first_elem(&nsp->active_iods); + current != NULL && gh_lnode_prev(current) != last; + current = next) { + struct niod *nsi = container_of(current, struct niod, nodeq); + + if (nsi->state != NSIOD_STATE_DELETED && nsi->events_pending) + process_iod_events(nsp, nsi, get_evmask(nsp, nsi)); + + next = gh_lnode_next(current); + if (nsi->state == NSIOD_STATE_DELETED) { + gh_list_remove(&nsp->active_iods, current); + gh_list_prepend(&nsp->free_iods, current); + } + } + + /* iterate through timers and expired events */ + process_expired_events(nsp); +} -- cgit v1.2.3