github/amiga-clib2
1
0
Fork 0
mirror of https://github.com/adtools/clib2.git synced 2025-12-08 14:59:05 +00:00
Code Issues Releases Wiki Activity
Files
0fad53e56e87189f9e3361355bfbff607bde3cdb
amiga-clib2/library/socket_select.c
Olaf Barthel c799b17bb9 - Extended the thread-safety locking to the file descriptors. 
git-svn-id: file:///Users/olsen/Code/migration-svn-zu-git/logical-line-staging/clib2/trunk@14844 87f5fb63-7c3d-0410-a384-fd976d0f7a62
2005-02-28 13:22:53 +00:00

1023 lines
23 KiB
C
Raw Blame History

/*
* $Id: socket_select.c,v 1.7 2005-02-28 13:22:53 obarthel Exp $
*
* :ts=4
*
* Portable ISO 'C' (1994) runtime library for the Amiga computer
* Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Neither the name of Olaf Barthel nor the names of contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#if defined(SOCKET_SUPPORT)
/****************************************************************************/
#ifndef _STDLIB_MEM_DEBUG_H
#include "stdlib_mem_debug.h"
#endif /* _STDLIB_MEM_DEBUG_H */
/****************************************************************************/
#ifndef _SOCKET_HEADERS_H
#include "socket_headers.h"
#endif /* _SOCKET_HEADERS_H */
/****************************************************************************/
STATIC VOID
copy_fd_set(fd_set * to,fd_set * from,int num_fds)
{
ENTER();
SHOWPOINTER(to);
SHOWPOINTER(from);
SHOWVALUE(num_fds);
if(to != NULL && from != NULL && num_fds > 0)
{
size_t num_bytes;
num_bytes = sizeof(unsigned long) * ((num_fds + 31) / 32);
SHOWVALUE(num_bytes);
memmove(to,from,num_bytes);
}
LEAVE();
}
/****************************************************************************/
STATIC VOID
zero_fd_set(fd_set * set,int num_fds)
{
ENTER();
SHOWPOINTER(set);
SHOWVALUE(num_fds);
if(set != NULL && num_fds > 0)
{
size_t num_bytes;
num_bytes = sizeof(unsigned long) * ((num_fds + 31) / 32);
SHOWVALUE(num_bytes);
memset(set,0,num_bytes);
}
LEAVE();
}
/****************************************************************************/
STATIC fd_set *
allocate_fd_set(int num_fds,fd_set * duplicate_this_set)
{
fd_set * result = NULL;
size_t num_bytes;
fd_set * set;
ENTER();
assert( num_fds > 0 );
SHOWVALUE(num_fds);
num_bytes = sizeof(unsigned long) * ((num_fds + 31) / 32);
SHOWVALUE(num_bytes);
set = (fd_set *)malloc(num_bytes);
if(set != NULL)
{
if(duplicate_this_set != NULL)
copy_fd_set(set,duplicate_this_set,num_fds);
else
zero_fd_set(set,num_fds);
result = set;
}
RETURN(result);
return(result);
}
/****************************************************************************/
STATIC VOID
free_fd_set(fd_set * set)
{
if(set != NULL)
free(set);
}
/****************************************************************************/
STATIC struct fd *
get_file_descriptor(int file_descriptor)
{
struct fd * result = NULL;
struct fd * fd;
__stdio_lock();
if(file_descriptor < 0 || file_descriptor >= __num_fd)
goto out;
assert( __fd != NULL );
fd = __fd[file_descriptor];
assert( fd != NULL );
if(FLAG_IS_CLEAR(fd->fd_Flags,FDF_IN_USE))
goto out;
result = fd;
out:
__stdio_unlock();
return(result);
}
/****************************************************************************/
STATIC VOID
fix_datestamp(struct DateStamp * ds)
{
const LONG ticks_per_minute = 60 * TICKS_PER_SECOND;
const LONG minutes_per_day = 24 * 60;
assert( ds != NULL );
while(ds->ds_Minute >= minutes_per_day ||
ds->ds_Tick >= ticks_per_minute)
{
if(ds->ds_Minute >= minutes_per_day)
{
ds->ds_Days++;
ds->ds_Minute -= minutes_per_day;
}
if(ds->ds_Tick >= ticks_per_minute)
{
ds->ds_Minute++;
ds->ds_Tick -= ticks_per_minute;
}
}
}
/****************************************************************************/
STATIC struct DateStamp *
timeval_to_datestamp(struct DateStamp * ds,const struct timeval * tv)
{
assert( ds != NULL && tv != NULL );
ds->ds_Days = (tv->tv_secs / (24 * 60 * 60));
ds->ds_Minute = (tv->tv_secs % (24 * 60 * 60)) / 60;
ds->ds_Tick = (tv->tv_secs % 60) * TICKS_PER_SECOND + (TICKS_PER_SECOND * tv->tv_micro) / 1000000;
fix_datestamp(ds);
return(ds);
}
/****************************************************************************/
STATIC VOID
add_dates(struct DateStamp * to,const struct DateStamp * from)
{
assert( to != NULL && from != NULL );
to->ds_Tick += from->ds_Tick;
to->ds_Minute += from->ds_Minute;
to->ds_Days += from->ds_Days;
fix_datestamp(to);
}
/****************************************************************************/
STATIC VOID
map_descriptor_sets(
const fd_set * input_fds,
int num_input_fds,
fd_set * socket_fds,
int num_socket_fds,
int * total_socket_fd_ptr,
fd_set * file_fds,
int num_file_fds,
int * total_file_fd_ptr)
{
ENTER();
SHOWPOINTER(input_fds);
SHOWVALUE(num_input_fds);
SHOWPOINTER(socket_fds);
SHOWVALUE(num_socket_fds);
SHOWPOINTER(file_fds);
SHOWVALUE(num_file_fds);
/* This routine maps file descriptor sets
* from one format to another. We map
* socket descriptors and regular file
* descriptor sets.
*/
if(input_fds != NULL && num_input_fds > 0)
{
int total_socket_fd;
int total_file_fd;
struct fd * fd;
int file_fd;
total_socket_fd = (*total_socket_fd_ptr);
total_file_fd = (*total_file_fd_ptr);
SHOWVALUE(total_socket_fd);
SHOWVALUE(total_file_fd);
for(file_fd = 0 ; file_fd < num_input_fds ; file_fd++)
{
if(NOT FD_ISSET(file_fd,input_fds))
continue;
D(("descriptor %ld is set",file_fd));
fd = get_file_descriptor(file_fd);
if(fd == NULL)
{
SHOWMSG("but no file is attached to it");
continue;
}
/* Is this a socket descriptor? */
if(FLAG_IS_SET(fd->fd_Flags,FDF_IS_SOCKET))
{
int socket_fd = (int)fd->fd_DefaultFile;
D(("corresponds to socket #%ld",socket_fd));
if(socket_fds != NULL && socket_fd < num_socket_fds)
{
SHOWMSG("setting it");
FD_SET(socket_fd,socket_fds);
if(total_socket_fd < socket_fd+1)
total_socket_fd = socket_fd+1;
}
else
{
SHOWMSG("can't set it, though");
}
}
else
{
/* We only watch files bound to console streams. */
if(FLAG_IS_CLEAR(fd->fd_Flags,FDF_IS_INTERACTIVE))
{
SHOWMSG("this is a file");
continue;
}
SHOWMSG("this is an interactive stream");
if(file_fds != NULL && file_fd < num_file_fds)
{
SHOWMSG("setting it");
FD_SET(file_fd,file_fds);
if(total_file_fd < file_fd+1)
total_file_fd = file_fd+1;
}
else
{
SHOWMSG("can't set it, though");
}
}
}
(*total_socket_fd_ptr) = total_socket_fd;
(*total_file_fd_ptr) = total_file_fd;
SHOWVALUE(total_socket_fd);
SHOWVALUE(total_file_fd);
}
LEAVE();
}
/****************************************************************************/
STATIC VOID
remap_descriptor_sets(
const fd_set * socket_fds,
int num_socket_fds,
const fd_set * file_fds,
int num_file_fds,
fd_set * output_fds,
int num_output_fds)
{
ENTER();
SHOWPOINTER(socket_fds);
SHOWVALUE(num_socket_fds);
SHOWPOINTER(file_fds);
SHOWVALUE(num_file_fds);
SHOWPOINTER(output_fds);
SHOWVALUE(num_output_fds);
/* This routine reverses the mapping established
* above. We map the file and socket descriptor
* sets back into the original set.
*/
if(output_fds != NULL && num_output_fds > 0)
{
zero_fd_set(output_fds,num_output_fds);
if(socket_fds != NULL && num_socket_fds > 0)
{
struct fd * fd;
int output_fd;
int socket_fd;
SHOWMSG("taking care of the sockets");
for(socket_fd = 0 ; socket_fd < num_socket_fds ; socket_fd++)
{
if(NOT FD_ISSET(socket_fd,socket_fds))
continue;
for(output_fd = 0 ; output_fd < num_output_fds ; output_fd++)
{
fd = get_file_descriptor(output_fd);
if(fd != NULL && FLAG_IS_SET(fd->fd_Flags,FDF_IS_SOCKET) && (int)fd->fd_DefaultFile == socket_fd)
{
assert( output_fd < num_output_fds );
assert( FLAG_IS_SET(__fd[output_fd]->fd_Flags,FDF_IS_SOCKET) );
D(("setting file %ld for socket #%ld",output_fd,socket_fd));
FD_SET(output_fd,output_fds);
}
}
}
}
if(file_fds != NULL && num_file_fds > 0)
{
int file_fd;
SHOWMSG("taking care of the files");
for(file_fd = 0 ; file_fd < num_file_fds ; file_fd++)
{
if(FD_ISSET(file_fd,file_fds))
{
int output_fd = file_fd;
assert( output_fd < num_output_fds );
assert( FLAG_IS_CLEAR(__fd[output_fd]->fd_Flags,FDF_IS_SOCKET) );
D(("setting file %ld",file_fd));
FD_SET(output_fd,output_fds);
}
}
}
}
else
{
SHOWMSG("no output necessary");
}
LEAVE();
}
/****************************************************************************/
STATIC VOID
get_num_descriptors_used(int num_fds,int * num_socket_used_ptr,int * num_file_used_ptr)
{
int num_socket_used = 0;
int num_file_used = 0;
int which_file_fd;
struct fd * fd;
assert( num_socket_used_ptr != NULL );
assert( num_file_used_ptr != NULL );
SHOWMSG("figuring out which file descriptors are in use");
for(which_file_fd = 0 ; which_file_fd < num_fds ; which_file_fd++)
{
fd = get_file_descriptor(which_file_fd);
if(fd != NULL)
{
if(FLAG_IS_SET(fd->fd_Flags,FDF_IS_SOCKET))
{
int which_socket_fd = (int)fd->fd_DefaultFile;
if(num_socket_used < which_socket_fd+1)
num_socket_used = which_socket_fd+1;
}
else
{
if(num_file_used < which_file_fd+1)
num_file_used = which_file_fd+1;
}
}
}
(*num_socket_used_ptr) = num_socket_used;
(*num_file_used_ptr) = num_file_used;
}
/****************************************************************************/
int
select(int num_fds,fd_set *read_fds,fd_set *write_fds,fd_set *except_fds,struct timeval *timeout)
{
fd_set * backup_socket_read_fds = NULL;
fd_set * backup_socket_write_fds = NULL;
fd_set * backup_socket_except_fds = NULL;
fd_set * backup_file_read_fds = NULL;
fd_set * backup_file_write_fds = NULL;
fd_set * socket_read_fds = NULL;
fd_set * socket_write_fds = NULL;
fd_set * socket_except_fds = NULL;
int total_socket_fd;
fd_set * file_read_fds = NULL;
fd_set * file_write_fds = NULL;
int total_file_fd;
struct fd * fd;
int result = -1;
int num_socket_used;
int num_file_used;
int i;
ENTER();
SHOWVALUE(num_fds);
SHOWPOINTER(read_fds);
SHOWPOINTER(write_fds);
SHOWPOINTER(except_fds);
SHOWPOINTER(timeout);
if(timeout != NULL)
{
SHOWVALUE(timeout->tv_secs);
SHOWVALUE(timeout->tv_micro);
}
assert(__SocketBase != NULL);
if(__check_abort_enabled)
__check_abort();
/* Figure out the number of file and socket descriptors in use. */
get_num_descriptors_used(num_fds,&num_socket_used,&num_file_used);
SHOWVALUE(num_socket_used);
SHOWVALUE(num_file_used);
/* Dynamically allocate the tables to keep track of which descriptor
* is ready for I/O.
*/
if(read_fds != NULL)
{
if(num_socket_used > 0)
{
SHOWMSG("allocating read socket fd_set");
socket_read_fds = allocate_fd_set(num_socket_used,NULL);
if(socket_read_fds == NULL)
goto out;
}
if(num_file_used > 0)
{
SHOWMSG("allocating read file fd_set");
file_read_fds = allocate_fd_set(num_file_used,NULL);
if(file_read_fds == NULL)
goto out;
}
}
if(write_fds != NULL)
{
if(num_socket_used > 0)
{
SHOWMSG("allocating write socket fd_set");
socket_write_fds = allocate_fd_set(num_socket_used,NULL);
if(socket_write_fds == NULL)
goto out;
}
if(num_file_used > 0)
{
SHOWMSG("allocating write file fd_set");
file_write_fds = allocate_fd_set(num_file_used,NULL);
if(file_write_fds == NULL)
goto out;
}
}
if(except_fds != NULL)
{
if(num_socket_used > 0)
{
SHOWMSG("allocating except socket fd_set");
socket_except_fds = allocate_fd_set(num_socket_used,NULL);
if(socket_except_fds == NULL)
goto out;
}
}
total_socket_fd = 0;
total_file_fd = 0;
SHOWMSG("mapping the fd_sets");
/* Translate from the tables the caller provided to us
* to the local copies, which take the files and sockets
* into account.
*/
__stdio_lock();
map_descriptor_sets(read_fds, num_fds, socket_read_fds, num_socket_used, &total_socket_fd, file_read_fds, num_file_used, &total_file_fd);
map_descriptor_sets(write_fds, num_fds, socket_write_fds, num_socket_used, &total_socket_fd, file_write_fds, num_file_used, &total_file_fd);
map_descriptor_sets(except_fds, num_fds, socket_except_fds, num_socket_used, &total_socket_fd, NULL, 0, &total_file_fd);
__stdio_unlock();
/* Wait for socket input? */
if(total_socket_fd > 0)
{
SHOWMSG("we have to deal with sockets");
/* Wait for file input, too? */
if((total_file_fd > 0) && (timeout == NULL || timeout->tv_secs > 0 || timeout->tv_micro > 0))
{
struct DateStamp stop_when;
struct timeval zero;
ULONG break_mask;
BOOL got_input;
BOOL got_output;
SHOWMSG("we also have to deal with files");
/* We may poll the sockets and files several times in a row.
* The results stored in the tables can tell only a single
* story, though. This is why we need to keep a backup copy
* of each table around, to be used for each iteration of
* the loop in which the sockets and files are checked.
*/
if(read_fds != NULL)
{
if(num_socket_used > 0)
{
SHOWMSG("allocating backup read socket fd_set");
backup_socket_read_fds = allocate_fd_set(num_socket_used,socket_read_fds);
if(backup_socket_read_fds == NULL)
goto out;
}
if(num_file_used > 0)
{
SHOWMSG("allocating backup read file fd_set");
backup_file_read_fds = allocate_fd_set(num_file_used,file_read_fds);
if(backup_file_read_fds == NULL)
goto out;
}
}
if(write_fds != NULL)
{
if(num_socket_used > 0)
{
SHOWMSG("allocating backup write socket fd_set");
backup_socket_write_fds = allocate_fd_set(num_socket_used,socket_write_fds);
if(backup_socket_write_fds == NULL)
goto out;
}
if(num_file_used > 0)
{
SHOWMSG("allocating backup write file fd_set");
backup_file_write_fds = allocate_fd_set(num_file_used,file_write_fds);
if(backup_file_write_fds == NULL)
goto out;
}
}
if(except_fds != NULL)
{
if(num_socket_used > 0)
{
SHOWMSG("allocating backup except socket fd_set");
backup_socket_except_fds = allocate_fd_set(num_socket_used,socket_except_fds);
if(backup_socket_except_fds == NULL)
goto out;
}
}
/* We are going to poll all streams; for the timeout
* feature to work, we absolutely must know when to
* stop polling.
*
* Why aren't we using asynchronous DOS packets?
* The answer is that once a packet is sent, you
* cannot easily abort it. Polling is safer in
* that respect. Yes, I know that ACTION_STACK
* can be used to fake input to a console stream,
* but I'd rather not rely upon it.
*/
if(timeout != NULL)
{
struct DateStamp datestamp_timeout;
PROFILE_OFF();
DateStamp(&stop_when);
PROFILE_ON();
add_dates(&stop_when,timeval_to_datestamp(&datestamp_timeout,timeout));
}
else
{
/* No timeout, poll until we are interrupted
* or get input from any of the files. It's
* not really necessary to initialize this
* timeval, but it keeps the compiler happy.
*/
memset(&stop_when,0,sizeof(stop_when));
}
while(TRUE)
{
/* Check for break signal. */
if(__check_abort_enabled)
__check_abort();
/* Delay for a tick to avoid busy-waiting. */
PROFILE_OFF();
Delay(1);
PROFILE_ON();
/* This tells WaitSelect() to poll the sockets for input. */
zero.tv_secs = 0;
zero.tv_micro = 0;
/* Signals to stop on; we want to stop when a break signal arrives. */
if(__check_abort_enabled)
break_mask = SIGBREAKF_CTRL_C;
else
break_mask = 0;
/* Check for socket input. */
PROFILE_OFF();
result = __WaitSelect(total_socket_fd,socket_read_fds,socket_write_fds,socket_except_fds,&zero,&break_mask);
PROFILE_ON();
/* Stop if a break signal arrives. */
if((result < 0 && __get_errno() == EINTR) || FLAG_IS_SET(break_mask,SIGBREAKF_CTRL_C))
{
SetSignal(SIGBREAKF_CTRL_C,SIGBREAKF_CTRL_C);
__check_abort();
}
/* Stop if the return value from WaitSelect() is negative (timeout, abort or serious error). */
if(result < 0)
break;
/* Check all files for input. We also poll
* them for input, but each with a little
* delay of about 1 microsecond. We stop
* as soon as we find one file that has
* input in it.
*/
for(i = 0 ; i < total_file_fd ; i++)
{
got_input = got_output = FALSE;
fd = get_file_descriptor(i);
if(fd != NULL)
{
if(file_read_fds != NULL && FD_ISSET(i,file_read_fds))
{
if(FLAG_IS_SET(fd->fd_Flags,FDF_READ))
{
assert( FLAG_IS_CLEAR(fd->fd_Flags,FDF_IS_SOCKET) );
/* Does this one have input? */
PROFILE_OFF();
if(WaitForChar(fd->fd_DefaultFile,1))
got_input = TRUE;
PROFILE_ON();
}
}
if(file_write_fds != NULL && FD_ISSET(i,file_write_fds))
{
/* If this is a writable stream, assume that we can
* write to it. ZZZ AmigaDOS needs a method to check
* if the write will block.
*/
if(FLAG_IS_SET(fd->fd_Flags,FDF_WRITE))
{
assert( FLAG_IS_CLEAR(fd->fd_Flags,FDF_IS_SOCKET) );
got_output = TRUE;
}
}
}
if(got_input || got_output)
{
/* Mark one more descriptor as
* having input/output.
*/
result++;
}
if(file_read_fds != NULL && NOT got_input)
FD_CLR(i,file_read_fds);
if(file_write_fds != NULL && NOT got_output)
FD_CLR(i,file_write_fds);
}
/* Did we get any input? If so, stop polling. */
if(result > 0)
break;
/* If a timeout was set, check if we are already
* beyond the point of time when we should have
* stopped polling.
*/
if(timeout != NULL)
{
struct DateStamp now;
PROFILE_OFF();
DateStamp(&now);
PROFILE_ON();
if(CompareDates(&now,&stop_when) <= 0)
break;
}
/* No I/O ready yet. Restore the sets and retry... */
copy_fd_set(socket_read_fds, backup_socket_read_fds, num_socket_used);
copy_fd_set(socket_write_fds, backup_socket_write_fds, num_socket_used);
copy_fd_set(socket_except_fds, backup_socket_except_fds, num_socket_used);
copy_fd_set(file_read_fds, backup_file_read_fds, num_file_used);
copy_fd_set(file_write_fds, backup_file_write_fds, num_file_used);
}
}
else
{
ULONG break_mask;
if(__check_abort_enabled)
break_mask = SIGBREAKF_CTRL_C;
else
break_mask = 0;
PROFILE_OFF();
result = __WaitSelect(total_socket_fd,socket_read_fds,socket_write_fds,socket_except_fds,timeout,&break_mask);
PROFILE_ON();
if((result < 0 && __get_errno() == EINTR) || FLAG_IS_SET(break_mask,SIGBREAKF_CTRL_C))
{
SetSignal(SIGBREAKF_CTRL_C,SIGBREAKF_CTRL_C);
__check_abort();
}
}
}
else
{
/* Wait for file input? */
if((total_file_fd > 0) && (timeout == NULL || timeout->tv_secs > 0 || timeout->tv_micro > 0))
{
struct DateStamp stop_when;
BOOL got_input;
BOOL got_output;
SHOWMSG("we have to deal with files");
if(num_file_used > 0)
{
if(read_fds != NULL)
{
SHOWMSG("allocating backup file read fd_set");
backup_file_read_fds = allocate_fd_set(num_file_used,file_read_fds);
if(backup_file_read_fds == NULL)
goto out;
}
if(write_fds != NULL)
{
SHOWMSG("allocating backup file write fd_set");
backup_file_write_fds = allocate_fd_set(num_file_used,file_write_fds);
if(backup_file_write_fds == NULL)
goto out;
}
}
if(timeout != NULL)
{
struct DateStamp datestamp_timeout;
PROFILE_OFF();
DateStamp(&stop_when);
PROFILE_ON();
add_dates(&stop_when,timeval_to_datestamp(&datestamp_timeout,timeout));
}
else
{
memset(&stop_when,0,sizeof(stop_when));
}
while(TRUE)
{
if(__check_abort_enabled)
__check_abort();
PROFILE_OFF();
Delay(1);
PROFILE_ON();
result = 0;
for(i = 0 ; i < total_file_fd ; i++)
{
got_input = got_output = FALSE;
fd = get_file_descriptor(i);
if(fd != NULL)
{
if(file_read_fds != NULL && FD_ISSET(i,file_read_fds))
{
if(FLAG_IS_SET(fd->fd_Flags,FDF_READ))
{
assert( FLAG_IS_CLEAR(fd->fd_Flags,FDF_IS_SOCKET) );
PROFILE_OFF();
if(WaitForChar(fd->fd_DefaultFile,1))
got_input = TRUE;
PROFILE_ON();
}
}
if(file_write_fds != NULL && FD_ISSET(i,file_write_fds))
{
if(FLAG_IS_SET(fd->fd_Flags,FDF_WRITE))
{
assert( FLAG_IS_CLEAR(fd->fd_Flags,FDF_IS_SOCKET) );
got_output = TRUE;
}
}
}
if(got_input || got_output)
result++;
if(file_read_fds != NULL && NOT got_input)
FD_CLR(i,file_read_fds);
if(file_write_fds != NULL && NOT got_output)
FD_CLR(i,file_write_fds);
}
if(result > 0)
break;
if(timeout != NULL)
{
struct DateStamp now;
PROFILE_OFF();
DateStamp(&now);
PROFILE_ON();
if(CompareDates(&now,&stop_when) <= 0)
break;
}
copy_fd_set(file_read_fds, backup_file_read_fds, num_file_used);
copy_fd_set(file_write_fds, backup_file_write_fds, num_file_used);
}
}
else
{
SHOWMSG("no files to worry about");
}
}
/* The descriptor sets remain unchanged in
* case of error.
*/
if(result >= 0)
{
SHOWMSG("remapping fd_sets");
__stdio_lock();
remap_descriptor_sets(socket_read_fds, total_socket_fd, file_read_fds, total_file_fd, read_fds, num_fds);
remap_descriptor_sets(socket_write_fds, total_socket_fd, file_write_fds, total_file_fd, write_fds, num_fds);
remap_descriptor_sets(socket_except_fds, total_socket_fd, NULL, 0, except_fds, num_fds);
__stdio_unlock();
}
if(__check_abort_enabled)
__check_abort();
out:
free_fd_set(socket_read_fds);
free_fd_set(socket_write_fds);
free_fd_set(socket_except_fds);
free_fd_set(file_read_fds);
free_fd_set(file_write_fds);
free_fd_set(backup_socket_read_fds);
free_fd_set(backup_socket_write_fds);
free_fd_set(backup_socket_except_fds);
free_fd_set(backup_file_read_fds);
free_fd_set(backup_file_write_fds);
RETURN(result);
return(result);
}
/****************************************************************************/
#endif /* SOCKET_SUPPORT */
Reference in New Issue View Git Blame Copy Permalink