ethminer/libwhisper/WhisperHost.h

/*
	This file is part of cpp-ethereum.

	cpp-ethereum 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.

	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
/** @file WhisperHost.h
 * @author Gav Wood <i@gavwood.com>
 * @date 2014
 */

#pragma once

#include <mutex>
#include <array>
#include <set>
#include <memory>
#include <utility>

#include <libdevcore/RLP.h>
#include <libdevcore/Worker.h>
#include <libdevcore/Guards.h>
#include <libdevcrypto/SHA3.h>
#include "Common.h"
#include "WhisperPeer.h"
#include "Interface.h"

namespace dev
{
namespace shh
{

static const FullTopic EmptyFullTopic;

class WhisperHost: public HostCapability<WhisperPeer>, public Interface, public Worker
{
	friend class WhisperPeer;

public:
	WhisperHost();
	virtual ~WhisperHost();

	unsigned protocolVersion() const { return 2; }

	virtual void inject(Envelope const& _e, WhisperPeer* _from = nullptr) override;

	virtual FullTopic const& fullTopic(unsigned _id) const { try { return m_filters.at(m_watches.at(_id).id).full; } catch (...) { return EmptyFullTopic; } }
	virtual unsigned installWatch(FullTopic const& _filter) override;
	virtual unsigned installWatchOnId(h256 _filterId) override;
	virtual void uninstallWatch(unsigned _watchId) override;
	virtual h256s peekWatch(unsigned _watchId) const override { dev::Guard l(m_filterLock); try { return m_watches.at(_watchId).changes; } catch (...) { return h256s(); } }
	virtual h256s checkWatch(unsigned _watchId) override { cleanup(); dev::Guard l(m_filterLock); h256s ret; try { ret = m_watches.at(_watchId).changes; m_watches.at(_watchId).changes.clear(); } catch (...) {} return ret; }
	virtual h256s watchMessages(unsigned _watchId) override;

	virtual Envelope envelope(h256 _m) const override { try { dev::ReadGuard l(x_messages); return m_messages.at(_m); } catch (...) { return Envelope(); } }

	std::map<h256, Envelope> all() const { ReadGuard l(x_messages); return m_messages; }

	void cleanup();

protected:
	void doWork();

private:
	virtual void onStarting() { startWorking(); }
	virtual void onStopping() { stopWorking(); }

	void streamMessage(h256 _m, RLPStream& _s) const;

	void noteChanged(h256 _messageHash, h256 _filter);

	mutable dev::SharedMutex x_messages;
	std::map<h256, Envelope> m_messages;
	std::multimap<unsigned, h256> m_expiryQueue;

	mutable dev::Mutex m_filterLock;
	std::map<h256, InstalledFilter> m_filters;
	std::map<unsigned, ClientWatch> m_watches;
};

}
}