Scale Stack 0.3 Developer Documentation

scalestack/network/ip/udp/socket_service.cc

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Chris Behrens
 *
 * 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/datagram.h>
#include <scalestack/network/datagram_service.h>
#include <scalestack/network/ip/address_service.h>
#include <scalestack/network/ip/udp/socket_service.h>

using namespace std;

namespace scalestack
{
namespace network
{
namespace ip
{
namespace udp
{

class socket_address_service: public ip::address_service
{
public:

  socket_address_service(kernel::module& module,
                         socket_service& socket_service,
                         bool local);

  bool add_addresses(const struct addrinfo* addresses);

private:

  bool _local;
  socket_service& _socket_service;
};

/*
 * Public methods.
 */

void socket_service::local_options(kernel::module& module,
                                   const std::string& addresses)
{
  module.add_option("addresses", _("List of host:port pairs to bind to."),
                    "[HOST:]PORT[,[HOST:]PORT]...", addresses);
}

void socket_service::peer_options(kernel::module& module,
                                  const std::string& addresses)
{
  module.add_option("addresses", _("List of host:port pairs to send to."),
                    "HOST[:PORT][,HOST[:PORT]]...", addresses);
}

socket_service::socket_service(kernel::module& module,
                               std::auto_ptr<datagram_service> datagram_service,
                               const std::string& default_host,
                               const std::string& default_port):
  kernel::service(module),
  _datagram_service(datagram_service),
  _default_host(default_host),
  _default_port(default_port),
  _handler_service(module)
{
}

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

void socket_service::add_socket(const struct addrinfo* local,
                                const struct addrinfo* peer)
{
  char host_name[NI_MAXHOST];
  char port_name[NI_MAXSERV];
  int return_code;

  if (local != NULL)
  {
    return_code = getnameinfo(local->ai_addr,
                              local->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(_("UDP socket trying to bind to %s:%s"), host_name,
                     port_name);
  }

  if (peer != NULL)
  {
    return_code = getnameinfo(peer->ai_addr,
                              peer->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(_("UDP socket with peer %s:%s"), host_name, port_name);
  }

  auto_ptr<datagram_provider> new_socket(
    new datagram_provider(_handler_service, *_datagram_service, local, peer));
  new_socket->start();
  new_socket.release();

  if (local != NULL)
    _module.log_notice(_("UDP socket bound to %s:%s"), host_name, port_name);
}

void socket_service::add_local_sockets(void)
{
  add_local_sockets(_module.get_option("addresses").get_value());
}

void socket_service::add_local_sockets(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_DGRAM;
  address_options.ai_protocol = IPPROTO_UDP;

  socket_address_service address_service(_module, *this, true);
  address_service.parse_addresses(addresses, true, _default_host,
                                  address_options);
}

void socket_service::add_peer_sockets(void)
{
  add_peer_sockets(_module.get_option("addresses").get_value());
}

void socket_service::add_peer_sockets(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_DGRAM;
  address_options.ai_protocol = IPPROTO_UDP;

  socket_address_service address_service(_module, *this, false);
  address_service.parse_addresses(addresses, false, _default_port,
                                  address_options);
}

/*
 * Public methods for address_service.
 */

socket_address_service::socket_address_service(
  kernel::module& module, socket_service& socket_service, bool local):
  ip::address_service(module),
  _local(local),
  _socket_service(socket_service)
{
}

bool socket_address_service::add_addresses(const struct addrinfo* addresses)
{
  if (!_local)
  {
    _socket_service.add_socket(NULL, addresses);
    return true;
  }

  bool added = false;
  for (; addresses != NULL; addresses = addresses->ai_next)
  {
    try
    {
      _socket_service.add_socket(addresses, NULL);
      added = true;
    }
    catch (exception&)
    {
      /* We only require one local address from the list to succeed. */
    }
  }

  if (!added)
    _module.log_fatal(_("Could not add any UDP sockets"));

  return true;
}

} /* namespace udp */
} /* namespace ip */
} /* namespace network */
} /* namespace scalestack */

---