Scale Stack 0.3 Developer Documentation

scalestack/network/listener.cc

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "config.h"

#include <cerrno>
#include <cstring>
#include <exception>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>

#include <scalestack/kernel/module.h>
#include <scalestack/network/listener.h>
#include <scalestack/network/stream_service.h>

using namespace std;

namespace scalestack
{
namespace network
{

/*
 * Public methods.
 */

listener::listener(event::handler_service& handler_service,
                   const struct addrinfo& local,
                   int backlog,
                   stream_service_provider& stream_service_provider):
  event::handler(handler_service),
  _stream_service_provider(stream_service_provider)
{
  int file_descriptor = socket(local.ai_family,
                               local.ai_socktype,
                               local.ai_protocol);
  if (file_descriptor == -1)
    _module.log_fatal(_("Failed socket: %s:%d"), strerror(errno), errno);

  int option = 1;
  int return_code = setsockopt(file_descriptor,
                               SOL_SOCKET,
                               SO_REUSEADDR,
                               &option,
                               sizeof(option));
  if (return_code == -1)
  {
    close(file_descriptor);
    _module.log_fatal(_("Failed setsockopt: %s:%d"), strerror(errno), errno);
  }

  return_code = ::bind(file_descriptor, local.ai_addr, local.ai_addrlen);
  if (return_code == -1)
  {
    close(file_descriptor);

    if (errno == EADDRINUSE)
    {
      _module.log_info(_("Failed bind, local address already in use"));
      throw exception();
    }

    _module.log_fatal(_("Failed bind: %s:%d"), strerror(errno), errno);
  }

  return_code = ::listen(file_descriptor, backlog);
  if (return_code == -1)
  {
    close(file_descriptor);
    _module.log_fatal(_("Failed listen: %s:%d"), strerror(errno), errno);
  }

  set_file_descriptor(file_descriptor);
  watch_read();
}

listener::~listener()
{
}

void listener::read_ready(int file_descriptor)
{
  while (true)
  {
    struct sockaddr_storage peer_storage;
    struct sockaddr& peer = reinterpret_cast<struct sockaddr&>(peer_storage);
    socklen_t peer_size = sizeof(peer_storage);

    int new_file_descriptor = ::accept(file_descriptor, &peer, &peer_size);
    if (new_file_descriptor == -1)
    {
      if (errno == EAGAIN)
      {
        watch_read();
        return;
      }
      else if (errno == EINTR)
        continue;
      else if (errno == EMFILE)
      {
        _module.log_error(_("Accept failed due to too many open files"));
        watch_read();
        return;
      }

      _module.log_fatal(_("Failed accept: %s:%d"), strerror(errno), errno);
    }

    try
    {
      _stream_service_provider.add_accepted(new_file_descriptor, peer,
                                            peer_size);
    }
    catch (exception& e)
    {
      _module.log_error(_("Accept failed: %s"), e.what());
      close(new_file_descriptor);
    }
  }
}

} /* namespace network */
} /* namespace scalestack */

---