void CountdownWidget::redrawImage(const QSize &sz)
{
Q_D(CountdownWidget);
if (d->image.size() != sz) {
d->image = QImage(sz, QImage::Format_ARGB32_Premultiplied);
}
d->image.fill(Qt::transparent);
if (d->masterPasswordInvalidationTimer.isActive()) {
QPainter p(&d->image);
p.setOpacity(0.6);
p.setRenderHint(QPainter::Antialiasing);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.setBrush(Qt::transparent);
static const int OneMinute = 60 * 1000;
static const QRect boundingRect(2, 2, 12, 12);
p.setPen(QPen(QBrush(remainingTime() < OneMinute ? Qt::red : Qt::black), 1.0));
const int spanAngle = 360 * remainingTime() / d->timeoutMs;
if (spanAngle > (360 - 10)) {
p.drawEllipse(boundingRect);
}
else {
p.drawPie(boundingRect, 16 * 90, -16 * spanAngle);
}
p.end();
}
update();
}
void ThreadImpl::sleepImpl(long milliseconds)
{
#if defined(__digital__)
// This is specific to DECThreads
struct timespec interval;
interval.tv_sec = milliseconds / 1000;
interval.tv_nsec = (milliseconds % 1000)*1000000;
pthread_delay_np(&interval);
#elif POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID || POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_QNX || POCO_OS == POCO_OS_VXWORKS
Poco::Timespan remainingTime(1000*Poco::Timespan::TimeDiff(milliseconds));
int rc;
do
{
struct timespec ts;
ts.tv_sec = (long) remainingTime.totalSeconds();
ts.tv_nsec = (long) remainingTime.useconds()*1000;
Poco::Timestamp start;
rc = ::nanosleep(&ts, 0);
if (rc < 0 && errno == EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): nanosleep() failed");
#else
Poco::Timespan remainingTime(1000*Poco::Timespan::TimeDiff(milliseconds));
int rc;
do
{
struct timeval tv;
tv.tv_sec = (long) remainingTime.totalSeconds();
tv.tv_usec = (long) remainingTime.useconds();
Poco::Timestamp start;
rc = ::select(0, NULL, NULL, NULL, &tv);
if (rc < 0 && errno == EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): select() failed");
#endif
}
void DownloadItem::updateInfoLabel()
{
if (m_reply->error() != QNetworkReply::NoError)
return;
qint64 bytesTotal = m_reply->header(QNetworkRequest::ContentLengthHeader).toULongLong();
bool running = !downloadedSuccessfully();
// update info label
double speed = currentSpeed();
double timeRemaining = remainingTime();
QString info;
if (running) {
QString remaining;
if (bytesTotal != 0) {
remaining = DownloadManager::timeString(timeRemaining);
}
info = QString(tr("%1 of %2 (%3/sec) - %4"))
.arg(DownloadManager::dataString(m_bytesReceived))
.arg(bytesTotal == 0 ? tr("?") : DownloadManager::dataString(bytesTotal))
.arg(DownloadManager::dataString((int)speed))
.arg(remaining);
} else {
if (m_bytesReceived == bytesTotal)
info = DownloadManager::dataString(m_output.size());
else
info = tr("%1 of %2 - Stopped")
.arg(DownloadManager::dataString(m_bytesReceived))
.arg(DownloadManager::dataString(bytesTotal));
}
downloadInfoLabel->setText(info);
}
void Timer::adjust() {
auto remaining = remainingTime();
if (remaining >= 0) {
cancel();
_timerId = startTimer(remaining, _type);
_adjusted = true;
}
}
void SingleTimer::startIfNotActive(int msec) {
if (isActive()) {
int remains = remainingTime();
if (remains > msec) {
start(msec);
} else if (!remains) {
start(1);
}
} else {
start(msec);
}
}
qint64 MediaObject::remainingTime() const
{
K_D(const MediaObject);
if (!d->m_backendObject) {
return -1;
}
qint64 ret = INTERFACE_CALL(remainingTime());
if (ret < 0) {
return -1;
}
return ret;
}
void CountdownWidget::tick(void)
{
Q_D(CountdownWidget);
QString msg;
if (d->masterPasswordInvalidationTimer.isActive()) {
const int secs = remainingTime() / 1000;
const QString &t = (secs <= 60)
? tr("%1 seconds").arg(secs)
: tr("<%1 minutes").arg(1 + secs / 60);
msg = tr("Application will be locked in %1.").arg(t);
}
setToolTip(msg);
setWhatsThis(msg);
redrawImage(size());
}
void ThreadImpl::sleepImpl(long milliseconds) {
lyx::Timespan remainingTime(1000*lyx::Timespan::TimeDiff(milliseconds));
int rc;
do {
struct timespec ts;
ts.tv_sec = (long) remainingTime.totalSeconds();
ts.tv_nsec = (long) remainingTime.useconds()*1000;
lyx::Timestamp start;
rc = ::nanosleep(&ts, 0);
if (rc < 0 && errno == EINTR) {
lyx::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0)
throw lyx::SystemException("Thread::sleep(): nanosleep() failed");
}
bool SocketImpl::poll(const Poco::Timespan& timeout, int mode)
{
poco_socket_t sockfd = _sockfd;
if (sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
#if defined(POCO_HAVE_FD_EPOLL)
int epollfd = epoll_create(1);
if (epollfd < 0)
{
char buf[1024];
strerror_r(errno, buf, sizeof(buf));
error(std::string("Can't create epoll queue: ") + buf);
}
struct epoll_event evin;
memset(&evin, 0, sizeof(evin));
if (mode & SELECT_READ)
evin.events |= EPOLLIN;
if (mode & SELECT_WRITE)
evin.events |= EPOLLOUT;
if (mode & SELECT_ERROR)
evin.events |= EPOLLERR;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &evin) < 0)
{
char buf[1024];
strerror_r(errno, buf, sizeof(buf));
::close(epollfd);
error(std::string("Can't insert socket to epoll queue: ") + buf);
}
Poco::Timespan remainingTime(timeout);
int rc;
do
{
struct epoll_event evout;
memset(&evout, 0, sizeof(evout));
Poco::Timestamp start;
rc = epoll_wait(epollfd, &evout, 1, remainingTime.totalMilliseconds());
if (rc < 0 && lastError() == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (rc < 0 && lastError() == POCO_EINTR);
::close(epollfd);
if (rc < 0) error();
return rc > 0;
#elif defined(POCO_HAVE_FD_POLL)
pollfd pollBuf;
memset(&pollBuf, 0, sizeof(pollfd));
pollBuf.fd = _sockfd;
if (mode & SELECT_READ) pollBuf.events |= POLLIN;
if (mode & SELECT_WRITE) pollBuf.events |= POLLOUT;
Poco::Timespan remainingTime(timeout);
int rc;
do
{
Poco::Timestamp start;
rc = ::poll(&pollBuf, 1, remainingTime.totalMilliseconds());
if (rc < 0 && lastError() == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (rc < 0 && lastError() == POCO_EINTR);
#else
fd_set fdRead;
fd_set fdWrite;
fd_set fdExcept;
FD_ZERO(&fdRead);
FD_ZERO(&fdWrite);
FD_ZERO(&fdExcept);
if (mode & SELECT_READ)
{
FD_SET(sockfd, &fdRead);
}
if (mode & SELECT_WRITE)
{
FD_SET(sockfd, &fdWrite);
}
if (mode & SELECT_ERROR)
{
FD_SET(sockfd, &fdExcept);
}
Poco::Timespan remainingTime(timeout);
int errorCode = POCO_ENOERR;
int rc;
do
{
struct timeval tv;
tv.tv_sec = (long) remainingTime.totalSeconds();
tv.tv_usec = (long) remainingTime.useconds();
Poco::Timestamp start;
rc = ::select(int(sockfd) + 1, &fdRead, &fdWrite, &fdExcept, &tv);
if (rc < 0 && (errorCode = lastError()) == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (rc < 0 && errorCode == POCO_EINTR);
if (rc < 0) error(errorCode);
return rc > 0;
#endif // POCO_HAVE_FD_EPOLL
}
void DialogClone::ViewProzent()
{
int prozent = 0 ;
QString sekunde;
int sekunde_ = 0;
QString minute;
int minute_ = 0;
QString hour;
int hour_ = 0;
QString text_integer;
QString size;
int size_1 = 0;
QString letzte_zeile;
QString befehl;
int diff = 0;
QString mb_sec;
if (endeThread_clone ==0)
{
QTimer::singleShot(1000, this, SLOT(ViewProzent()));
// Prüfen, nach wieviel Sekunden ViewProzent erneut aufgerufen wird
diff = sekunde_summe_clone - sekunde_summe_clone_1;
size_clone = read_write_space_sum * sekunde_summe_clone;
//qDebug() << "size_clone" << size_clone;
if (size_clone_dummy > size_clone)
size_clone=size_clone_dummy; //Verhindert, dass die bereits angezeigten gespeicherten Daten nicht reduziert werden
size_clone_dummy = size_clone;
lbl_hd_size ->setText("MB");
prozent = size_clone/(partition_exist_size_int)/10;
prozent = 100 * size_clone/(partition_exist_size_int);
if (prozent > 100)
prozent = 100;
sekunde_summe_clone_1 = sekunde_summe_clone;
savedBytes->setText("");
size_1 = (int) size_clone;
if (size_clone > 10000) {
size_1 = size_1 / 1000;
lbl_hd_size ->setText("GB");}
size = QString::number(size_1);
mb_sec = QString::number(read_write_space_sum, 'f',1);
//qDebug() << "prozent size_clone read_write_space_sum sekunde_summe_clone size mb_sec" << prozent <<read_write_space_sum << sekunde_summe_clone<< size << mb_sec;
if (read_write_space_sum > 0)
bytes_sec ->setText(mb_sec);
if (read_write_space_sec != "")
bytes_sec ->setText(read_write_space_sec);
if (size_clone > 0)
savedBytes->setText(size);
// verhindert dass mehr gesicherte Bytes angezeigt werden als Festplattengröße
if (size_clone > partition_exist_size_int)
savedBytes->setText(QString::number(partition_exist_size_int));
this->repaint();
elapsedTime();
progressBar->setValue(prozent);
if (dummy_prozent_clone != prozent)
remainingTime(prozent);
else {
if (prozent >= 1)
{
// Sekunden nach unten zählen
sekunde = SekundeRemaining->text();
sekunde_ = sekunde.toInt();
minute = MinuteRemaining->text();
minute_ = minute.toInt();
hour = HourRemaining->text();
hour_ = hour.toInt();
if (sekunde_ > 0)
{
sekunde_ = sekunde_ - diff;
if (sekunde_ < 0)
sekunde_ = 0;
if (sekunde_ == 0)
{
if (minute_ > 0)
{
minute_ = minute_ - 1;
minute = QString::number(minute_);
MinuteRemaining ->setText(minute);
sekunde_ = 59;
}
if (minute_ == 0 && sekunde == 0)
{
hour_ = hour_ - 1;
hour = QString::number(hour_);
HourRemaining ->setText(hour);
minute_ = 59;
}
}
}
sekunde = QString::number(sekunde_);
SekundeRemaining ->setText(sekunde);
}
}
dummy_prozent_clone = prozent;
}
}
void DialogDIR::ViewProzent()
{
QString sekunde;
int sekunde_;
QString minute;
int minute_;
int meldung;
int anzahl;
int anzahl1;
QString text_integer;
if (endeThread_ !=1)
{
timer->singleShot( 1000, this , SLOT(ViewProzent( )) ) ;
elapsedTime();
meldung = werte_holen(4);
if (meldung >= 100) // Thread Abschluss mit Fehler
return;
if (flag_View_dir == 1)
{
anzahl = werte_holen(2);
text_integer = text_integer.setNum(anzahl);
AnzahlsaveFile ->setText(text_integer);
anzahl1 = werte_holen(3);
text_integer = text_integer.setNum(anzahl1);
AnzahlgesicherteFile ->setText(text_integer);
}
prozent_ = werte_holen(1);
if (dummy_prozent_dir != prozent_)
remainingTime(prozent_);
else {
if (prozent_ > 5)
{
// Sekunden nach unten zählen
// SekundenRemaining einlesen
sekunde = SekundeRemaining->text();
sekunde_ = sekunde.toInt();
minute = MinuteRemaining->text();
minute_ = minute.toInt();
if (sekunde_ > 0)
{
sekunde_ = sekunde_ - 1;
if (sekunde_ == 0)
{
if (minute_ > 0)
{
minute_ = minute_ - 1;
minute = QString::number(minute_);
MinuteRemaining ->setText(minute);
sekunde_ = 59;
}
}
}
sekunde = QString::number(sekunde_);
SekundeRemaining ->setText(sekunde);
}
}
dummy_prozent_dir = prozent_;
}
// bei mehrmaligem Aufruf von fsarchiver wird am Anfang der Sicherung kurzfristig 100 % angezeigt, was falsch ist
if (prozent_ <= 99 )
progressBar->setValue(prozent_);
if (prozent_ == 99 or endeThread_ >= 1)
progressBar->setValue(100);
return;
}
qint32 Pomodoro::remaining() const
{
qint32 _remaining = remainingTime();
if (_remaining != -1) _remaining = std::floor (1. * _remaining / 1000.);
return _remaining;
}
void Themes::updateTitle()
{
remainingTime(remainingSeconds);
}
int Socket::select(SocketList& readList, SocketList& writeList, SocketList& exceptList, const Poco::Timespan& timeout)
{
fd_set fdRead;
fd_set fdWrite;
fd_set fdExcept;
int nfd = 0;
FD_ZERO(&fdRead);
for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it)
{
if (int(it->sockfd()) > nfd)
nfd = int(it->sockfd());
FD_SET(it->sockfd(), &fdRead);
}
FD_ZERO(&fdWrite);
for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it)
{
if (int(it->sockfd()) > nfd)
nfd = int(it->sockfd());
FD_SET(it->sockfd(), &fdWrite);
}
FD_ZERO(&fdExcept);
for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it)
{
if (int(it->sockfd()) > nfd)
nfd = int(it->sockfd());
FD_SET(it->sockfd(), &fdExcept);
}
Poco::Timespan remainingTime(timeout);
int rc;
do
{
struct timeval tv;
tv.tv_sec = (long) remainingTime.totalSeconds();
tv.tv_usec = (long) remainingTime.useconds();
Poco::Timestamp start;
rc = ::select(nfd + 1, &fdRead, &fdWrite, &fdExcept, &tv);
if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
if (rc < 0) SocketImpl::error();
SocketList readyReadList;
for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it)
{
if (FD_ISSET(it->sockfd(), &fdRead))
readyReadList.push_back(*it);
}
std::swap(readList, readyReadList);
SocketList readyWriteList;
for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it)
{
if (FD_ISSET(it->sockfd(), &fdWrite))
readyWriteList.push_back(*it);
}
std::swap(writeList, readyWriteList);
SocketList readyExceptList;
for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it)
{
if (FD_ISSET(it->sockfd(), &fdExcept))
readyExceptList.push_back(*it);
}
std::swap(exceptList, readyExceptList);
return rc;
}
int Socket::select(SocketList& readList, SocketList& writeList, SocketList& exceptList, const Poco::Timespan& timeout)
{
#if defined(POCO_HAVE_FD_EPOLL)
int epollSize = readList.size() + writeList.size() + exceptList.size();
if (epollSize == 0) return 0;
int epollfd = -1;
{
struct epoll_event eventsIn[epollSize];
memset(eventsIn, 0, sizeof(eventsIn));
struct epoll_event* eventLast = eventsIn;
for (SocketList::iterator it = readList.begin(); it != readList.end(); ++it)
{
poco_socket_t sockfd = it->sockfd();
if (sockfd != POCO_INVALID_SOCKET)
{
struct epoll_event* e = eventsIn;
for (; e != eventLast; ++e)
{
if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd)
break;
}
if (e == eventLast)
{
e->data.ptr = &(*it);
++eventLast;
}
e->events |= EPOLLIN;
}
}
for (SocketList::iterator it = writeList.begin(); it != writeList.end(); ++it)
{
poco_socket_t sockfd = it->sockfd();
if (sockfd != POCO_INVALID_SOCKET)
{
struct epoll_event* e = eventsIn;
for (; e != eventLast; ++e)
{
if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd)
break;
}
if (e == eventLast)
{
e->data.ptr = &(*it);
++eventLast;
}
e->events |= EPOLLOUT;
}
}
for (SocketList::iterator it = exceptList.begin(); it != exceptList.end(); ++it)
{
poco_socket_t sockfd = it->sockfd();
if (sockfd != POCO_INVALID_SOCKET)
{
struct epoll_event* e = eventsIn;
for (; e != eventLast; ++e)
{
if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd)
break;
}
if (e == eventLast)
{
e->data.ptr = &(*it);
++eventLast;
}
e->events |= EPOLLERR;
}
}
epollSize = eventLast - eventsIn;
epollfd = epoll_create(epollSize);
if (epollfd < 0)
{
char buf[1024];
strerror_r(errno, buf, sizeof(buf));
SocketImpl::error(std::string("Can't create epoll queue: ") + buf);
}
for (struct epoll_event* e = eventsIn; e != eventLast; ++e)
{
poco_socket_t sockfd = reinterpret_cast<Socket*>(e->data.ptr)->sockfd();
if (sockfd != POCO_INVALID_SOCKET)
{
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, e) < 0)
{
char buf[1024];
strerror_r(errno, buf, sizeof(buf));
::close(epollfd);
SocketImpl::error(std::string("Can't insert socket to epoll queue: ") + buf);
}
}
}
}
struct epoll_event eventsOut[epollSize];
memset(eventsOut, 0, sizeof(eventsOut));
Poco::Timespan remainingTime(timeout);
int rc;
do
{
Poco::Timestamp start;
rc = epoll_wait(epollfd, eventsOut, epollSize, remainingTime.totalMilliseconds());
if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
::close(epollfd);
if (rc < 0) SocketImpl::error();
SocketList readyReadList;
SocketList readyWriteList;
SocketList readyExceptList;
for (int n = 0; n < rc; ++n)
{
if (eventsOut[n].events & EPOLLERR)
readyExceptList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr));
if (eventsOut[n].events & EPOLLIN)
readyReadList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr));
if (eventsOut[n].events & EPOLLOUT)
readyWriteList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr));
}
std::swap(readList, readyReadList);
std::swap(writeList, readyWriteList);
std::swap(exceptList, readyExceptList);
return readList.size() + writeList.size() + exceptList.size();
#elif defined(POCO_HAVE_FD_POLL)
nfds_t nfd = readList.size() + writeList.size() + exceptList.size();
if (0 == nfd) return 0;
SharedPollArray pPollArr = new pollfd[nfd];
int idx = 0;
for (SocketList::iterator it = readList.begin(); it != readList.end(); ++it)
{
pPollArr[idx].fd = int(it->sockfd());
pPollArr[idx++].events |= POLLIN;
}
SocketList::iterator begR = readList.begin();
SocketList::iterator endR = readList.end();
for (SocketList::iterator it = writeList.begin(); it != writeList.end(); ++it)
{
SocketList::iterator pos = std::find(begR, endR, *it);
if (pos != endR)
{
pPollArr[pos-begR].events |= POLLOUT;
--nfd;
}
else
{
pPollArr[idx].fd = int(it->sockfd());
pPollArr[idx++].events |= POLLOUT;
}
}
SocketList::iterator begW = writeList.begin();
SocketList::iterator endW = writeList.end();
for (SocketList::iterator it = exceptList.begin(); it != exceptList.end(); ++it)
{
SocketList::iterator pos = std::find(begR, endR, *it);
if (pos != endR) --nfd;
else
{
SocketList::iterator pos = std::find(begW, endW, *it);
if (pos != endW) --nfd;
else pPollArr[idx++].fd = int(it->sockfd());
}
}
Poco::Timespan remainingTime(timeout);
int rc;
do
{
Poco::Timestamp start;
rc = ::poll(pPollArr, nfd, timeout.totalMilliseconds());
if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime) remainingTime -= waited;
else remainingTime = 0;
}
}
while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
if (rc < 0) SocketImpl::error();
SocketList readyReadList;
SocketList readyWriteList;
SocketList readyExceptList;
SocketList::iterator begE = exceptList.begin();
SocketList::iterator endE = exceptList.end();
for (int idx = 0; idx < nfd; ++idx)
{
SocketList::iterator slIt = std::find_if(begR, endR, Socket::FDCompare(pPollArr[idx].fd));
if (POLLIN & pPollArr[idx].revents && slIt != endR) readyReadList.push_back(*slIt);
slIt = std::find_if(begW, endW, Socket::FDCompare(pPollArr[idx].fd));
if (POLLOUT & pPollArr[idx].revents && slIt != endW) readyWriteList.push_back(*slIt);
slIt = std::find_if(begE, endE, Socket::FDCompare(pPollArr[idx].fd));
if (POLLERR & pPollArr[idx].revents && slIt != endE) readyExceptList.push_back(*slIt);
}
std::swap(readList, readyReadList);
std::swap(writeList, readyWriteList);
std::swap(exceptList, readyExceptList);
return readList.size() + writeList.size() + exceptList.size();
#else
fd_set fdRead;
fd_set fdWrite;
fd_set fdExcept;
int nfd = 0;
FD_ZERO(&fdRead);
for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it)
{
poco_socket_t fd = it->sockfd();
if (fd != POCO_INVALID_SOCKET)
{
if (int(fd) > nfd)
nfd = int(fd);
FD_SET(fd, &fdRead);
}
}
FD_ZERO(&fdWrite);
for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it)
{
poco_socket_t fd = it->sockfd();
if (fd != POCO_INVALID_SOCKET)
{
if (int(fd) > nfd)
nfd = int(fd);
FD_SET(fd, &fdWrite);
}
}
FD_ZERO(&fdExcept);
for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it)
{
poco_socket_t fd = it->sockfd();
if (fd != POCO_INVALID_SOCKET)
{
if (int(fd) > nfd)
nfd = int(fd);
FD_SET(fd, &fdExcept);
}
}
if (nfd == 0) return 0;
Poco::Timespan remainingTime(timeout);
int rc;
do
{
struct timeval tv;
tv.tv_sec = (long) remainingTime.totalSeconds();
tv.tv_usec = (long) remainingTime.useconds();
Poco::Timestamp start;
rc = ::select(nfd + 1, &fdRead, &fdWrite, &fdExcept, &tv);
if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = end - start;
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
if (rc < 0) SocketImpl::error();
SocketList readyReadList;
for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it)
{
poco_socket_t fd = it->sockfd();
if (fd != POCO_INVALID_SOCKET)
{
if (FD_ISSET(fd, &fdRead))
readyReadList.push_back(*it);
}
}
std::swap(readList, readyReadList);
SocketList readyWriteList;
for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it)
{
poco_socket_t fd = it->sockfd();
if (fd != POCO_INVALID_SOCKET)
{
if (FD_ISSET(fd, &fdWrite))
readyWriteList.push_back(*it);
}
}
std::swap(writeList, readyWriteList);
SocketList readyExceptList;
for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it)
{
poco_socket_t fd = it->sockfd();
if (fd != POCO_INVALID_SOCKET)
{
if (FD_ISSET(fd, &fdExcept))
readyExceptList.push_back(*it);
}
}
std::swap(exceptList, readyExceptList);
return rc;
#endif // POCO_HAVE_FD_EPOLL
}
