Scale Stack 0.3 Developer Documentation

scalestack/echo/flood/stream.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 <scalestack/echo/flood/flood.h>
#include <scalestack/echo/flood/stream.h>
#include <scalestack/echo/flood/stream_service.h>
#include <scalestack/kernel/module.h>
#include <scalestack/kernel/option.h>

namespace scalestack
{
namespace echo
{
namespace flood
{

/*
 * Public methods.
 */

stream::stream(stream_service& stream_service):
  network::stream(stream_service.get_module()),
  _flush(_module.get_option("flush").get_bool_value()),
  _iterations(_module.get_option("iterations").get_size_value()),
  _write_size(_module.get_option("write_size").get_size_value()),
  _read_offset(),
  _write_offset(),
  _stream_service(stream_service)
{
}

stream::~stream()
{
  _stream_service.remove_stream();
}

void stream::connected(void)
{
  flush_write();
}

size_t stream::read(uint8_t* buffer, size_t size)
{
  if (memcmp(random_buffer + _read_offset, buffer, size))
    _module.log_fatal(_("Read data did not match what was sent"));

  _read_offset += size;

  if (_read_offset == random_buffer_size)
  {
    if (_iterations == 0 || --_iterations > 0)
    {
      _read_offset = 0;
      _write_offset = 0;

      if (_module.get_option("reconnect").get_bool_value())
        reconnect();
      else
        flush_write();
    }
    else
      stop();
  }

  return size;
}

void stream::flush_write(void)
{
  size_t write_size;
  size_t written;
  bool flush;

  do
  {
    write_size = random_buffer_size - _write_offset;
    if (write_size == 0)
      break;
    if (_write_size > 0 && _write_size < write_size)
    {
      write_size = _write_size;
      flush = _flush;
    }
    else
      flush = true;

    written = write(random_buffer + _write_offset, write_size, flush);
    _write_offset += written;
  }
  while (write_size == written);
}

} /* namespace flood */
} /* namespace echo */
} /* namespace scalestack */

---