---

FileDescriptor.cc

Go to the documentation of this file.

/**************************************************************************
 Copyright (c) 2000-2001, Tony Garnock-Jones
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
       with the distribution.

     * Neither the names of the copyright holders nor the names of this
       software's contributors may be used to endorse or promote
       products derived from this software without specific prior
       written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**************************************************************************/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>

#include <FileDescriptor.h>

#define WANT_FD_DEBUG_MESSAGES  0

#ifndef MAX
#define MAX(a, b) ((a > b) ? a : b)
#endif

#ifndef MIN
#define MIN(a, b) ((a < b) ? a : b)
#endif

///////////////////////////////////////////////////////////////////////////

FileDescriptor::FileDescriptor(ref<FileDescriptorManager> const &_fdMgr, int _fd)
  : fdMgr(_fdMgr),
    fd(_fd),
    buflen(0),
    pos(0),
    readCallback(),
    writeCallback()
{
  // Don't call updateCallbacks here. Wait until someone actually
  // *sets* a callback. This because: if we're registered with the
  // fdMgr while still being constructed, and our subclass'
  // constructor throws an exception, then when close() is called, the
  // fdMgr will be told to remove its reference to us. But since *at
  // that time* it's the only reference available, it will decrement
  // to zero, and call our destructor again, before the outer
  // invocation of the dtor has finished. Leading to much mess.
  //
  // This applies to subclass ctors too: don't call updateCallbacks()
  // or set{Read,Write}Callback() from them either - otherwise you
  // will end up with the same problem if an exception is thrown
  // during construction.
#if WANT_FD_DEBUG_MESSAGES
  fprintf(stderr, "%u: FileDescriptor::FileDescriptor on fd %d\n", (unsigned) time(NULL), fd);
#endif
}

FileDescriptor::~FileDescriptor()
{
#if WANT_FD_DEBUG_MESSAGES
  if (fd == -1) {
    // This is fine.
    fprintf(stderr, "%u: FileDescriptor::~FileDescriptor (already closed.)\n",
            (unsigned) time(NULL));
  } else {
    fprintf(stderr, "%u: FileDescriptor::~FileDescriptor on fd %d\n", (unsigned) time(NULL), fd);
  }
#endif
  this->close();
}

///////////////////////////////////////////////////////////////////////////

bool FileDescriptor::fillBuffer() {
  while (pos >= buflen) {
    int nread = lowlevel_read(fd, buf, sizeof(buf));

    //fprintf(stderr, "%d rres %d errno %d len %d\n", fd, nread, errno, sizeof(buf));

    if (nread == 0) {
      // End-of-file.
      char buf[20];
      sprintf(buf, "%d", fd);
      throw EndOfFile("EOF (graceful) while reading fd " + string(buf));
    }

    if (nread == -1) {
      switch (errno) {
#ifndef __WIN32__
        // Windows has WSAECONNRESET instead. See SocketDescriptor::lowlevel_read.
        case ECONNRESET: {
          char buf[20];
          sprintf(buf, "%d", fd);
          throw EndOfFile("EOF (connection reset) while reading fd " + string(buf));
        }
#endif

        case EINTR:
          continue;

        case EAGAIN:
          return false;

        default:
          throw Exception("EOF due to error condition while reading", errno);
      }
    }

    buflen = nread;
    pos = 0;
  }

  return true;
}

void FileDescriptor::block(bool forRead, bool forWrite) {
  fd_set fds;
  FD_ZERO(&fds);
  FD_SET(fd, &fds);

  select(fd + 1, forRead ? &fds : NULL, forWrite ? &fds : NULL, &fds, NULL);
}

void FileDescriptor::close() {
  if (isOpen()) {
#if WANT_FD_DEBUG_MESSAGES
    fprintf(stderr, "FileDescriptor::close() - closing FD %d\n", fd);
#endif

    int oldfd = fd;
    fd = -1;

    lowlevel_close(oldfd);
    fdMgr->remove(oldfd);
    fdMgr = 0;
  }
}

bool FileDescriptor::setNonBlocking(bool on) {
  if (!isOpen())
    return false;

  int status;

#ifdef __WIN32__
  // Bloody Windows.
  {
    int non_block = (on ? 1 : 0);
    ioctlsocket(fd, FIONBIO, (u_long FAR *) &non_block);
  }
#else
  // POSIX.
  if (on) {
    status = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  } else {
    status = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_NONBLOCK);
  }
#endif

  return (status != -1);
}

///////////////////////////////////////////////////////////////////////////

void FileDescriptor::updateCallbacks() {
  fdMgr->update(this,
                readCallback.callback.valid(),
                writeCallback.callback.valid());
}

void FileDescriptor::setReadCallback(ref<Callback> const &cb, Callback::Method cbm) {
  readCallback.callback = cb;
  readCallback.callbackMethod = cbm;
  updateCallbacks();
}

void FileDescriptor::setWriteCallback(ref<Callback> const &cb, Callback::Method cbm) {
  writeCallback.callback = cb;
  writeCallback.callbackMethod = cbm;
  updateCallbacks();
}

void FileDescriptor::clearReadCallback() {
  setReadCallback(0, 0);
}

void FileDescriptor::clearWriteCallback() {
  setWriteCallback(0, 0);
}

void FileDescriptor::fireReadCallback() {
  if (readCallback.callback.valid()) {
    ((readCallback.callback)->*(readCallback.callbackMethod))(this);
  }
}

void FileDescriptor::fireWriteCallback() {
  if (writeCallback.callback.valid()) {
    ((writeCallback.callback)->*(writeCallback.callbackMethod))(this);
  }
}

///////////////////////////////////////////////////////////////////////////

int FileDescriptor::lowlevel_read(int fd, char *buf, int len) {
  return ::read(fd, buf, len);
}

int FileDescriptor::lowlevel_write(int fd, char const *buf, int len) {
  return ::write(fd, buf, len);
}

int FileDescriptor::lowlevel_close(int fd) {
  return ::close(fd);
}

ref<FileDescriptorManager> const &FileDescriptor::getFdMgr() const
{
  return fdMgr;
}

int FileDescriptor::read(char *inbuf, int len, bool complete = false) {
  int sofar = 0;

  while (sofar < len) {
    int tocopy = MIN(len - sofar, buflen - pos);

    if (tocopy == 0) {
      if (!fillBuffer()) {
        if (complete)
          block(true, false);
        else
          return sofar;
      }
      continue;
    }

    memcpy(inbuf, buf, tocopy);
    inbuf += tocopy;
    sofar += tocopy;
    pos += tocopy;
  }

  return sofar;
}

int FileDescriptor::write(char const *outbuf, int len, bool complete = false) {
  int sofar = 0;

  while (sofar < len) {
    int result = lowlevel_write(fd, outbuf, len - sofar);

    if (result == -1) {
      if (errno == EINTR) {
        continue;
      }

      if (errno == EAGAIN) {
        if (complete)
          block(false, true);
        else
          return sofar;
        continue;
      }

      throw Exception("EOF due to error condition writing", errno);
    }

    outbuf += result;
    sofar += result;
  }

  return sofar;
}

///////////////////////////////////////////////////////////////////////////

FileDescriptorManager::FileDescriptorManager()
  : allFds(),
    countRegistered(0),
    maxFd(-1)
{
  FD_ZERO(&readFds);
  FD_ZERO(&writeFds);
}

void FileDescriptorManager::update(ref<FileDescriptor> const &fd, bool forRead, bool forWrite)
{
  int fdnum = fd->getFd();

  if (fdnum != -1) {
    if (fdnum >= maxFd) {
      maxFd = fdnum;
      allFds.resize(maxFd + 1);
    }

    if (allFds[fdnum].get() == 0)
      countRegistered++;

    allFds[fdnum] = fd;
    if (forRead) FD_SET(fdnum, &readFds); else FD_CLR(fdnum, &readFds);
    if (forWrite) FD_SET(fdnum, &writeFds); else FD_CLR(fdnum, &writeFds);
  }
}

void FileDescriptorManager::remove(int fdnum) {
  // Don't "remove" an entry for a file descriptor that is
  //    - invalid (== -1)
  //    - out of range (> maxFd)
  //    - not registered with us (!allFds[fdnum].valid())
  if (fdnum != -1 && fdnum <= maxFd && allFds[fdnum].valid()) {
    allFds[fdnum] = 0;
    countRegistered--;

    FD_CLR(fdnum, &readFds);
    FD_CLR(fdnum, &writeFds);
  }
}

void FileDescriptorManager::closeAll()
{
  for (unsigned int fdnum = 0; fdnum < allFds.size(); fdnum++) {
    ref<FileDescriptor> &fd(allFds[fdnum]);

    if (fd.valid()) {
      fd->close();
      allFds[fdnum] = 0;
    }
  }

  FD_ZERO(&readFds);
  FD_ZERO(&writeFds);
  countRegistered = 0;
  maxFd = -1;
}

void FileDescriptorManager::fillFdSet(fd_set *rfds, fd_set *wfds) const
{
  for (unsigned int fdnum = 0; fdnum < allFds.size(); fdnum++) {
    if (allFds[fdnum].valid()) {
      if (FD_ISSET(fdnum, &readFds)) FD_SET(fdnum, rfds);
      if (FD_ISSET(fdnum, &writeFds)) FD_SET(fdnum, wfds);
    }
  }
}

void FileDescriptorManager::processFdSet(fd_set *rfds, fd_set *wfds)
{
  for (unsigned int fdnum = 0; fdnum < allFds.size(); fdnum++) {
    ref<FileDescriptor> &fd(allFds[fdnum]);

    if (fd.valid()) {
      try {
        if (FD_ISSET(fdnum, rfds)) {
          fd->fireReadCallback();
        }
      } catch (FileDescriptor::Exception &fe) {
        fprintf(stderr, "processFdSet: fireReadCallback threw: %s (%d %s)\n",
                fe.what(), fe.getErrno(), strerror(fe.getErrno()));
        throw;  // we don't want to swallow this exception.
      }

      try {
        if (FD_ISSET(fdnum, wfds)) {
          fd->fireWriteCallback();
        }
      } catch (FileDescriptor::Exception &fe) {
        fprintf(stderr, "processFdSet: fireWriteCallback threw: %s (%d %s)\n",
                fe.what(), fe.getErrno(), strerror(fe.getErrno()));
        throw;  // we don't want to swallow this exception.
      }

    }
  }
}

bool FileDescriptorManager::poll(struct timeval const *timeout) {
  fd_set rfds;
  fd_set wfds;
  fd_set efds;

  // make a non-const copy of "timeout", to preserve the original, if there is one
  struct timeval _timeout;
  if (timeout != NULL) {
    _timeout = *timeout;
  }

  if (countRegistered == 0) {
    throw FileDescriptor::Exception("poll() called on empty FileDescriptorManager");
  }

  memcpy(&rfds, &readFds, sizeof(rfds));
  memcpy(&wfds, &writeFds, sizeof(wfds));
  memcpy(&efds, &readFds, sizeof(efds));

  int selectResult = select(maxFd + 1, &rfds, &wfds, &efds, timeout ? &_timeout : NULL);

  if (selectResult == -1) {
    int errnoCopy = errno;
    throw FileDescriptor::Exception("Error in select()", errnoCopy);
  }

  if (selectResult == 0) {
    // Timed out.
    return false;
  }

  // Regular work available.
  processFdSet(&rfds, &wfds);
  return true;
}

void FileDescriptorManager::mainloop() {
  while (true) {
    poll(NULL);
  }
}

---