Scale Stack 0.3 Developer Documentation

scalestack/network/datagram.h

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.
 */

#ifndef SCALESTACK_NETWORK_DATAGRAM_H
#define SCALESTACK_NETWORK_DATAGRAM_H

#include <memory>
#include <stdint.h>
#include <sys/socket.h>
#include <sys/types.h>

#include <scalestack/event/handler.h>
#include <scalestack/kernel/macros.h>

struct addrinfo;

namespace scalestack
{
namespace network
{

class datagram_provider;
class datagram_service;

class datagram
{
public:

  datagram(kernel::module& module);

  virtual ~datagram();

  virtual void started(void);

  virtual void shutdown(void);

  void stop(void);

  void set_timer(uint64_t milliseconds);

  virtual void timer_expired(void);

  void run_now(void);

  virtual void run(void);

  virtual size_t receive(uint8_t* buffer,
                         size_t size,
                         struct sockaddr& peer,
                         socklen_t peer_size) = 0;

  void consume(size_t size);

  size_t send(uint8_t* buffer,
              size_t size,
              const struct sockaddr& peer,
              socklen_t peer_size);

  size_t send(uint8_t* buffer, size_t size);

  virtual void flush_send(void) = 0;

protected:

  kernel::module& _module;

private:

  datagram(const datagram&);

  datagram& operator=(const datagram&);

  datagram_provider* _datagram_provider;

  friend class datagram_provider;
};

class SCALESTACK_API datagram_provider: public event::handler
{
public:

  datagram_provider(event::handler_service& handler_service,
                    datagram_service& datagram_service,
                    const struct addrinfo* local,
                    const struct addrinfo* peer);

  virtual ~datagram_provider();

  void started();

  void shutdown(void);

  void timer_expired(void);

  void run(void);

  virtual void set_file_descriptor(int file_descriptor);

  void consume(size_t size);

  size_t send(uint8_t* buffer,
              size_t size,
              const struct sockaddr& peer,
              socklen_t peer_size);

  size_t send(uint8_t* buffer, size_t size);

private:

  SCALESTACK_LOCAL
  datagram_provider(const datagram_provider&);

  SCALESTACK_LOCAL
  datagram_provider& operator=(const datagram_provider&);

  void read_ready(int file_descriptor);

  void write_ready(int file_descriptor);

  static const size_t _receive_buffer_max_size = 64 * 1024;

  int _file_descriptor;
  socklen_t _peer_size;
  size_t _receive_buffer_size;
  std::auto_ptr<datagram> _datagram;
  datagram_service& _datagram_service;
  struct sockaddr* _peer;
  struct sockaddr_storage _peer_storage;
  uint8_t _receive_buffer[_receive_buffer_max_size];
};

/*
 * Public datagram methods.
 */

inline datagram::datagram(kernel::module& module):
  _module(module),
  _datagram_provider()
{
}

inline datagram::~datagram()
{
}

inline void datagram::started(void)
{
}

inline void datagram::shutdown(void)
{
  _datagram_provider->stop();
}

inline void datagram::stop(void)
{
  _datagram_provider->stop();
}

inline void datagram::set_timer(uint64_t milliseconds)
{
  _datagram_provider->set_timer(milliseconds);
}

inline void datagram::timer_expired(void)
{
}

inline void datagram::run_now(void)
{
  _datagram_provider->run_now();
}

inline void datagram::run(void)
{
}

inline void datagram::consume(size_t size)
{
  _datagram_provider->consume(size);
}

inline size_t datagram::send(uint8_t* buffer,
                             size_t size,
                             const struct sockaddr& peer,
                             socklen_t peer_size)
{
  return _datagram_provider->send(buffer, size, peer, peer_size);
}

inline size_t datagram::send(uint8_t* buffer, size_t size)
{
  return _datagram_provider->send(buffer, size);
}

/*
 * Public datagram_provider methods.
 */

inline void datagram_provider::shutdown(void)
{
  _datagram->shutdown();
}

inline void datagram_provider::timer_expired(void)
{
  _datagram->timer_expired();
}

inline void datagram_provider::run(void)
{
  _datagram->run();
}

inline void datagram_provider::write_ready(int)
{
  _datagram->flush_send();
}

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

#endif /* SCALESTACK_NETWORK_DATAGRAM_H */

---