romenskiy2012/curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-07-24 12:17:16 +03:00
Code Issues Projects Releases Packages Wiki Activity

reverted the pselect patch => http://curl.haxx.se/mail/lib-2007-03/0100.html

Browse source
This commit is contained in:
Daniel Stenberg 2007-03-11 09:11:29 +00:00
parent 40e9e40cb4
commit c8cd13337e
8 changed files with 49 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

7
lib/progress.c
View file

@ -280,6 +280,9 @@ int Curl_pgrsUpdate(struct connectdata *conn)
((double)data->progress.uploaded/
(data->progress.timespent>0?data->progress.timespent:1));
if(data->progress.lastshow == Curl_tvlong(now))
return 0; /* never update this more than once a second if the end isn't
reached */
data->progress.lastshow = now.tv_sec;
/* Let's do the "current speed" thing, which should use the fastest
@ -356,10 +359,6 @@ int Curl_pgrsUpdate(struct connectdata *conn)
return result;
}
if(data->progress.lastshow == Curl_tvlong(now))
return 0; /* never update this more than once a second if the end isn't
reached */
/* Figure out the estimated time of arrival for the upload */
if((data->progress.flags & PGRS_UL_SIZE_KNOWN) &&
(data->progress.ulspeed>0) &&

169
lib/select.c
View file

@ -32,7 +32,9 @@
#include <sys/time.h>
#endif
#include <signal.h>
#ifndef HAVE_SELECT
#error "We can't compile without select() support!"
#endif
#ifdef __BEOS__
/* BeOS has FD_SET defined in socket.h */
@ -51,57 +53,6 @@
/* Winsock and TPF sockets are not in range [0..FD_SETSIZE-1] */
/* There are various ways to wait for a socket to be ready to give or take
* data. None of them are perfect.
*
* select() is available everywhere, but cannot take a file
* descriptor numerically greater than FD_SETSIZE but cannot be reliably
* interrupted by a signal.
*
* pselect() works with signals, but still has the file descriptor problem.
* And some older systems don't have it.
*
* poll() (and equivalently on Windows, WSAPoll()) can take any file
* descriptor, but has the signal problem. And some older systems
* don't have it.
*
* The signal issue is this: We would like to be able to avoid the
* wait if a signal has arrived since we last checked for it. All
* these methods terminate the wait (with EINTR) if a signal arrives
* while the waiting is underway, so it's just signals that happen
* shortly before the wait that are a problem. With pselect(), this
* is possible because it has the ability to simultaneously unblock
* signals _after_ the wait begins. So you just block signals, then
* check for arrival, then assuming no signals have arrived, call
* pselect() with an argument that says to unblock signals. Any
* signal that arrived after you blocked will thus interrupt the wait
* and pselect() returns immediately.
*
* Curl_pselect() is our compromise among these. We use poll()
* whenever it is available and select() otherwise. We emulate
* pselect-like signal behavior by unblocking signals just before
* calling poll() or select() and re-blocking after. This only
* _approximates_ pselect(), because there is a window in which a
* signal may arrive and we wait anyway.
*
* To reduce that window, we use pselect(), if it is available --
* with no file descriptors -- just before the poll() or select() in
* order to detect signals that arrived between when the caller
* blocked signals and when he called Curl_pselect().
*
* Curl_select() is for callers who want us to ignore caught signals and
* wait until a socket is ready or the timeout expires. We implement that
* simply as a loop around Curl_pselect().
*
* There is a way to add signal interruptibility to poll(), which we
* don't provide today: Let caller give us a file descriptor to add
* to our list of wait-for-readable file descriptors. Caller passes
* us the fd of a pipe. He doesn't block signals and his signal
* handler writes to the other end of that pipe. Therefore, a signal
* causes poll() to return, even if received before poll() was
* called.
*/
#if defined(USE_WINSOCK) || defined(TPF)
#define VERIFY_SOCK(x) do { } while (0)
#else
@ -115,56 +66,18 @@
#endif
/*
* This function unblocks a set of signal classes momentarily, to allow any
* the process to receive any presently blocked signal. If there exists
* a handler for that, it will run now. If not, it will typically
* terminate the process.
* This is an internal function used for waiting for read or write
* events on single file descriptors. It attempts to replace select()
* in order to avoid limits with FD_SETSIZE.
*
* We return 1 if as a result of the unblocking, a signal was
* received, caught and handled. 0 otherwise.
*
* On a system that does not have pselect(), we always return 0, even if
* signals were received.
* Return values:
* -1 = system call error
* 0 = timeout
* CSELECT_IN | CSELECT_OUT | CSELECT_ERR
*/
int receive_signals(sigset_t * sigmask)
int Curl_select(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms)
{
#ifdef HAVE_PSELECT
struct timespec zeroTime = {0, 0};
/* Note that on older Linux, pselect() is imperfect -- the kernel doesn't
have a pselect() system call, so the GNU C Library implements it
with sigprocmask() followed by select(), which means the result is
the same as with the code below for systmes with no pselect() at all.
*/
if (pselect(0, NULL, NULL, NULL, &zeroTime, sigmask) == 0)
return 0;
else
return 1;
#else
sigset_t oldmask;
sigprocmask(SIG_SETMASK, sigmask, &oldmask);
sigprocmask(SIG_SETMASK, &oldmask, NULL);
return 0;
#endif
}
#if defined(HAVE_POLL_FINE) || defined(CURL_HAVE_WSAPOLL)
#define USE_POLL_FOR_SELECT 1
#else
#if defined(HAVE_SELECT)
#define USE_POLL_FOR_SELECT 0
#else
#error "You don't appear to have either poll() or select()."
#endif
#endif
#if USE_POLL_FOR_SELECT
static int select_with_poll(curl_socket_t readfd, curl_socket_t writefd,
int timeout_ms)
{
struct pollfd pfd[2];
int num;
int r;
@ -182,11 +95,13 @@ static int select_with_poll(curl_socket_t readfd, curl_socket_t writefd,
num++;
}
do {
#ifdef CURL_HAVE_WSAPOLL
r = WSAPoll(pfd, num, timeout_ms);
r = WSAPoll(pfd, num, timeout_ms);
#else
r = poll(pfd, num, timeout_ms);
r = poll(pfd, num, timeout_ms);
#endif
} while((r == -1) && (SOCKERRNO == EINTR));
if (r < 0)
return -1;
@ -217,13 +132,7 @@ static int select_with_poll(curl_socket_t readfd, curl_socket_t writefd,
}
return ret;
}
#endif USE_POLL_FOR_SELECT
static int select_with_select(curl_socket_t readfd, curl_socket_t writefd,
int timeout_ms)
{
#else
struct timeval timeout;
fd_set fds_read;
fd_set fds_write;
@ -270,7 +179,9 @@ static int select_with_select(curl_socket_t readfd, curl_socket_t writefd,
maxfd = writefd;
}
r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, &timeout);
do {
r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, &timeout);
} while((r == -1) && (SOCKERRNO == EINTR));
if (r < 0)
return -1;
@ -292,49 +203,7 @@ static int select_with_select(curl_socket_t readfd, curl_socket_t writefd,
}
return ret;
}
/*
* This is an internal function used for waiting for read or write
* events on single file descriptors. It attempts to replace select()
* in order to avoid limits with FD_SETSIZE.
*
* Return values:
* -1 = system call error, including interrupted by signal
* 0 = timeout
* CSELECT_IN | CSELECT_OUT | CSELECT_ERR
*/
int Curl_pselect(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms,
sigset_t * sigmask)
{
int ret;
sigset_t oldmask;
if (sigmask && receive_signals(sigmask)) {
SET_SOCKERRNO(EINTR);
ret = -1;
} else {
if (sigmask)
sigprocmask(SIG_SETMASK, sigmask, &oldmask);
#if USE_POLL_FOR_SELECT
ret = select_with_poll(readfd, writefd, timeout_ms);
#else
ret = select_with_select(readfd, writefd, timeout_ms);
#endif
if (sigmask)
sigprocmask(SIG_SETMASK, &oldmask, NULL);
}
return ret;
}
int Curl_select(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms)
{
int r;
do {
r = Curl_pselect(readfd, writefd, timeout_ms, NULL);
} while((r == -1) && (SOCKERRNO == EINTR));
return r;
}
/*

3
lib/select.h
View file

@ -51,9 +51,6 @@ struct pollfd
#define CSELECT_OUT 0x02
#define CSELECT_ERR 0x04
int Curl_pselect(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms,
sigset_t * sigmask);
int Curl_select(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms);
int Curl_poll(struct pollfd ufds[], unsigned int nfds, int timeout_ms);

59
lib/transfer.c
View file

@ -1603,6 +1603,8 @@ CURLcode Curl_readwrite(struct connectdata *conn,
failf(data, "transfer closed with outstanding read data remaining");
return CURLE_PARTIAL_FILE;
}
if(Curl_pgrsUpdate(conn))
return CURLE_ABORTED_BY_CALLBACK;
}
/* Now update the "done" boolean we return */
@ -1752,18 +1754,6 @@ int Curl_single_getsock(struct connectdata *conn,
}
static bool
errnoIsInterruption(int errnoarg)
{
#ifdef EINTR
return (errnoarg == EINTR);
#else
return FALSE;
#endif
}
/*
* Transfer()
*
@ -1785,12 +1775,6 @@ Transfer(struct connectdata *conn)
struct SessionHandle *data = conn->data;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
bool done=FALSE;
sigset_t callersigmask;
sigset_t allsignals;
int pgrsrc;
int selectrc;
sigfillset(&allsignals);
if(!(conn->protocol & PROT_FILE)) {
/* Only do this if we are not transferring FILE:, since the file: treatment
@ -1844,33 +1828,28 @@ Transfer(struct connectdata *conn)
the timeout case and if we limit transfer speed we must make sure that
this function doesn't transfer anything while in HOLD status. */
sigprocmask(SIG_SETMASK, &allsignals, &callersigmask);
pgrsrc = Curl_pgrsUpdate(conn);
if(!pgrsrc)
selectrc = Curl_pselect(fd_read, fd_write, 3000, &callersigmask);
sigprocmask(SIG_SETMASK, &callersigmask, NULL);
if(pgrsrc)
return CURLE_ABORTED_BY_CALLBACK;
if (selectrc == -1 && !errnoIsInterruption(SOCKERRNO)) {
done = TRUE; /* no more read or write */
switch (Curl_select(fd_read, fd_write, 1000)) {
case -1: /* select() error, stop reading */
#ifdef EINTR
/* The EINTR is not serious, and it seems you might get this more
ofen when using the lib in a multi-threaded environment! */
if(SOCKERRNO == EINTR)
;
else
#endif
done = TRUE; /* no more read or write */
continue;
} else {
/* ready files, timeout, or signal received */
case 0: /* timeout */
default: /* readable descriptors */
result = Curl_readwrite(conn, &done);
/* "done" signals to us if the transfer(s) are ready */
if(result)
return result;
break;
}
if(result)
return result;
/* "done" signals to us if the transfer(s) are ready */
}
Curl_pgrsUpdate(conn);
return CURLE_OK;
}