OK, for the benefit of others listening in, this is what I've briefly
described to Steve and Anders on suse-linux-e - who both said "it's
impossible" - which I agree with. Reality however seems to be of a
different opinion.
I'm writing a simple, multi-threaded SMTP proxy. New connections are
received/accepted, packed into a unit-of-work, then queued for one of X
worker-threads to pick up. Each UOW has the socket returned by the
accept call. I refer to this as the "left side". When a UOW is picked
up for processing, the thread will connect to the outbound side (the
"right side"), and then start processing.
Here's roughly what happens: (code attached)
check that the socket is still valid - the client could have gone away
whilst the UOW was queued.
connect to right side (create socket etc.)
create a copy of the socket - new one is called right2.
The original is set nonblocking.
Now create streams, one on each socket.
Similar thing for the left side.
The main code (not attached) now uses select() on the left and right
inbound, nonblocking sockets, and when e.g. the left side has some data
for us,:
if ( FD_ISSET(left,&readfds) )
{
closed=1;
while( NULL!=fgets( buffer, sizeof(buffer), left_in ) )
{
closed=0;
while( EOF==(rc=fputs( buffer, right_out )) )
{
if ( errno!=EAGAIN ) break;
log_error( "[%02u.%04u] %d.2: unable to write to
right; error %d: %s\n", c->id, work->id, stage, errno,
strerror(errno) );
sleep(1);
}
if ( EOF==rc )
{
stage=99;
break;
}
}
fflush( right_out );
// if the left side closed the connection
if ( closed )
{
log_error( "right side closed??\n");
stage=99;
}
}
/Per Jessen, Zürich
