Skip to main content :: ::

KDE API Reference

:: Skip to Link Menu

/ API Reference / kdecore

kextsock.cpp /* * This file is part of the KDE libraries * Copyright (C) 2000-2004 Thiago Macieira <thiago.macieira@kdemail.net> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. **/ #include <config.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/times.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/un.h> #include <stdio.h> #include <errno.h> #include <fcntl.h> #include <netdb.h> #include <stdlib.h> #include <unistd.h> #include <qglobal.h> #include <qstring.h> #include <qiodevice.h> #include <qsocketnotifier.h> #include <qguardedptr.h> #include "kresolver.h" #include "kdebug.h" #include "kextsock.h" #include "ksockaddr.h" #include "ksocks.h" #ifdef __CYGWIN__ #include "netsupp.h" #endif using namespace KNetwork; // // Internal class definitions // class KExtendedSocketPrivate { public: int flags; // socket flags int status; // status int syserror; // the system error value timeval timeout; // connection/acception timeout KResolver resRemote; // the resolved addresses KResolver resLocal; // binding resolution unsigned current; // used by the asynchronous connection ::KSocketAddress *local; // local socket address ::KSocketAddress *peer; // peer socket address QSocketNotifier *qsnIn, *qsnOut; int inMaxSize, outMaxSize; bool emitRead : 1, emitWrite : 1; mutable bool addressReusable : 1, ipv6only : 1; KExtendedSocketPrivate() : flags(0), status(0), syserror(0), current(0), local(0), peer(0), qsnIn(0), qsnOut(0), inMaxSize(-1), outMaxSize(-1), emitRead(false), emitWrite(false), addressReusable(false), ipv6only(false) { timeout.tv_sec = timeout.tv_usec = 0; } }; // translate KExtendedSocket flags into KResolver ones static bool process_flags(int flags, int& socktype, int& familyMask, int& outflags) { switch (flags & (KExtendedSocket::streamSocket | KExtendedSocket::datagramSocket | KExtendedSocket::rawSocket)) { case 0: /* No flags given, use default */ case KExtendedSocket::streamSocket: /* streaming socket requested */ socktype = SOCK_STREAM; break; case KExtendedSocket::datagramSocket: /* datagram packet socket requested */ socktype = SOCK_DGRAM; break; case KExtendedSocket::rawSocket: /* raw socket requested. I wouldn't do this if I were you... */ socktype = SOCK_RAW; break; default: /* the flags were used in an invalid manner */ return false; } if (flags & KExtendedSocket::knownSocket) { familyMask = 0; if ((flags & KExtendedSocket::unixSocket) == KExtendedSocket::unixSocket) familyMask |= KResolver::UnixFamily; switch ((flags & (KExtendedSocket::ipv6Socket|KExtendedSocket::ipv4Socket))) { case KExtendedSocket::ipv4Socket: familyMask |= KResolver::IPv4Family; break; case KExtendedSocket::ipv6Socket: familyMask |= KResolver::IPv6Family; break; case KExtendedSocket::inetSocket: familyMask |= KResolver::InternetFamily; break; } // those are all the families we know about } else familyMask = KResolver::KnownFamily; /* check other flags */ outflags = (flags & KExtendedSocket::passiveSocket ? KResolver::Passive : 0) | (flags & KExtendedSocket::canonName ? KResolver::CanonName : 0) | (flags & KExtendedSocket::noResolve ? KResolver::NoResolve : 0); if (getenv("KDE_NO_IPV6")) familyMask &= ~KResolver::IPv6Family; return true; } // "skips" at most len bytes from file descriptor fd // that is, we will try and read that much data and discard // it. We will stop when we have read those or when the read // function returns error static int skipData(int fd, unsigned len) { char buf[1024]; unsigned skipped = 0; while (len) { int count = sizeof(buf); if ((unsigned)count > len) count = len; count = KSocks::self()->read(fd, buf, count); if (count == -1) return -1; else { len -= count; skipped += count; } } return skipped; } /* * class KExtendedSocket */ // default constructor KExtendedSocket::KExtendedSocket() : sockfd(-1), d(new KExtendedSocketPrivate) { } // constructor with hostname KExtendedSocket::KExtendedSocket(const QString& host, int port, int flags) : sockfd(-1), d(new KExtendedSocketPrivate) { setAddress(host, port); setSocketFlags(flags); } // same KExtendedSocket::KExtendedSocket(const QString& host, const QString& service, int flags) : sockfd(-1), d(new KExtendedSocketPrivate) { setAddress(host, service); setSocketFlags(flags); } // destroy the class KExtendedSocket::~KExtendedSocket() { closeNow(); if (d->local != NULL) delete d->local; if (d->peer != NULL) delete d->peer; if (d->qsnIn != NULL) delete d->qsnIn; if (d->qsnOut != NULL) delete d->qsnOut; delete d; } void KExtendedSocket::reset() { closeNow(); release(); d->current = 0; d->status = nothing; d->syserror = 0; } int KExtendedSocket::socketStatus() const { return d->status; } void KExtendedSocket::setSocketStatus(int newstatus) { d->status = newstatus; } void KExtendedSocket::setError(int errorcode, int syserror) { setStatus(errorcode); d->syserror = syserror; } int KExtendedSocket::systemError() const { return d->syserror; } /* * Sets socket flags * This is only allowed if we are in nothing state */ int KExtendedSocket::setSocketFlags(int flags) { if (d->status > nothing) return -1; // error! return d->flags = flags; } int KExtendedSocket::socketFlags() const { return d->flags; } /* * Sets socket target hostname * This is only allowed if we are in nothing state */ bool KExtendedSocket::setHost(const QString& host) { if (d->status > nothing) return false; // error! d->resRemote.setNodeName(host); return true; } /* * returns the hostname */ QString KExtendedSocket::host() const { return d->resRemote.nodeName(); } /* * Sets the socket target port/service * Same thing: only state 'nothing' */ bool KExtendedSocket::setPort(int port) { return setPort(QString::number(port)); } bool KExtendedSocket::setPort(const QString& service) { if (d->status > nothing) return false; // error d->resRemote.setServiceName(service); return true; } /* * returns the service port number */ QString KExtendedSocket::port() const { return d->resRemote.serviceName(); } /* * sets the address */ bool KExtendedSocket::setAddress(const QString& host, int port) { return setHost(host) && setPort(port); } /* * the same */ bool KExtendedSocket::setAddress(const QString& host, const QString& serv) { return setHost(host) && setPort(serv); } /* * Sets the bind hostname * This is only valid in the 'nothing' state and if this is not a * passiveSocket socket */ bool KExtendedSocket::setBindHost(const QString& host) { if (d->status > nothing || d->flags & passiveSocket) return false; // error d->resLocal.setServiceName(host); return true; } /* * Unsets the bind hostname * same thing */ bool KExtendedSocket::unsetBindHost() { return setBindHost(QString::null); } /* * returns the binding host */ QString KExtendedSocket::bindHost() const { return d->resLocal.serviceName(); } /* * Sets the bind port * Same condition as setBindHost */ bool KExtendedSocket::setBindPort(int port) { return setBindPort(QString::number(port)); } bool KExtendedSocket::setBindPort(const QString& service) { if (d->status > nothing || d->flags & passiveSocket) return false; // error d->resLocal.setServiceName(service); return true; } /* * unsets the bind port */ bool KExtendedSocket::unsetBindPort() { return setBindPort(QString::null); } /* * returns the binding port */ QString KExtendedSocket::bindPort() const { return d->resLocal.serviceName(); } /* * sets the binding address */ bool KExtendedSocket::setBindAddress(const QString& host, int port) { return setBindHost(host) && setBindPort(port); } /* * same */ bool KExtendedSocket::setBindAddress(const QString& host, const QString& service) { return setBindHost(host) && setBindPort(service); } /* * unsets binding address */ bool KExtendedSocket::unsetBindAddress() { return unsetBindHost() && unsetBindPort(); } /* * sets the timeout for the connection */ bool KExtendedSocket::setTimeout(int secs, int usecs) { if (d->status >= connected) // closed? return false; d->timeout.tv_sec = secs; d->timeout.tv_usec = usecs; return true; } /* * returns the timeout */ timeval KExtendedSocket::timeout() const { return d->timeout; } /* * Sets the blocking mode on this socket */ bool KExtendedSocket::setBlockingMode(bool enable) { cleanError(); if (d->status < created) return false; if (sockfd == -1) return false; // error! int fdflags = fcntl(sockfd, F_GETFL, 0); if (fdflags == -1) return false; // error! if (!enable) fdflags |= O_NONBLOCK; else fdflags &= ~O_NONBLOCK; if (fcntl(sockfd, F_SETFL, fdflags) == -1) { setError(IO_UnspecifiedError, errno); return false; } return true; } /* * Returns the blocking mode on the socket */ bool KExtendedSocket::blockingMode() { cleanError(); if (d->status < created) return false; // sockets not created are in blocking mode if (sockfd == -1) return false; // error int fdflags = fcntl(sockfd, F_GETFL, 0); if (fdflags == -1) { setError(IO_UnspecifiedError, errno); return false; } return (fdflags & O_NONBLOCK) == 0; // non-blocking == false } /* * Sets the reusability flag for this socket in the OS */ bool KExtendedSocket::setAddressReusable(bool enable) { cleanError(); d->addressReusable = enable; if (d->status < created) return true; if (sockfd == -1) return true; if (!setAddressReusable(sockfd, enable)) { setError(IO_UnspecifiedError, errno); return false; } return true; } bool KExtendedSocket::setAddressReusable(int fd, bool enable) { if (fd == -1) return false; int on = enable; // just to be on the safe side if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)) == -1) return false; return true; } /* * Retrieves the reusability flag for this socket */ bool KExtendedSocket::addressReusable() { cleanError(); if (d->status < created) return d->addressReusable; if (sockfd == -1) return d->addressReusable; int on; socklen_t onsiz = sizeof(on); if (getsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, &onsiz) == -1) { setError(IO_UnspecifiedError, errno); return false; } return on != 0; } /* * Set the IPV6_V6ONLY flag */ bool KExtendedSocket::setIPv6Only(bool enable) { #ifdef IPV6_V6ONLY cleanError(); d->ipv6only = enable; if (sockfd == -1) return true; // can't set on a non-existing socket int on = enable; if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&on, sizeof(on)) == -1) { setError(IO_UnspecifiedError, errno); return false; } else return true; #else // we don't have the IPV6_V6ONLY constant in this system d->ipv6only = enable; setError(IO_UnspecifiedError, ENOSYS); return false; // can't set if we don't know about this flag #endif } /* * retrieve the IPV6_V6ONLY flag */ bool KExtendedSocket::isIPv6Only() { #ifdef IPV6_V6ONLY cleanError(); if (d->status < created || sockfd == -1) return d->ipv6only; int on; socklen_t onsiz = sizeof(on); if (getsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&on, &onsiz) == -1) { setError(IO_UnspecifiedError, errno); return false; } return d->ipv6only = on; #else // we don't have the constant setError(IO_UnspecifiedError, ENOSYS); return false; #endif } /* * Sets the buffer sizes in this socket * Also, we create or delete the socket notifiers */ bool KExtendedSocket::setBufferSize(int rsize, int wsize) { cleanError(); if (d->status < created) return false; if (sockfd == -1) return false; if (d->flags & passiveSocket) return false; // no I/O on passive sockets if (rsize < -2) return false; if (wsize < -2) return false; // LOCK BUFFER MUTEX // The input socket notifier is always enabled // That happens because we want to be notified of when the socket gets // closed if (d->qsnIn == NULL) { d->qsnIn = new QSocketNotifier(sockfd, QSocketNotifier::Read); QObject::connect(d->qsnIn, SIGNAL(activated(int)), this, SLOT(socketActivityRead())); d->qsnIn->setEnabled(true); } if (rsize == 0 && d->flags & inputBufferedSocket) { // user wants to disable input buffering d->flags &= ~inputBufferedSocket; consumeReadBuffer(readBufferSize(), NULL, true); d->inMaxSize = 0; } else if (rsize != -2) { // enabling input buffering if (rsize) d->flags |= inputBufferedSocket; d->inMaxSize = rsize; if (rsize > 0 && (unsigned)rsize < readBufferSize()) // input buffer has more data than the new size; discard consumeReadBuffer(readBufferSize() - rsize, NULL, true); } if (wsize == 0 && d->flags & outputBufferedSocket) { // disabling output buffering d->flags &= ~outputBufferedSocket; if (d->qsnOut && !d->emitWrite) d->qsnOut->setEnabled(false); consumeWriteBuffer(writeBufferSize()); d->outMaxSize = 0; } else if (wsize != -2) { // enabling input buffering if (wsize) d->flags |= outputBufferedSocket; d->outMaxSize = wsize; if (wsize > 0 && (unsigned)wsize < writeBufferSize()) // output buffer is bigger than it is to become; shrink consumeWriteBuffer(writeBufferSize() - wsize); if (d->qsnOut == NULL) { d->qsnOut = new QSocketNotifier(sockfd, QSocketNotifier::Write); QObject::connect(d->qsnOut, SIGNAL(activated(int)), this, SLOT(socketActivityWrite())); // if the class is being created now, there's nothing to write yet // so socketActivityWrite() will get called once and disable // the notifier } } // UNLOCK BUFFER MUTEX setFlags((mode() & ~IO_Raw) | ((d->flags & bufferedSocket) ? 0 : IO_Raw)); // check we didn't turn something off we shouldn't if (d->emitWrite && d->qsnOut == NULL) { d->qsnOut = new QSocketNotifier(sockfd, QSocketNotifier::Write); QObject::connect(d->qsnOut, SIGNAL(activated(int)), this, SLOT(socketActivityWrite())); } return true; } /* * Finds the local address for this socket * if we have done this already, we return it. Otherwise, we'll have * to find the socket name */ const ::KSocketAddress *KExtendedSocket::localAddress() { if (d->local != NULL) return d->local; if (d->status < bound) return NULL; return d->local = localAddress(sockfd); } /* * Same thing, but for peer address. Which means this does not work on * passiveSocket and that we require to be connected already. Also note that * the behavior on connectionless sockets is not defined here. */ const ::KSocketAddress* KExtendedSocket::peerAddress() { if (d->peer != NULL) return d->peer; if (d->flags & passiveSocket || d->status < connected) return NULL; return d->peer = peerAddress(sockfd); } /* * Perform the lookup on the addresses given */ int KExtendedSocket::lookup() { if (startAsyncLookup() != 0) return -1; if (!d->resRemote.wait() || !d->resLocal.wait()) { d->status = nothing; return -1; } d->status = lookupDone; if (d->resRemote.error() != KResolver::NoError) return d->resRemote.error(); if (d->resLocal.error() != KResolver::NoError) return d->resLocal.error(); return 0; } /* * Performs an asynchronous lookup on the given address(es) */ int KExtendedSocket::startAsyncLookup() { cleanError(); if (d->status > lookupInProgress) return -1; if (d->status == lookupInProgress) // already in progress return 0; /* check socket type flags */ int socktype, familyMask, flags; if (!process_flags(d->flags, socktype, familyMask, flags)) return -2; // perform the global lookup before if (!d->resRemote.isRunning()) { d->resRemote.setFlags(flags); d->resRemote.setFamily(familyMask); d->resRemote.setSocketType(socktype); QObject::connect(&d->resRemote, SIGNAL(finished(KResolverResults)), this, SLOT(dnsResultsReady())); if (!d->resRemote.start()) { setError(IO_LookupError, d->resRemote.error()); return d->resRemote.error(); } } if ((d->flags & passiveSocket) == 0 && !d->resLocal.isRunning()) { /* keep flags, but make this passive */ flags |= KResolver::Passive; d->resLocal.setFlags(flags); d->resLocal.setFamily(familyMask); d->resLocal.setSocketType(socktype); QObject::connect(&d->resLocal, SIGNAL(finished(KResolverResults)), this, SLOT(dnsResultsReady())); if (!d->resLocal.start()) { setError(IO_LookupError, d->resLocal.error()); return d->resLocal.error(); } } // if we are here, there were no errors if (d->resRemote.isRunning() || d->resLocal.isRunning()) d->status = lookupInProgress; // only if there actually is a running lookup else { d->status = lookupDone; emit lookupFinished(d->resRemote.results().count() + d->resLocal.results().count()); } return 0; } void KExtendedSocket::cancelAsyncLookup() { cleanError(); if (d->status != lookupInProgress) return; // what's to cancel? d->status = nothing; d->resLocal.cancel(false); d->resRemote.cancel(false); } int KExtendedSocket::listen(int N) { cleanError(); if ((d->flags & passiveSocket) == 0 || d->status >= listening) return -2; if (d->status < lookupDone) if (lookup() != 0) return -2; // error! if (d->resRemote.error()) return -2; // doing the loop: KResolverResults::const_iterator it; KResolverResults res = d->resRemote.results(); for (it = res.begin(); it != res.end(); ++it) { //kdDebug(170) << "Trying to listen on " << (*it).address().toString() << endl; sockfd = ::socket((*it).family(), (*it).socketType(), (*it).protocol()); if (sockfd == -1) { // socket failed creating //kdDebug(170) << "Failed to create: " << perror << endl; continue; } fcntl(sockfd, F_SETFD, FD_CLOEXEC); if (d->addressReusable) setAddressReusable(sockfd, true); setIPv6Only(d->ipv6only); cleanError(); if (KSocks::self()->bind(sockfd, (*it).address().address(), (*it).length()) == -1) { //kdDebug(170) << "Failed to bind: " << perror << endl; ::close(sockfd); sockfd = -1; continue; } // ok, socket has bound // kdDebug(170) << "Socket bound: " << sockfd << endl; d->status = bound; break; } if (sockfd == -1) { setError(IO_ListenError, errno); //kdDebug(170) << "Listen error - sockfd is -1 " << endl; return -1; } d->status = bound; setFlags(IO_Sequential | IO_Raw | IO_ReadWrite); int retval = KSocks::self()->listen(sockfd, N); if (retval == -1) setError(IO_ListenError, errno); else { d->status = listening; d->qsnIn = new QSocketNotifier(sockfd, QSocketNotifier::Read); QObject::connect(d->qsnIn, SIGNAL(activated(int)), this, SLOT(socketActivityRead())); } return retval == -1 ? -1 : 0; } int KExtendedSocket::accept(KExtendedSocket *&sock) { cleanError(); sock = NULL; if ((d->flags & passiveSocket) == 0 || d->status >= accepting) return -2; if (d->status < listening) if (listen() < 0) return -2; // error! // let's see // if we have a timeout in place, we have to place this socket in non-blocking // mode bool block = blockingMode(); struct sockaddr sa; ksocklen_t len = sizeof(sa); sock = NULL; if (d->timeout.tv_sec > 0 || d->timeout.tv_usec > 0) { fd_set set; setBlockingMode(false); // turn on non-blocking FD_ZERO(&set); FD_SET(sockfd, &set); //kdDebug(170).form("Accepting on %d with %d.%06d second timeout\n", // sockfd, d->timeout.tv_sec, d->timeout.tv_usec); // check if there is anything to accept now int retval = KSocks::self()->select(sockfd + 1, &set, NULL, NULL, &d->timeout); if (retval == -1) { setError(IO_UnspecifiedError, errno); return -1; // system error } else if (retval == 0 || !FD_ISSET(sockfd, &set)) { setError(IO_TimeOutError, 0); return -3; // timeout } } // it's common stuff here int newfd = KSocks::self()->accept(sockfd, &sa, &len); if (newfd == -1) { setError(IO_AcceptError, errno); kdWarning(170) << "Error accepting on socket " << sockfd << ":" << perror << endl; return -1; } fcntl(newfd, F_SETFD, FD_CLOEXEC); //kdDebug(170).form("Socket %d accepted socket %d\n", sockfd, newfd); setBlockingMode(block); // restore blocking mode sock = new KExtendedSocket; sock->d->status = connected; sock->sockfd = newfd; sock->setFlags(IO_Sequential | IO_Raw | IO_ReadWrite | IO_Open | IO_Async); sock->setBufferSize(0, 0); // always unbuffered here. User can change that later return 0; } /* * tries to connect * * FIXME! * This function is critical path. It has to be cleaned up and made faster */ int KExtendedSocket::connect() { cleanError(); if (d->flags & passiveSocket || d->status >= connected) return -2; if (d->status < lookupDone) if (lookup() != 0) return -2; timeval end, now; // Ok, things are a little tricky here // Let me explain // getaddrinfo() will return several different families of sockets // When we have to bind before we connect, we have to make sure we're binding // and connecting to the same family, or things won't work bool doingtimeout = d->timeout.tv_sec > 0 || d->timeout.tv_usec > 0; if (doingtimeout) { gettimeofday(&end, NULL); end.tv_usec += d->timeout.tv_usec; end.tv_sec += d->timeout.tv_sec; if (end.tv_usec > 1000*1000) { end.tv_usec -= 1000*1000; end.tv_sec++; } // kdDebug(170).form("Connection with timeout of %d.%06d seconds (ends in %d.%06d)\n", // d->timeout.tv_sec, d->timeout.tv_usec, end.tv_sec, end.tv_usec); } KResolverResults remote = d->resRemote.results(), local = d->resLocal.results(); KResolverResults::const_iterator it, it2; //kdDebug(170) << "Starting connect to " << host() << '|' << port() // << ": have " << local.count() << " local entries and " // << remote.count() << " remote" << endl; for (it = remote.begin(), it2 = local.begin(); it != remote.end(); ++it) { //kdDebug(170) << "Trying to connect to " << (*it).address().toString() << endl; if (it2 != local.end()) { // //kdDebug(170) << "Searching bind socket for family " << p->ai_family << endl; if ((*it).family() != (*it2).family()) // differing families, scan local for a matching family for (it2 = local.begin(); it2 != local.end(); ++it2) if ((*it).family() == (*it2).family()) break; if ((*it).family() != (*it2).family()) { // no matching families for this //kdDebug(170) << "No matching family for bind socket\n"; it2 = local.begin(); continue; } //kdDebug(170) << "Binding on " << (*it2).address().toString() << " before connect" << endl; errno = 0; sockfd = ::socket((*it).family(), (*it).socketType(), (*it).protocol()); setError(IO_ConnectError, errno); if (sockfd == -1) continue; // cannot create this socket fcntl(sockfd, F_SETFD, FD_CLOEXEC); if (d->addressReusable) setAddressReusable(sockfd, true); setIPv6Only(d->ipv6only); cleanError(); if (KSocks::self()->bind(sockfd, (*it2).address(), (*it2).length())) { //kdDebug(170) << "Bind failed: " << perror << endl; ::close(sockfd); sockfd = -1; continue; } } else { // no need to bind, just create sockfd = ::socket((*it).family(), (*it).socketType(), (*it).protocol()); if (sockfd == -1) { setError(IO_ConnectError, errno); continue; } fcntl(sockfd, F_SETFD, FD_CLOEXEC); if (d->addressReusable) setAddressReusable(sockfd, true); setIPv6Only(d->ipv6only); cleanError(); } // kdDebug(170) << "Socket " << sockfd << " created" << endl; d->status = created; // check if we have to do timeout if (doingtimeout && KSocks::self()->hasWorkingAsyncConnect()) { fd_set rd, wr; setBlockingMode(false); // now try and connect if (KSocks::self()->connect(sockfd, (*it).address(), (*it).length()) == -1) { // this could be EWOULDBLOCK if (errno != EWOULDBLOCK && errno != EINPROGRESS) { //kdDebug(170) << "Socket " << sockfd << " did not connect: " << perror << endl; setError(IO_ConnectError, errno); ::close(sockfd); sockfd = -1; continue; // nope, another error } FD_ZERO(&rd); FD_ZERO(&wr); FD_SET(sockfd, &rd); FD_SET(sockfd, &wr); int retval = KSocks::self()->select(sockfd + 1, &rd, &wr, NULL, &d->timeout); if (retval == -1) { setError(IO_FatalError, errno); continue; // system error } else if (retval == 0) { ::close(sockfd); sockfd = -1; // kdDebug(170) << "Time out while trying to connect to " << // (*it).address().toString() << endl; d->status = lookupDone; setError(IO_TimeOutError, 0); return -3; // time out } // adjust remaining time gettimeofday(&now, NULL); d->timeout.tv_sec = end.tv_sec - now.tv_sec; d->timeout.tv_usec = end.tv_usec - now.tv_usec; if (d->timeout.tv_usec < 0) { d->timeout.tv_usec += 1000*1000; d->timeout.tv_sec--; } // kdDebug(170).form("Socket %d activity; %d.%06d seconds remaining\n", // sockfd, d->timeout.tv_sec, d->timeout.tv_usec); // this means that an event occurred in the socket int errcode; socklen_t len = sizeof(errcode); retval = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (char*)&errcode, &len); if (retval == -1 || errcode != 0) { // socket did not connect //kdDebug(170) << "Socket " << sockfd << " did not connect: " // << strerror(errcode) << endl; ::close(sockfd); sockfd = -1; // this is HIGHLY UNLIKELY if (d->timeout.tv_sec == 0 && d->timeout.tv_usec == 0) { d->status = lookupDone; setError(IO_TimeOutError, 0); return -3; // time out } setError(IO_ConnectError, errcode); continue; } } // getting here means it connected // setBufferSize() takes care of creating the socket notifiers setBlockingMode(true); d->status = connected; setFlags(IO_Sequential | IO_Raw | IO_ReadWrite | IO_Open | IO_Async); setBufferSize(d->flags & inputBufferedSocket ? -1 : 0, d->flags & outputBufferedSocket ? -1 : 0); emit connectionSuccess(); // kdDebug(170) << "Socket " << sockfd << " connected\n"; return 0; } else { // without timeouts if (KSocks::self()->connect(sockfd, (*it).address(), (*it).length()) == -1) { //kdDebug(170) << "Socket " << sockfd << " to " << (*it).address().toString() // << " did not connect: " << perror << endl; setError(IO_ConnectError, errno); ::close(sockfd); sockfd = -1; continue; } d->status = connected; setFlags(IO_Sequential | IO_Raw | IO_ReadWrite | IO_Open | IO_Async); setBufferSize(d->flags & inputBufferedSocket ? -1 : 0, d->flags & outputBufferedSocket ? -1 : 0); emit connectionSuccess(); // kdDebug(170) << "Socket " << sockfd << " connected\n"; return 0; // it connected } } // getting here means no socket connected or stuff like that emit connectionFailed(d->syserror); //kdDebug(170) << "Failed to connect\n"; return -1; } int KExtendedSocket::startAsyncConnect() { cleanError(); // check status if (d->status >= connected || d->flags & passiveSocket) return -2; if (d->status == connecting) // already on async connect return 0; // check if we have to do lookup // if we do, then we'll use asynchronous lookup and use // signal lookupFinished to do connection if (d->status < lookupDone) { QObject::connect(this, SIGNAL(lookupFinished(int)), this, SLOT(startAsyncConnectSlot())); if (d->status < lookupInProgress) return startAsyncLookup(); else return 0; // we still have to wait } // here we have d->status >= lookupDone and <= connecting // we can do our connection d->status = connecting; QGuardedPtr<QObject> p = this; connectionEvent(); if (!p) return -1; // We have been deleted. if (d->status < connecting) return -1; return 0; } void KExtendedSocket::cancelAsyncConnect() { if (d->status != connecting) return; if (sockfd != -1) { // we have a waiting connection if (d->qsnIn) delete d->qsnIn; if (d->qsnOut) delete d->qsnOut; d->qsnIn = d->qsnOut = NULL; ::close(sockfd); sockfd = -1; } d->status = lookupDone; } bool KExtendedSocket::open(int mode) { if (mode != IO_Raw | IO_ReadWrite) return false; // invalid open mode if (d->flags & passiveSocket) return listen() == 0; else if (d->status < connecting) return connect() == 0; else return false; } void KExtendedSocket::close() { if (sockfd == -1 || d->status >= closing) return; // nothing to close // LOCK BUFFER MUTEX if (d->flags & outputBufferedSocket && writeBufferSize() > 0) { // write buffer not empty, go into closing state d->status = closing; if (d->qsnIn) delete d->qsnIn; d->qsnIn = NULL; // we keep the outgoing socket notifier because we want // to send data, but not receive } else { // nope, write buffer is empty // we can close now if (d->qsnIn) delete d->qsnIn; if (d->qsnOut) delete d->qsnOut; d->qsnIn = d->qsnOut = NULL; ::close(sockfd); d->status = done; emit closed(readBufferSize() != 0 ? availRead : 0); } // UNLOCK BUFFER MUTEX } void KExtendedSocket::closeNow() { if (d->status >= done) return; // nothing to close // close the socket delete d->qsnIn; delete d->qsnOut; d->qsnIn = d-&g