mirror of
https://github.com/juce-framework/JUCE.git
synced 2026-01-10 23:44:24 +00:00
443 lines
12 KiB
C++
443 lines
12 KiB
C++
/*
|
|
==============================================================================
|
|
|
|
This file is part of the JUCE framework.
|
|
Copyright (c) Raw Material Software Limited
|
|
|
|
JUCE is an open source framework subject to commercial or open source
|
|
licensing.
|
|
|
|
By downloading, installing, or using the JUCE framework, or combining the
|
|
JUCE framework with any other source code, object code, content or any other
|
|
copyrightable work, you agree to the terms of the JUCE End User Licence
|
|
Agreement, and all incorporated terms including the JUCE Privacy Policy and
|
|
the JUCE Website Terms of Service, as applicable, which will bind you. If you
|
|
do not agree to the terms of these agreements, we will not license the JUCE
|
|
framework to you, and you must discontinue the installation or download
|
|
process and cease use of the JUCE framework.
|
|
|
|
JUCE End User Licence Agreement: https://juce.com/legal/juce-8-licence/
|
|
JUCE Privacy Policy: https://juce.com/juce-privacy-policy
|
|
JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/
|
|
|
|
Or:
|
|
|
|
You may also use this code under the terms of the AGPLv3:
|
|
https://www.gnu.org/licenses/agpl-3.0.en.html
|
|
|
|
THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
|
|
WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
|
|
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
namespace juce
|
|
{
|
|
|
|
struct InterprocessConnection::ConnectionThread final : public Thread
|
|
{
|
|
ConnectionThread (InterprocessConnection& c) : Thread (SystemStats::getJUCEVersion() + ": IPC"), owner (c) {}
|
|
void run() override { owner.runThread(); }
|
|
|
|
InterprocessConnection& owner;
|
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ConnectionThread)
|
|
};
|
|
|
|
class SafeActionImpl
|
|
{
|
|
public:
|
|
explicit SafeActionImpl (InterprocessConnection& p)
|
|
: ref (p) {}
|
|
|
|
template <typename Fn>
|
|
void ifSafe (Fn&& fn)
|
|
{
|
|
const ScopedLock lock (mutex);
|
|
|
|
if (safe)
|
|
fn (ref);
|
|
}
|
|
|
|
void setSafe (bool s)
|
|
{
|
|
const ScopedLock lock (mutex);
|
|
safe = s;
|
|
}
|
|
|
|
bool isSafe()
|
|
{
|
|
const ScopedLock lock (mutex);
|
|
return safe;
|
|
}
|
|
|
|
private:
|
|
CriticalSection mutex;
|
|
InterprocessConnection& ref;
|
|
bool safe = false;
|
|
};
|
|
|
|
class InterprocessConnection::SafeAction final : public SafeActionImpl
|
|
{
|
|
using SafeActionImpl::SafeActionImpl;
|
|
};
|
|
|
|
//==============================================================================
|
|
InterprocessConnection::InterprocessConnection (bool callbacksOnMessageThread, uint32 magicMessageHeaderNumber)
|
|
: useMessageThread (callbacksOnMessageThread),
|
|
magicMessageHeader (magicMessageHeaderNumber),
|
|
safeAction (std::make_shared<SafeAction> (*this))
|
|
{
|
|
thread.reset (new ConnectionThread (*this));
|
|
}
|
|
|
|
InterprocessConnection::~InterprocessConnection()
|
|
{
|
|
// You *must* call `disconnect` in the destructor of your derived class to ensure
|
|
// that any pending messages are not delivered. If the messages were delivered after
|
|
// destroying the derived class, we'd end up calling the pure virtual implementations
|
|
// of `messageReceived`, `connectionMade` and `connectionLost` which is definitely
|
|
// not a good idea!
|
|
jassert (! safeAction->isSafe());
|
|
|
|
callbackConnectionState = false;
|
|
disconnect (4000, Notify::no);
|
|
thread.reset();
|
|
}
|
|
|
|
//==============================================================================
|
|
bool InterprocessConnection::connectToSocket (const String& hostName,
|
|
int portNumber, int timeOutMillisecs)
|
|
{
|
|
disconnect();
|
|
|
|
auto s = std::make_unique<StreamingSocket>();
|
|
|
|
if (s->connect (hostName, portNumber, timeOutMillisecs))
|
|
{
|
|
const ScopedWriteLock sl (pipeAndSocketLock);
|
|
initialiseWithSocket (std::move (s));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool InterprocessConnection::connectToPipe (const String& pipeName, int timeoutMs)
|
|
{
|
|
disconnect();
|
|
|
|
auto newPipe = std::make_unique<NamedPipe>();
|
|
|
|
if (newPipe->openExisting (pipeName))
|
|
{
|
|
const ScopedWriteLock sl (pipeAndSocketLock);
|
|
pipeReceiveMessageTimeout = timeoutMs;
|
|
initialiseWithPipe (std::move (newPipe));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool InterprocessConnection::createPipe (const String& pipeName, int timeoutMs, bool mustNotExist)
|
|
{
|
|
disconnect();
|
|
|
|
auto newPipe = std::make_unique<NamedPipe>();
|
|
|
|
if (newPipe->createNewPipe (pipeName, mustNotExist))
|
|
{
|
|
const ScopedWriteLock sl (pipeAndSocketLock);
|
|
pipeReceiveMessageTimeout = timeoutMs;
|
|
initialiseWithPipe (std::move (newPipe));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void InterprocessConnection::disconnect (int timeoutMs, Notify notify)
|
|
{
|
|
thread->signalThreadShouldExit();
|
|
|
|
{
|
|
const ScopedReadLock sl (pipeAndSocketLock);
|
|
if (socket != nullptr) socket->close();
|
|
if (pipe != nullptr) pipe->close();
|
|
}
|
|
|
|
thread->stopThread (timeoutMs);
|
|
deletePipeAndSocket();
|
|
|
|
if (notify == Notify::yes)
|
|
connectionLostInt();
|
|
|
|
callbackConnectionState = false;
|
|
safeAction->setSafe (false);
|
|
}
|
|
|
|
void InterprocessConnection::deletePipeAndSocket()
|
|
{
|
|
const ScopedWriteLock sl (pipeAndSocketLock);
|
|
socket.reset();
|
|
pipe.reset();
|
|
}
|
|
|
|
bool InterprocessConnection::isConnected() const
|
|
{
|
|
const ScopedReadLock sl (pipeAndSocketLock);
|
|
|
|
return ((socket != nullptr && socket->isConnected())
|
|
|| (pipe != nullptr && pipe->isOpen()))
|
|
&& threadIsRunning;
|
|
}
|
|
|
|
String InterprocessConnection::getConnectedHostName() const
|
|
{
|
|
{
|
|
const ScopedReadLock sl (pipeAndSocketLock);
|
|
|
|
if (pipe == nullptr && socket == nullptr)
|
|
return {};
|
|
|
|
if (socket != nullptr && ! socket->isLocal())
|
|
return socket->getHostName();
|
|
}
|
|
|
|
return IPAddress::local().toString();
|
|
}
|
|
|
|
//==============================================================================
|
|
bool InterprocessConnection::sendMessage (const MemoryBlock& message)
|
|
{
|
|
uint32 messageHeader[2] = { ByteOrder::swapIfBigEndian (magicMessageHeader),
|
|
ByteOrder::swapIfBigEndian ((uint32) message.getSize()) };
|
|
|
|
MemoryBlock messageData (sizeof (messageHeader) + message.getSize());
|
|
messageData.copyFrom (messageHeader, 0, sizeof (messageHeader));
|
|
messageData.copyFrom (message.getData(), sizeof (messageHeader), message.getSize());
|
|
|
|
return writeData (messageData.getData(), (int) messageData.getSize()) == (int) messageData.getSize();
|
|
}
|
|
|
|
int InterprocessConnection::writeData (void* data, int dataSize)
|
|
{
|
|
const ScopedReadLock sl (pipeAndSocketLock);
|
|
|
|
if (socket != nullptr)
|
|
return socket->write (data, dataSize);
|
|
|
|
if (pipe != nullptr)
|
|
return pipe->write (data, dataSize, pipeReceiveMessageTimeout);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//==============================================================================
|
|
void InterprocessConnection::initialise()
|
|
{
|
|
safeAction->setSafe (true);
|
|
threadIsRunning = true;
|
|
connectionMadeInt();
|
|
thread->startThread();
|
|
}
|
|
|
|
void InterprocessConnection::initialiseWithSocket (std::unique_ptr<StreamingSocket> newSocket)
|
|
{
|
|
jassert (socket == nullptr && pipe == nullptr);
|
|
socket = std::move (newSocket);
|
|
initialise();
|
|
}
|
|
|
|
void InterprocessConnection::initialiseWithPipe (std::unique_ptr<NamedPipe> newPipe)
|
|
{
|
|
jassert (socket == nullptr && pipe == nullptr);
|
|
pipe = std::move (newPipe);
|
|
initialise();
|
|
}
|
|
|
|
//==============================================================================
|
|
struct ConnectionStateMessage final : public MessageManager::MessageBase
|
|
{
|
|
ConnectionStateMessage (std::shared_ptr<SafeActionImpl> ipc, bool connected) noexcept
|
|
: safeAction (ipc), connectionMade (connected)
|
|
{}
|
|
|
|
void messageCallback() override
|
|
{
|
|
safeAction->ifSafe ([this] (InterprocessConnection& owner)
|
|
{
|
|
if (connectionMade)
|
|
owner.connectionMade();
|
|
else
|
|
owner.connectionLost();
|
|
});
|
|
}
|
|
|
|
std::shared_ptr<SafeActionImpl> safeAction;
|
|
bool connectionMade;
|
|
|
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ConnectionStateMessage)
|
|
};
|
|
|
|
void InterprocessConnection::connectionMadeInt()
|
|
{
|
|
if (! callbackConnectionState)
|
|
{
|
|
callbackConnectionState = true;
|
|
|
|
if (useMessageThread)
|
|
(new ConnectionStateMessage (safeAction, true))->post();
|
|
else
|
|
connectionMade();
|
|
}
|
|
}
|
|
|
|
void InterprocessConnection::connectionLostInt()
|
|
{
|
|
if (callbackConnectionState)
|
|
{
|
|
callbackConnectionState = false;
|
|
|
|
if (useMessageThread)
|
|
(new ConnectionStateMessage (safeAction, false))->post();
|
|
else
|
|
connectionLost();
|
|
}
|
|
}
|
|
|
|
struct DataDeliveryMessage final : public Message
|
|
{
|
|
DataDeliveryMessage (std::shared_ptr<SafeActionImpl> ipc, const MemoryBlock& d)
|
|
: safeAction (ipc), data (d)
|
|
{}
|
|
|
|
void messageCallback() override
|
|
{
|
|
safeAction->ifSafe ([this] (InterprocessConnection& owner)
|
|
{
|
|
owner.messageReceived (data);
|
|
});
|
|
}
|
|
|
|
std::shared_ptr<SafeActionImpl> safeAction;
|
|
MemoryBlock data;
|
|
};
|
|
|
|
void InterprocessConnection::deliverDataInt (const MemoryBlock& data)
|
|
{
|
|
jassert (callbackConnectionState);
|
|
|
|
if (useMessageThread)
|
|
(new DataDeliveryMessage (safeAction, data))->post();
|
|
else
|
|
messageReceived (data);
|
|
}
|
|
|
|
//==============================================================================
|
|
int InterprocessConnection::readData (void* data, int num)
|
|
{
|
|
const ScopedReadLock sl (pipeAndSocketLock);
|
|
|
|
if (socket != nullptr)
|
|
return socket->read (data, num, true);
|
|
|
|
if (pipe != nullptr)
|
|
return pipe->read (data, num, pipeReceiveMessageTimeout);
|
|
|
|
jassertfalse;
|
|
return -1;
|
|
}
|
|
|
|
bool InterprocessConnection::readNextMessage()
|
|
{
|
|
uint32 messageHeader[2];
|
|
auto bytes = readData (messageHeader, sizeof (messageHeader));
|
|
|
|
if (bytes == (int) sizeof (messageHeader)
|
|
&& ByteOrder::swapIfBigEndian (messageHeader[0]) == magicMessageHeader)
|
|
{
|
|
auto bytesInMessage = (int) ByteOrder::swapIfBigEndian (messageHeader[1]);
|
|
|
|
if (bytesInMessage > 0)
|
|
{
|
|
MemoryBlock messageData ((size_t) bytesInMessage, true);
|
|
int bytesRead = 0;
|
|
|
|
while (bytesInMessage > 0)
|
|
{
|
|
if (thread->threadShouldExit())
|
|
return false;
|
|
|
|
auto numThisTime = jmin (bytesInMessage, 65536);
|
|
auto bytesIn = readData (addBytesToPointer (messageData.getData(), bytesRead), numThisTime);
|
|
|
|
if (bytesIn <= 0)
|
|
break;
|
|
|
|
bytesRead += bytesIn;
|
|
bytesInMessage -= bytesIn;
|
|
}
|
|
|
|
if (bytesRead >= 0)
|
|
deliverDataInt (messageData);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if (bytes < 0)
|
|
{
|
|
if (socket != nullptr)
|
|
deletePipeAndSocket();
|
|
|
|
connectionLostInt();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void InterprocessConnection::runThread()
|
|
{
|
|
while (! thread->threadShouldExit())
|
|
{
|
|
if (socket != nullptr)
|
|
{
|
|
auto ready = socket->waitUntilReady (true, 100);
|
|
|
|
if (ready < 0)
|
|
{
|
|
deletePipeAndSocket();
|
|
connectionLostInt();
|
|
break;
|
|
}
|
|
|
|
if (ready == 0)
|
|
{
|
|
thread->wait (1);
|
|
continue;
|
|
}
|
|
}
|
|
else if (pipe != nullptr)
|
|
{
|
|
if (! pipe->isOpen())
|
|
{
|
|
deletePipeAndSocket();
|
|
connectionLostInt();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (thread->threadShouldExit() || ! readNextMessage())
|
|
break;
|
|
}
|
|
|
|
threadIsRunning = false;
|
|
}
|
|
|
|
} // namespace juce
|