root/tls/ringbuf.cc

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "ringbuf.hh"

namespace {
        typedef boost::asio::mutable_buffer mb;
        typedef boost::asio::const_buffer cb;
        using boost::asio::buffer_cast;
        using boost::asio::buffer_size;
}

namespace tls
{

        std::vector<mb> ringbuf::write_area()
        {
                std::vector<mb> rv;
                if (n == N) return rv;
                if (wrs1() > 0) rv.push_back(mb(wra1(), wrs1()));
                if (wrs2() > 0) rv.push_back(mb(wra2(), wrs2()));
                return rv;
        }
        std::vector<cb> ringbuf::read_area() const
        {
                std::vector<cb> rv;
                if (n == 0) return rv;
                if (rds1() > 0) rv.push_back(cb(rda1(), rds1()));
                if (rds2() > 0) rv.push_back(cb(rda2(), rds2()));
                return rv;
        }
        size_t ringbuf::get(unsigned char *out, size_t k)
        {
                size_t rv = 0;
                std::vector<cb> cbs = read_area();
                for (size_t i = 0; i < cbs.size() && rv < k; i++)
                {
                        size_t nuff = buffer_size(cbs[i]);
                        if (nuff > k - rv) nuff = k - rv;
                        std::memcpy(out + rv,
                                    buffer_cast<const unsigned char *>(cbs[i]),
                                    nuff);
                        rv += nuff;
                }
                read(rv);
                return rv;
        }
        size_t ringbuf::put(const unsigned char *in, size_t k)
        {
                size_t rv = 0;
                std::vector<mb> mbs = write_area();
                for (size_t i = 0; i < mbs.size() && rv < k; i++)
                {
                        size_t nuff = buffer_size(mbs[i]);
                        if (nuff > k - rv) nuff = k - rv;
                        std::memcpy(buffer_cast<unsigned char *>(mbs[i]),
                                    in + rv, nuff);
                        rv += nuff;
                }
                written(rv);
                return rv;
        }
}