X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fdcpomatic_socket.cc;h=a0a7a1cf3f3d877ee92aa204c2ad3c23f162a754;hb=143cfcf6c9e8c0a0879652d0d741ec268e8d9541;hp=bc8f596a7fefbf30c043cbc80b6647ac50384137;hpb=f213fd833a840fc97e3875979ae7dc7cbbc883b1;p=dcpomatic.git diff --git a/src/lib/dcpomatic_socket.cc b/src/lib/dcpomatic_socket.cc index bc8f596a7..a0a7a1cf3 100644 --- a/src/lib/dcpomatic_socket.cc +++ b/src/lib/dcpomatic_socket.cc @@ -1,54 +1,51 @@ /* - 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 "exceptions.h" +#include "dcpomatic_assert.h" #include #include +#include #include "i18n.h" +using boost::shared_ptr; +using boost::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); } @@ -77,26 +74,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. * @param size Number of bytes to write. @@ -108,7 +85,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,6 +93,10 @@ 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 @@ -140,10 +121,14 @@ 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 @@ -154,3 +139,97 @@ 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 () +{ + shared_ptr 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 () +{ + shared_ptr 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); +} +