abstract_socket.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2013 Evidence Srl - www.evidence.eu.com
 *
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 * 
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "abstract_socket.hpp"

namespace net {

/**
 * @brief Receive operation
 *
 * This function sendsendsensendsendsendcare of synchronization
 * with any other asynchronous operations.
 * Note: it can block the caller, because it calls __receive() which
 * continues receiving until the given number of bytes have been received.
 * @param buf Pointer where received data must be put
 * @param size Size of data to be received
 * @return Number of bytes actually received
 * @exception runtime_error in case of too small buffer
 *
 * Example of usage:
 * <code>
 *              std::array<char, 5> buf;
 *              AbstractSocket::receive(net::buffer(b), 3);
 * </code>
 */
int AbstractSocket::receive (struct __buffer buf, std::size_t size)
{
        int ret;
        if (buf.size_ == 0 || size > buf.size_){
                ERROR("Wrong buffer size!");
                throw std::runtime_error ("Wrong buffer size");
        }
        receive_lock_.lock();
        try {
                ret = __receive(buf.ptr_, size);
        } catch (...) {
                ERROR("Receive error!");
        }
        
        receive_lock_.unlock();
        return ret;
}

/**
 * @brief Send operation
 *
 * This function sends data to the socket taking care of synchronization
 * with any other asynchronous operations.
 * Note: it can block the caller, because it calls __send() which
 * continues writing until the given number of bytes have been written.
 * @param buf Pointer to data to be written
 * @param size Size of data to be written
 * @return Number of bytes actually written
 * @exception runtime_error in case of too small buffer
 *
 * Example of usage:
 * <code>
 *              std::array<char, 5> buf;
 *              AbstractSocket::send(net::buffer(b), 3);
 * </code>
 */
int AbstractSocket::send (struct __buffer buf, std::size_t size)
{
        int ret;
        if (buf.size_ == 0 || size > buf.size_){
                ERROR("Wrong buffer size!");
                throw std::runtime_error ("Wrong buffer size");
        }
        send_lock_.lock();
        try {
                ret = __send(buf.ptr_, size);
        } catch (...) {
                ERROR("Send error!");
        }
        
        send_lock_.unlock();
        return ret;

}

/**
 * \brief Low-level receive
 *
 * This method is private because it is meant to be used through the other receive()
 * method.
 * Note: it can block the caller, because it continues receiving until the given
 * number of bytes have been received.
 * @param buffer Pointer to the buffer where received bytes must be stored
 * @param size Number of bytes to be received
 * @exception runtime_error if the read() returns an error
 * @return The number of actually received bytes or -1 in case of error
 */
int AbstractSocket::__receive (void* buffer, size_t size)
{
        size_t remaining = size;
        while (remaining > 0) {
                ssize_t ret = socket_->read (((char*)buffer)+(size-remaining),
                    remaining);
                if (ret == 0){
                        // End of file reached
                        DEBUG("End of file reached");
                        break;
                } else if (ret < 0) {
                        ERROR("Receive error");
                        throw std::runtime_error ("Receive error");
                        return -1;
                }
                remaining -= ret;
        }
        return (size-remaining);
}



/**
 * \brief Low-level send
 *
 * This method is private because it is meant to be used through the other
 * send() method.
 * Note: it can block the caller, because it continues writing until the
 * given number of bytes have been written.
 * @param buffer Pointer to the buffer containing bytes to be written
 * @param size Number of bytes to be written
 * @exception runtime_error if the write() returns 0 or an error
 * @return The number of actually written bytes or -1 in case of error
 */
int AbstractSocket::__send(const void* buffer, size_t size)
{
        size_t remaining = size;
        while (remaining > 0) {
                ssize_t ret = socket_->write (((char*)buffer)+(size-remaining), remaining);
                if (ret == 0){
                        DEBUG("Cannot send any further");
                        // Cannot send more
                        break;
                } else if (ret < 0) {
                        ERROR("Send error");
                        throw std::runtime_error ("Send error");
                        return -1;
                }
                remaining -= ret;
        }
        return (size-remaining);
}

} // net