X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fdcpomatic_socket.cc;h=f4292e842d5375e3944953954ebc7803305bc697;hb=bb78e4dcbdf5f9592679f0262b97de240fbd62e7;hp=bc8f596a7fefbf30c043cbc80b6647ac50384137;hpb=f213fd833a840fc97e3875979ae7dc7cbbc883b1;p=dcpomatic.git diff --git a/src/lib/dcpomatic_socket.cc b/src/lib/dcpomatic_socket.cc index bc8f596a7..f4292e842 100644 --- a/src/lib/dcpomatic_socket.cc +++ b/src/lib/dcpomatic_socket.cc @@ -1,60 +1,61 @@ /* - Copyright (C) 2012-2015 Carl Hetherington + Copyright (C) 2012-2020 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic 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 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic 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 this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ -#include "dcpomatic_socket.h" + #include "compose.hpp" +#include "dcpomatic_assert.h" +#include "dcpomatic_socket.h" #include "exceptions.h" -#include +#include #include +#include #include "i18n.h" + +using std::shared_ptr; +using std::weak_ptr; + + +/** @param timeout Timeout in seconds */ Socket::Socket (int timeout) : _deadline (_io_service) , _socket (_io_service) - , _acceptor (0) , _timeout (timeout) { _deadline.expires_at (boost::posix_time::pos_infin); check (); } -Socket::~Socket () -{ - delete _acceptor; -} - void Socket::check () { if (_deadline.expires_at() <= boost::asio::deadline_timer::traits_type::now ()) { - if (_acceptor) { - _acceptor->cancel (); - } else { - _socket.close (); - } + _socket.close (); _deadline.expires_at (boost::posix_time::pos_infin); } _deadline.async_wait (boost::bind (&Socket::check, this)); } + /** Blocking connect. * @param endpoint End-point to connect to. */ @@ -77,25 +78,6 @@ Socket::connect (boost::asio::ip::tcp::endpoint endpoint) } } -void -Socket::accept (int port) -{ - _acceptor = new boost::asio::ip::tcp::acceptor (_io_service, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)); - - _deadline.expires_from_now (boost::posix_time::seconds (_timeout)); - boost::system::error_code ec = boost::asio::error::would_block; - _acceptor->async_accept (_socket, boost::lambda::var(ec) = boost::lambda::_1); - do { - _io_service.run_one (); - } while (ec == boost::asio::error::would_block); - - delete _acceptor; - _acceptor = 0; - - if (ec) { - throw NetworkError (String::compose (_("error during async_accept (%1)"), ec.value ())); - } -} /** Blocking write. * @param data Buffer to write. @@ -108,7 +90,7 @@ Socket::write (uint8_t const * data, int size) boost::system::error_code ec = boost::asio::error::would_block; boost::asio::async_write (_socket, boost::asio::buffer (data, size), boost::lambda::var(ec) = boost::lambda::_1); - + do { _io_service.run_one (); } while (ec == boost::asio::error::would_block); @@ -116,8 +98,13 @@ Socket::write (uint8_t const * data, int size) if (ec) { throw NetworkError (String::compose (_("error during async_write (%1)"), ec.value ())); } + + if (_write_digester) { + _write_digester->add (data, static_cast(size)); + } } + void Socket::write (uint32_t v) { @@ -125,6 +112,7 @@ Socket::write (uint32_t v) write (reinterpret_cast (&v), 4); } + /** Blocking read. * @param data Buffer to read to. * @param size Number of bytes to read. @@ -140,12 +128,17 @@ Socket::read (uint8_t* data, int size) do { _io_service.run_one (); } while (ec == boost::asio::error::would_block); - + if (ec) { throw NetworkError (String::compose (_("error during async_read (%1)"), ec.value ())); } + + if (_read_digester) { + _read_digester->add (data, static_cast(size)); + } } + uint32_t Socket::read_uint32 () { @@ -154,3 +147,99 @@ Socket::read_uint32 () return ntohl (v); } + +void +Socket::start_read_digest () +{ + DCPOMATIC_ASSERT (!_read_digester); + _read_digester.reset (new Digester()); +} + + +void +Socket::start_write_digest () +{ + DCPOMATIC_ASSERT (!_write_digester); + _write_digester.reset (new Digester()); +} + + +Socket::ReadDigestScope::ReadDigestScope (shared_ptr socket) + : _socket (socket) +{ + socket->start_read_digest (); +} + + +bool +Socket::ReadDigestScope::check () +{ + auto sp = _socket.lock (); + if (!sp) { + return false; + } + + return sp->check_read_digest (); +} + + +Socket::WriteDigestScope::WriteDigestScope (shared_ptr socket) + : _socket (socket) +{ + socket->start_write_digest (); +} + + +Socket::WriteDigestScope::~WriteDigestScope () +{ + auto sp = _socket.lock (); + if (sp) { + try { + sp->finish_write_digest (); + } catch (...) { + /* If we can't write our digest, something bad has happened + * so let's just let it happen. + */ + } + } +} + + +bool +Socket::check_read_digest () +{ + DCPOMATIC_ASSERT (_read_digester); + int const size = _read_digester->size (); + + uint8_t ref[size]; + _read_digester->get (ref); + + /* Make sure _read_digester is gone before we call read() so that the digest + * isn't itself digested. + */ + _read_digester.reset (); + + uint8_t actual[size]; + read (actual, size); + + return memcmp(ref, actual, size) == 0; +} + + +void +Socket::finish_write_digest () +{ + DCPOMATIC_ASSERT (_write_digester); + int const size = _write_digester->size(); + + uint8_t buffer[size]; + _write_digester->get (buffer); + + /* Make sure _write_digester is gone before we call write() so that the digest + * isn't itself digested. + */ + _write_digester.reset (); + + write (buffer, size); +} +