path: root/tdecore/network/kstreamsocket.cpp

/*
 *  Copyright (C) 2003 Thiago Macieira <thiago.macieira@kdemail.net>
 *
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included 
 *  in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <config.h>

#include <tqsocketnotifier.h>
#include <tqdatetime.h>
#include <tqtimer.h>
#include <tqguardedptr.h>

#include "tdesocketaddress.h"
#include "kresolver.h"
#include "tdesocketdevice.h"
#include "kstreamsocket.h"

using namespace KNetwork;

class KNetwork::KStreamSocketPrivate
{
public:
  KResolverResults::ConstIterator local, peer;
  TQTime startTime;
  TQTimer timer;

  int timeout;

  inline KStreamSocketPrivate()
    : timeout(0)
  { }
};

KStreamSocket::KStreamSocket(const TQString& node, const TQString& service,
			     TQObject* parent, const char *name)
  : KClientSocketBase(parent, name), d(new KStreamSocketPrivate)
{
  peerResolver().setNodeName(node);
  peerResolver().setServiceName(service);
  peerResolver().setFamily(KResolver::KnownFamily);
  localResolver().setFamily(KResolver::KnownFamily);

  setSocketOptions(socketOptions() & ~Blocking);

  TQObject::connect(&d->timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timeoutSlot()));
}

KStreamSocket::~KStreamSocket()
{
  delete d;
  // KClientSocketBase's destructor closes the socket
}

int KStreamSocket::timeout() const
{
  return d->timeout;
}

int KStreamSocket::remainingTimeout() const
{
  if (state() != Connecting)
    return timeout();
  if (timeout() <= 0)
    return 0;

  return timeout() - d->startTime.elapsed();
}

void KStreamSocket::setTimeout(int msecs)
{
  d->timeout = msecs;

  if (state() == Connecting)
    d->timer.changeInterval(msecs);
}

bool KStreamSocket::bind(const TQString& node, const TQString& service)
{
  if (state() != Idle)
    return false;

  if (!node.isNull())
    localResolver().setNodeName(node);
  if (!service.isNull())
    localResolver().setServiceName(service);
  return true;
}

bool KStreamSocket::connect(const TQString& node, const TQString& service)
{
  if (state() == Connected)
    return true;		// already connected

  if (state() > Connected)
    return false;		// can't do much here

  if (!node.isNull())
    peerResolver().setNodeName(node);
  if (!service.isNull())
    peerResolver().setServiceName(service);

  if (state() == Connecting && !blocking())
    {
      setError(IO_ConnectError, InProgress);
      emit gotError(InProgress);
      return true;		// we're already connecting
    }

  if (state() < HostFound)
    {
      // connection hasn't started yet
      if (!blocking())
	{
	  TQObject::connect(this, TQ_SIGNAL(hostFound()), TQ_SLOT(hostFoundSlot()));
	  return lookup();
	}

      // blocking mode
      if (!lookup())
	return false;		// lookup failure
    }

  /*
   * lookup results are available here
   */

  if (timeout() > 0)
    {
      if (!blocking() && !d->timer.isActive())
	d->timer.start(timeout(), true);
      else
	{
	  // blocking connection with timeout
	  // this must be handled as a special case because it requires a
	  // non-blocking socket

	  d->timer.stop();	// no need for a timer here

	  socketDevice()->setBlocking(false);
	  while (true)
	    {
	      connectionEvent();
	      if (state() < Connecting)
		return false;	// error connecting
	      if (state() == Connected)
		return true;	// connected!

	      if (remainingTimeout() <= 0)
		{
		  // we've timed out
		  timeoutSlot();
		  return false;
		}

	      if (socketDevice()->error() == InProgress)
		{
		  bool timedout;
		  socketDevice()->poll(remainingTimeout(), &timedout);
		  if (timedout)
		    {
		      timeoutSlot();
		      return false;
		    }
		}
	    }
	}
    }

  connectionEvent();
  return error() == NoError;
}

bool KStreamSocket::connect(const KResolverEntry& entry)
{
  return KClientSocketBase::connect(entry);
}

void KStreamSocket::hostFoundSlot()
{
  TQObject::disconnect(this, TQ_SLOT(hostFoundSlot()));
  if (timeout() > 0)
    d->timer.start(timeout(), true);
  TQTimer::singleShot(0, this, TQ_SLOT(connectionEvent()));
}

void KStreamSocket::connectionEvent()
{
  if (state() != HostFound && state() != Connecting)
    return;			// nothing to do

  const KResolverResults& peer = peerResults();
  if (state() == HostFound)
    {
      d->startTime.start();

      setState(Connecting);
      emit stateChanged(Connecting);
      d->peer = peer.begin();
      d->local = localResults().begin(); // just to be on the safe side
    }

  while (d->peer != peer.end())
    {
      const KResolverEntry &r = *d->peer;

      if (socketDevice()->socket() != -1)
	{
	  // we have an existing file descriptor
	  // this means that we've got activity in it (connection result)
	  if (socketDevice()->connect(r) && socketDevice()->error() == NoError)
	    {
	      // yes, it did connect!
	      connectionSucceeded(r);
	      return;
	    }
	  else if (socketDevice()->error() == InProgress)
	    // nope, still in progress
	    return;

	  // no, the socket failed to connect
	  copyError();
	  socketDevice()->close();
	  ++d->peer;
	  continue;
	}

      // try to bind
      if (!bindLocallyFor(r))
	{
	  // could not find a matching family
	  ++d->peer;
	  continue;
	}

      {
	bool skip = false;
	emit aboutToConnect(r, skip);
	if (skip)
	  {
	    ++d->peer;
	    continue;
	  }
      }

      if (socketDevice()->connect(r) || socketDevice()->error() == InProgress)
	{
	  // socket is attempting to connect
	  if (socketDevice()->error() == InProgress)
	    {
	      TQSocketNotifier *n = socketDevice()->readNotifier();
	      TQObject::connect(n, TQ_SIGNAL(activated(int)),
			       this, TQ_SLOT(connectionEvent()));
	      n->setEnabled(true);

	      n = socketDevice()->writeNotifier();
	      TQObject::connect(n, TQ_SIGNAL(activated(int)),
			       this, TQ_SLOT(connectionEvent()));
	      n->setEnabled(true);

	      return;		// wait for activity
	    }

	  // socket has connected
	  connectionSucceeded(r);
	  return;
	}

      // connection failed
      // try next
      copyError();
      socketDevice()->close();
      ++d->peer;
    }

  // that was the last item
  socketDevice()->setSocketOptions(socketOptions());
  setState(Idle);
  emit stateChanged(Idle);
  emit gotError(error());
  return;
}

void KStreamSocket::timeoutSlot()
{
  if (state() != Connecting)
    return;

  // halt the connections
  socketDevice()->close();	// this also kills the notifiers

  setError(IO_TimeOutError, Timeout);
  setState(HostFound);
  emit stateChanged(HostFound);

  TQGuardedPtr<KStreamSocket> that = this;
  emit gotError(Timeout);
  if (!that.isNull())
    emit timedOut();
}

bool KStreamSocket::bindLocallyFor(const KResolverEntry& peer)
{
  const KResolverResults& local = localResults();

  if (local.isEmpty())
    // user doesn't want to bind to any specific local address
    return true;

  bool foundone = false;
  // scan the local resolution for a matching family
  for (d->local = local.begin(); d->local != local.end(); ++d->local)
    if ((*d->local).family() == peer.family())
      {
	// found a suitable address!
	foundone = true;

	if (socketDevice()->bind(*d->local))
	  return true;
      }
  
  if (!foundone)
    {
      // found nothing
      setError(IO_BindError, NotSupported);
      emit gotError(NotSupported);
    }
  else
    copyError();
  return false;
}

void KStreamSocket::connectionSucceeded(const KResolverEntry& peer)
{
  TQObject::disconnect(socketDevice()->readNotifier(), 0, this, TQ_SLOT(connectionEvent()));
  TQObject::disconnect(socketDevice()->writeNotifier(), 0, this, TQ_SLOT(connectionEvent()));

  resetError();
  setFlags(IO_Sequential | IO_Raw | IO_ReadWrite | IO_Open | IO_Async);
  setState(Connected);
  socketDevice()->setSocketOptions(socketOptions());
  d->timer.stop();
  emit stateChanged(Connected);
  
  if (!localResults().isEmpty())
    emit bound(*d->local);
  emit connected(peer);
}

#include "kstreamsocket.moc"