Scale Stack 0.3 Developer Documentation

scalestack/network/ip/tcp/listener_service.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 <cstring>
#include <exception>
#include <memory>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>

#include <scalestack/kernel/module.h>
#include <scalestack/kernel/option.h>
#include <scalestack/network/ip/address_service.h>
#include <scalestack/network/ip/tcp/listener_service.h>
#include <scalestack/network/listener.h>
#include <scalestack/network/stream_service.h>

using namespace std;

namespace scalestack
{
namespace network
{
namespace ip
{
namespace tcp
{

class listener_address_service: public ip::address_service
{
public:

  listener_address_service(kernel::module& module,
                           event::handler_service& _handler_service,
                           stream_service_provider& _stream_service_provider);

  bool add_addresses(const struct addrinfo* addresses);

private:

  event::handler_service& _handler_service;
  stream_service_provider& _stream_service_provider;
};

/*
 * Public methods.
 */

void listener_service::options(kernel::module& module,
                               const std::string& addresses)
{
  module.add_option("addresses", _("List of host:port pairs to listen on."),
                    "[HOST:]PORT[,[HOST:]PORT]...", addresses);
  module.add_option("backlog", _("Backlog value to use for listen(2)."),
                    "BACKLOG", "64");
}

listener_service::listener_service(kernel::module& module,
  std::auto_ptr<stream_service_provider> stream_service_provider,
  const std::string& default_host):
  network::listener_service(module, stream_service_provider),
  _default_host(default_host)
{
}

listener_service::~listener_service()
{
  _handler_service.stop();
}

void listener_service::add_listeners(void)
{
  add_listeners(_module.get_option("addresses").get_value());
}

void listener_service::add_listeners(const std::string& addresses)
{
  struct addrinfo address_options;

  memset(&address_options, 0, sizeof(struct addrinfo));
  address_options.ai_flags  = AI_PASSIVE;
  address_options.ai_family = AF_UNSPEC;
  address_options.ai_socktype = SOCK_STREAM;
  address_options.ai_protocol = IPPROTO_TCP;

  listener_address_service address_service(_module, _handler_service,
                                           *_stream_service_provider);
  address_service.parse_addresses(addresses, true, _default_host,
                                  address_options);
}

/*
 * Public methods for address_service.
 */

listener_address_service::listener_address_service(
  kernel::module& module,
  event::handler_service& handler_service,
  stream_service_provider& stream_service_provider):
  ip::address_service(module),
  _handler_service(handler_service),
  _stream_service_provider(stream_service_provider)
{
}

bool listener_address_service::add_addresses(const struct addrinfo* addresses)
{
  char host_name[NI_MAXHOST];
  char port_name[NI_MAXSERV];
  int return_code;
  bool added = false;

  for (; addresses != NULL; addresses = addresses->ai_next)
  {
    return_code = getnameinfo(addresses->ai_addr,
                              addresses->ai_addrlen,
                              host_name, NI_MAXHOST,
                              port_name, NI_MAXSERV,
                              NI_NUMERICHOST | NI_NUMERICSERV);
    if (return_code != 0)
      _module.log_fatal(_("Failed getnameinfo: %s"), gai_strerror(return_code));

    _module.log_info(_("TCP listener trying to bind to %s:%s"), host_name,
                     port_name);
    try
    {
      auto_ptr<listener> new_listener(
        new listener(_handler_service,
                     *addresses,
                     _module.get_option("backlog").get_int_value(),
                     _stream_service_provider));
      new_listener->start();
      new_listener.release();
      added = true;
      _module.log_notice(_("TCP listener bound to %s:%s"), host_name,
                         port_name);
    }
    catch (exception&)
    {
      /* We only require one address from the list to succeed. */
    }
  }

  if (!added)
    _module.log_fatal(_("Could not add any TCP listeners"));

  return true;
}

} /* namespace tcp */
} /* namespace ip */
} /* namespace network */
} /* namespace scalestack */

---