mirror of
https://github.com/badaix/snapcast.git
synced 2025-04-30 18:57:37 +02:00
139 lines
3.3 KiB
C++
139 lines
3.3 KiB
C++
#include "controlServer.h"
|
|
#include "common/timeMsg.h"
|
|
#include "common/ackMsg.h"
|
|
#include "common/requestMsg.h"
|
|
#include <iostream>
|
|
|
|
|
|
ControlServer::ControlServer(unsigned short port) : port_(port), headerChunk(NULL), sampleFormat(NULL)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
|
|
void ControlServer::send(shared_ptr<BaseMessage> message)
|
|
{
|
|
std::unique_lock<std::mutex> mlock(mutex);
|
|
for (std::set<shared_ptr<ServerSession>>::iterator it = sessions.begin(); it != sessions.end(); )
|
|
{
|
|
if (!(*it)->active())
|
|
{
|
|
cout << "Session inactive. Removing\n";
|
|
(*it)->stop();
|
|
sessions.erase(it++);
|
|
}
|
|
else
|
|
++it;
|
|
}
|
|
|
|
for (auto s : sessions)
|
|
s->add(message);
|
|
}
|
|
|
|
|
|
|
|
void ControlServer::onMessageReceived(ServerSession* connection, const BaseMessage& baseMessage, char* buffer)
|
|
{
|
|
// cout << "onMessageReceived: " << baseMessage.type << ", size: " << baseMessage.size << ", sent: " << baseMessage.sent.sec << "," << baseMessage.sent.usec << ", recv: " << baseMessage.received.sec << "," << baseMessage.received.usec << "\n";
|
|
if (baseMessage.type == message_type::requestmsg)
|
|
{
|
|
RequestMsg requestMsg;
|
|
requestMsg.deserialize(baseMessage, buffer);
|
|
cout << "request: " << requestMsg.request << "\n";
|
|
if (requestMsg.request == "time")
|
|
{
|
|
// timeMsg.latency = (timeMsg.received.sec - timeMsg.sent.sec) * 1000000 + (timeMsg.received.usec - timeMsg.sent.usec);
|
|
TimeMsg timeMsg;
|
|
timeMsg.refersTo = requestMsg.id;
|
|
timeMsg.latency = (requestMsg.received.sec - requestMsg.sent.sec) + (requestMsg.received.usec - requestMsg.sent.usec) / 1000000.;
|
|
// tv diff = timeMsg.received - timeMsg.sent;
|
|
// cout << "Latency: " << diff.sec << "." << diff.usec << "\n";
|
|
connection->send(&timeMsg);
|
|
}
|
|
else if (requestMsg.request == "serverSettings")
|
|
{
|
|
serverSettings->refersTo = requestMsg.id;
|
|
connection->send(serverSettings);
|
|
}
|
|
else if (requestMsg.request == "sampleFormat")
|
|
{
|
|
sampleFormat->refersTo = requestMsg.id;
|
|
connection->send(sampleFormat);
|
|
}
|
|
else if (requestMsg.request == "headerChunk")
|
|
{
|
|
headerChunk->refersTo = requestMsg.id;
|
|
connection->send(headerChunk);
|
|
}
|
|
else if (requestMsg.request == "startStream")
|
|
{
|
|
AckMsg ackMsg;
|
|
ackMsg.refersTo = requestMsg.id;
|
|
connection->send(&ackMsg);
|
|
connection->setStreamActive(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ControlServer::acceptor()
|
|
{
|
|
tcp::acceptor a(io_service_, tcp::endpoint(tcp::v4(), port_));
|
|
for (;;)
|
|
{
|
|
socket_ptr sock(new tcp::socket(io_service_));
|
|
struct timeval tv;
|
|
tv.tv_sec = 5;
|
|
tv.tv_usec = 0;
|
|
a.accept(*sock);
|
|
setsockopt(sock->native(), SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
|
|
setsockopt(sock->native(), SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
|
|
cout << "ControlServer::NewConnection: " << sock->remote_endpoint().address().to_string() << "\n";
|
|
ServerSession* session = new ServerSession(this, sock);
|
|
{
|
|
std::unique_lock<std::mutex> mlock(mutex);
|
|
session->start();
|
|
sessions.insert(shared_ptr<ServerSession>(session));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ControlServer::start()
|
|
{
|
|
acceptThread = new thread(&ControlServer::acceptor, this);
|
|
}
|
|
|
|
|
|
void ControlServer::stop()
|
|
{
|
|
// acceptThread->join();
|
|
}
|
|
|
|
|
|
void ControlServer::setHeader(HeaderMessage* header)
|
|
{
|
|
if (header)
|
|
headerChunk = header;
|
|
}
|
|
|
|
|
|
void ControlServer::setFormat(SampleFormat* format)
|
|
{
|
|
if (format)
|
|
sampleFormat = format;
|
|
}
|
|
|
|
|
|
|
|
void ControlServer::setServerSettings(ServerSettings* settings)
|
|
{
|
|
if (settings)
|
|
serverSettings = settings;
|
|
}
|
|
|
|
|
|
|
|
|
|
|