Mirrored_Repos/obs-websocket
1
0
Fork 0
mirror of https://github.com/Palakis/obs-websocket.git synced 2024-08-30 18:12:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Style changes

Browse Source
This commit is contained in:
Palakis 2017-02-15 17:09:34 +01:00
parent f2e6e137a6
commit 3fbc221db0
3 changed files with 121 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
WSRequestHandler.cpp
View File

@ -57,13 +57,16 @@ WSRequestHandler::WSRequestHandler(QWebSocket *client) :
authNotRequired.insert("Authenticate"); authNotRequired.insert("Authenticate");
} }
void WSRequestHandler::processIncomingMessage(QString textMessage) { void WSRequestHandler::processIncomingMessage(QString textMessage)
{
QByteArray msgData = textMessage.toUtf8(); QByteArray msgData = textMessage.toUtf8();
const char *msg = msgData; const char *msg = msgData;
_requestData = obs_data_create_from_json(msg); _requestData = obs_data_create_from_json(msg);
if (!_requestData) { if (!_requestData)
if (!msg) { {
if (!msg)
{
msg = "<null pointer>"; msg = "<null pointer>";
} }
@ -76,8 +79,8 @@ void WSRequestHandler::processIncomingMessage(QString textMessage) {
_messageId = obs_data_get_string(_requestData, "message-id"); _messageId = obs_data_get_string(_requestData, "message-id");
if (Config::Current()->AuthRequired if (Config::Current()->AuthRequired
&& _client->property(PROP_AUTHENTICATED) == false && (_client->property(PROP_AUTHENTICATED).toBool() == false)
&& authNotRequired.find(_requestType) == authNotRequired.end()) && (authNotRequired.find(_requestType) == authNotRequired.end()))
{ {
SendErrorResponse("Not Authenticated"); SendErrorResponse("Not Authenticated");
return; return;
@ -85,28 +88,34 @@ void WSRequestHandler::processIncomingMessage(QString textMessage) {
void (*handlerFunc)(WSRequestHandler*) = (messageMap[_requestType]); void (*handlerFunc)(WSRequestHandler*) = (messageMap[_requestType]);
if (handlerFunc != NULL) { if (handlerFunc != NULL)
{
handlerFunc(this); handlerFunc(this);
} }
else { else
{
SendErrorResponse("invalid request type"); SendErrorResponse("invalid request type");
} }
obs_data_release(_requestData); obs_data_release(_requestData);
} }
WSRequestHandler::~WSRequestHandler() { WSRequestHandler::~WSRequestHandler()
if (_requestData != NULL) { {
if (_requestData != NULL)
{
obs_data_release(_requestData); obs_data_release(_requestData);
} }
} }
void WSRequestHandler::SendOKResponse(obs_data_t *additionalFields) { void WSRequestHandler::SendOKResponse(obs_data_t *additionalFields)
{
obs_data_t *response = obs_data_create(); obs_data_t *response = obs_data_create();
obs_data_set_string(response, "status", "ok"); obs_data_set_string(response, "status", "ok");
obs_data_set_string(response, "message-id", _messageId); obs_data_set_string(response, "message-id", _messageId);
if (additionalFields != NULL) { if (additionalFields != NULL)
{
obs_data_apply(response, additionalFields); obs_data_apply(response, additionalFields);
} }
@ -115,7 +124,8 @@ void WSRequestHandler::SendOKResponse(obs_data_t *additionalFields) {
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::SendErrorResponse(const char *errorMessage) { void WSRequestHandler::SendErrorResponse(const char *errorMessage)
{
obs_data_t *response = obs_data_create(); obs_data_t *response = obs_data_create();
obs_data_set_string(response, "status", "error"); obs_data_set_string(response, "status", "error");
obs_data_set_string(response, "error", errorMessage); obs_data_set_string(response, "error", errorMessage);
@ -126,7 +136,8 @@ void WSRequestHandler::SendErrorResponse(const char *errorMessage) {
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::HandleGetVersion(WSRequestHandler *owner) { void WSRequestHandler::HandleGetVersion(WSRequestHandler *owner)
{
obs_data_t *data = obs_data_create(); obs_data_t *data = obs_data_create();
obs_data_set_double(data, "version", 1.1); obs_data_set_double(data, "version", 1.1);
obs_data_set_string(data, "obs-websocket-version", OBS_WEBSOCKET_VERSION); obs_data_set_string(data, "obs-websocket-version", OBS_WEBSOCKET_VERSION);
@ -137,13 +148,15 @@ void WSRequestHandler::HandleGetVersion(WSRequestHandler *owner) {
obs_data_release(data); obs_data_release(data);
} }
void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler *owner) { void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler *owner)
{
bool authRequired = Config::Current()->AuthRequired; bool authRequired = Config::Current()->AuthRequired;
obs_data_t *data = obs_data_create(); obs_data_t *data = obs_data_create();
obs_data_set_bool(data, "authRequired", authRequired); obs_data_set_bool(data, "authRequired", authRequired);
if (authRequired) { if (authRequired)
{
obs_data_set_string(data, "challenge", Config::Current()->SessionChallenge); obs_data_set_string(data, "challenge", Config::Current()->SessionChallenge);
obs_data_set_string(data, "salt", Config::Current()->Salt); obs_data_set_string(data, "salt", Config::Current()->Salt);
} }
@ -153,38 +166,51 @@ void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler *owner) {
obs_data_release(data); obs_data_release(data);
} }
void WSRequestHandler::HandleAuthenticate(WSRequestHandler *owner) { void WSRequestHandler::HandleAuthenticate(WSRequestHandler *owner)
{
const char *auth = obs_data_get_string(owner->_requestData, "auth"); const char *auth = obs_data_get_string(owner->_requestData, "auth");
if (!auth || strlen(auth) < 1) { if (!auth || strlen(auth) < 1)
{
owner->SendErrorResponse("auth not specified!"); owner->SendErrorResponse("auth not specified!");
return; return;
} }
if (owner->_client->property(PROP_AUTHENTICATED) == false && Config::Current()->CheckAuth(auth)) { blog(LOG_INFO, "[obs-websocket] preauth : client_authenticated : %d", owner->_client->property(PROP_AUTHENTICATED).toBool());
if ((owner->_client->property(PROP_AUTHENTICATED).toBool() == false) && Config::Current()->CheckAuth(auth))
{
blog(LOG_INFO, "[obs-websocket] auth successful");
owner->_client->setProperty(PROP_AUTHENTICATED, true); owner->_client->setProperty(PROP_AUTHENTICATED, true);
owner->SendOKResponse(); owner->SendOKResponse();
} }
else { else
{
blog(LOG_INFO, "[obs-websocket] auth refused");
owner->SendErrorResponse("Authentication Failed."); owner->SendErrorResponse("Authentication Failed.");
} }
} }
void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler *owner) { void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler *owner)
{
const char *sceneName = obs_data_get_string(owner->_requestData, "scene-name"); const char *sceneName = obs_data_get_string(owner->_requestData, "scene-name");
obs_source_t *source = obs_get_source_by_name(sceneName); obs_source_t *source = obs_get_source_by_name(sceneName);
if (source) { if (source)
{
obs_frontend_set_current_scene(source); obs_frontend_set_current_scene(source);
owner->SendOKResponse(); owner->SendOKResponse();
} }
else { else
{
owner->SendErrorResponse("requested scene does not exist"); owner->SendErrorResponse("requested scene does not exist");
} }
obs_source_release(source); obs_source_release(source);
} }
void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler *owner) { void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler *owner)
{
obs_source_t *current_scene = obs_frontend_get_current_scene(); obs_source_t *current_scene = obs_frontend_get_current_scene();
const char *name = obs_source_get_name(current_scene); const char *name = obs_source_get_name(current_scene);
@ -201,7 +227,8 @@ void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler *owner) {
obs_source_release(current_scene); obs_source_release(current_scene);
} }
void WSRequestHandler::HandleGetSceneList(WSRequestHandler *owner) { void WSRequestHandler::HandleGetSceneList(WSRequestHandler *owner)
{
obs_source_t *current_scene = obs_frontend_get_current_scene(); obs_source_t *current_scene = obs_frontend_get_current_scene();
obs_data_array_t *scenes = Utils::GetScenes(); obs_data_array_t *scenes = Utils::GetScenes();
@ -216,10 +243,12 @@ void WSRequestHandler::HandleGetSceneList(WSRequestHandler *owner) {
obs_source_release(current_scene); obs_source_release(current_scene);
} }
void WSRequestHandler::HandleSetSourceRender(WSRequestHandler *owner) { void WSRequestHandler::HandleSetSourceRender(WSRequestHandler *owner)
{
const char *itemName = obs_data_get_string(owner->_requestData, "source"); const char *itemName = obs_data_get_string(owner->_requestData, "source");
bool isVisible = obs_data_get_bool(owner->_requestData, "render"); bool isVisible = obs_data_get_bool(owner->_requestData, "render");
if (itemName == NULL) { if (itemName == NULL)
{
owner->SendErrorResponse("invalid request parameters"); owner->SendErrorResponse("invalid request parameters");
return; return;
} }
@ -227,19 +256,22 @@ void WSRequestHandler::HandleSetSourceRender(WSRequestHandler *owner) {
obs_source_t* currentScene = obs_frontend_get_current_scene(); obs_source_t* currentScene = obs_frontend_get_current_scene();
obs_sceneitem_t *sceneItem = Utils::GetSceneItemFromName(currentScene, itemName); obs_sceneitem_t *sceneItem = Utils::GetSceneItemFromName(currentScene, itemName);
if (sceneItem != NULL) { if (sceneItem != NULL)
{
obs_sceneitem_set_visible(sceneItem, isVisible); obs_sceneitem_set_visible(sceneItem, isVisible);
obs_sceneitem_release(sceneItem); obs_sceneitem_release(sceneItem);
owner->SendOKResponse(); owner->SendOKResponse();
} }
else { else
{
owner->SendErrorResponse("specified scene item doesn't exist"); owner->SendErrorResponse("specified scene item doesn't exist");
} }
obs_source_release(currentScene); obs_source_release(currentScene);
} }
void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler *owner) { void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler *owner)
{
obs_data_t *data = obs_data_create(); obs_data_t *data = obs_data_create();
obs_data_set_bool(data, "streaming", obs_frontend_streaming_active()); obs_data_set_bool(data, "streaming", obs_frontend_streaming_active());
obs_data_set_bool(data, "recording", obs_frontend_recording_active()); obs_data_set_bool(data, "recording", obs_frontend_recording_active());
@ -249,35 +281,43 @@ void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler *owner) {
obs_data_release(data); obs_data_release(data);
} }
void WSRequestHandler::HandleStartStopStreaming(WSRequestHandler *owner) { void WSRequestHandler::HandleStartStopStreaming(WSRequestHandler *owner)
if (obs_frontend_streaming_active()) { {
if (obs_frontend_streaming_active())
{
obs_frontend_streaming_stop(); obs_frontend_streaming_stop();
} }
else { else
{
obs_frontend_streaming_start(); obs_frontend_streaming_start();
} }
owner->SendOKResponse(); owner->SendOKResponse();
} }
void WSRequestHandler::HandleStartStopRecording(WSRequestHandler *owner) { void WSRequestHandler::HandleStartStopRecording(WSRequestHandler *owner)
if (obs_frontend_recording_active()) { {
if (obs_frontend_recording_active())
{
obs_frontend_recording_stop(); obs_frontend_recording_stop();
} }
else { else
{
obs_frontend_recording_start(); obs_frontend_recording_start();
} }
owner->SendOKResponse(); owner->SendOKResponse();
} }
void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *owner) { void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *owner)
{
obs_source_t *current_transition = obs_frontend_get_current_transition(); obs_source_t *current_transition = obs_frontend_get_current_transition();
obs_frontend_source_list transitionList = {}; obs_frontend_source_list transitionList = {};
obs_frontend_get_transitions(&transitionList); obs_frontend_get_transitions(&transitionList);
obs_data_array_t* transitions = obs_data_array_create(); obs_data_array_t* transitions = obs_data_array_create();
for (size_t i = 0; i < transitionList.sources.num; i++) { for (size_t i = 0; i < transitionList.sources.num; i++)
{
obs_source_t* transition = transitionList.sources.array[i]; obs_source_t* transition = transitionList.sources.array[i];
obs_data_t *obj = obs_data_create(); obs_data_t *obj = obs_data_create();
@ -299,7 +339,8 @@ void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *owner) {
obs_source_release(current_transition); obs_source_release(current_transition);
} }
void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler *owner) { void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler *owner)
{
obs_source_t *current_transition = obs_frontend_get_current_transition(); obs_source_t *current_transition = obs_frontend_get_current_transition();
obs_data_t *response = obs_data_create(); obs_data_t *response = obs_data_create();
@ -311,32 +352,38 @@ void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler *owner) {
obs_source_release(current_transition); obs_source_release(current_transition);
} }
void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler *owner) { void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler *owner)
{
const char *name = obs_data_get_string(owner->_requestData, "transition-name"); const char *name = obs_data_get_string(owner->_requestData, "transition-name");
obs_source_t *transition = Utils::GetTransitionFromName(name); obs_source_t *transition = Utils::GetTransitionFromName(name);
if (transition) { if (transition)
{
obs_frontend_set_current_transition(transition); obs_frontend_set_current_transition(transition);
owner->SendOKResponse(); owner->SendOKResponse();
obs_source_release(transition); obs_source_release(transition);
} }
else { else
{
owner->SendErrorResponse("requested transition does not exist"); owner->SendErrorResponse("requested transition does not exist");
} }
} }
void WSRequestHandler::HandleSetVolume(WSRequestHandler *owner) { void WSRequestHandler::HandleSetVolume(WSRequestHandler *owner)
{
const char *item_name = obs_data_get_string(owner->_requestData, "source"); const char *item_name = obs_data_get_string(owner->_requestData, "source");
float item_volume = obs_data_get_double(owner->_requestData, "volume"); float item_volume = obs_data_get_double(owner->_requestData, "volume");
if (item_name == NULL || item_volume < 0.0 || item_volume > 1.0) { if (item_name == NULL || item_volume < 0.0 || item_volume > 1.0)
{
owner->SendErrorResponse("invalid request parameters"); owner->SendErrorResponse("invalid request parameters");
return; return;
} }
obs_source_t* item = obs_get_source_by_name(item_name); obs_source_t* item = obs_get_source_by_name(item_name);
if (!item) { if (!item)
{
owner->SendErrorResponse("specified source doesn't exist"); owner->SendErrorResponse("specified source doesn't exist");
return; return;
} }
@ -347,9 +394,11 @@ void WSRequestHandler::HandleSetVolume(WSRequestHandler *owner) {
obs_source_release(item); obs_source_release(item);
} }
void WSRequestHandler::HandleGetVolume(WSRequestHandler *owner) { void WSRequestHandler::HandleGetVolume(WSRequestHandler *owner)
{
const char *item_name = obs_data_get_string(owner->_requestData, "source"); const char *item_name = obs_data_get_string(owner->_requestData, "source");
if (item_name == NULL) { if (item_name == NULL)
{
owner->SendErrorResponse("invalid request parameters"); owner->SendErrorResponse("invalid request parameters");
return; return;
} }
@ -369,13 +418,15 @@ void WSRequestHandler::HandleGetVolume(WSRequestHandler *owner) {
void WSRequestHandler::ToggleMute(WSRequestHandler *owner) { void WSRequestHandler::ToggleMute(WSRequestHandler *owner) {
const char *item_name = obs_data_get_string(owner->_requestData, "source"); const char *item_name = obs_data_get_string(owner->_requestData, "source");
if (item_name == NULL) { if (item_name == NULL)
{
owner->SendErrorResponse("invalid request parameters"); owner->SendErrorResponse("invalid request parameters");
return; return;
} }
obs_source_t* item = obs_get_source_by_name(item_name); obs_source_t* item = obs_get_source_by_name(item_name);
if (!item) { if (!item)
{
owner->SendErrorResponse("invalid request parameters"); owner->SendErrorResponse("invalid request parameters");
return; return;
} }
@ -386,16 +437,19 @@ void WSRequestHandler::ToggleMute(WSRequestHandler *owner) {
obs_source_release(item); obs_source_release(item);
} }
void WSRequestHandler::SetMute(WSRequestHandler *owner) { void WSRequestHandler::SetMute(WSRequestHandler *owner)
{
const char *item_name = obs_data_get_string(owner->_requestData, "source"); const char *item_name = obs_data_get_string(owner->_requestData, "source");
bool mute = obs_data_get_bool(owner->_requestData, "mute"); bool mute = obs_data_get_bool(owner->_requestData, "mute");
if (item_name == NULL) { if (item_name == NULL)
{
owner->SendErrorResponse("invalid request parameters"); owner->SendErrorResponse("invalid request parameters");
return; return;
} }
obs_source_t* item = obs_get_source_by_name(item_name); obs_source_t* item = obs_get_source_by_name(item_name);
if (!item) { if (!item)
{
owner->SendErrorResponse("specified source doesn't exist"); owner->SendErrorResponse("specified source doesn't exist");
return; return;
} }
@ -406,6 +460,7 @@ void WSRequestHandler::SetMute(WSRequestHandler *owner) {
obs_source_release(item); obs_source_release(item);
} }
void WSRequestHandler::ErrNotImplemented(WSRequestHandler *owner) { void WSRequestHandler::ErrNotImplemented(WSRequestHandler *owner)
{
owner->SendErrorResponse("not implemented"); owner->SendErrorResponse("not implemented");
} }

20
WSServer.cpp
View File

@ -46,7 +46,8 @@ WSServer::WSServer(quint16 port, QObject *parent) :
_serverThread->start(); _serverThread->start();
bool serverStarted = _wsServer->listen(QHostAddress::Any, port); bool serverStarted = _wsServer->listen(QHostAddress::Any, port);
if (serverStarted) { if (serverStarted)
{
connect(_wsServer, &QWebSocketServer::newConnection, this, &WSServer::onNewConnection); connect(_wsServer, &QWebSocketServer::newConnection, this, &WSServer::onNewConnection);
} }
} }
@ -66,9 +67,11 @@ void WSServer::broadcast(QString message)
{ {
_clMutex.lock(); _clMutex.lock();
Q_FOREACH(QWebSocket *pClient, _clients) { Q_FOREACH(QWebSocket *pClient, _clients)
if (Config::Current()->AuthRequired == true {
&& pClient->property(PROP_AUTHENTICATED) == false) { if (Config::Current()->AuthRequired
&& (pClient->property(PROP_AUTHENTICATED).toBool() == false))
{
// Skip this client if unauthenticated // Skip this client if unauthenticated
continue; continue;
} }
@ -83,7 +86,8 @@ void WSServer::onNewConnection()
{ {
QWebSocket *pSocket = _wsServer->nextPendingConnection(); QWebSocket *pSocket = _wsServer->nextPendingConnection();
if (pSocket) { if (pSocket)
{
connect(pSocket, &QWebSocket::textMessageReceived, this, &WSServer::textMessageReceived); connect(pSocket, &QWebSocket::textMessageReceived, this, &WSServer::textMessageReceived);
connect(pSocket, &QWebSocket::disconnected, this, &WSServer::socketDisconnected); connect(pSocket, &QWebSocket::disconnected, this, &WSServer::socketDisconnected);
pSocket->setProperty(PROP_AUTHENTICATED, false); pSocket->setProperty(PROP_AUTHENTICATED, false);
@ -101,7 +105,8 @@ void WSServer::textMessageReceived(QString message)
{ {
QWebSocket *pSocket = qobject_cast<QWebSocket *>(sender()); QWebSocket *pSocket = qobject_cast<QWebSocket *>(sender());
if (pSocket) { if (pSocket)
{
WSRequestHandler handler(pSocket); WSRequestHandler handler(pSocket);
handler.processIncomingMessage(message); handler.processIncomingMessage(message);
} }
@ -111,7 +116,8 @@ void WSServer::socketDisconnected()
{ {
QWebSocket *pSocket = qobject_cast<QWebSocket *>(sender()); QWebSocket *pSocket = qobject_cast<QWebSocket *>(sender());
if (pSocket) { if (pSocket)
{
pSocket->setProperty(PROP_AUTHENTICATED, false); pSocket->setProperty(PROP_AUTHENTICATED, false);
_clMutex.lock(); _clMutex.lock();

2
obs-websocket.h
View File

@ -19,7 +19,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
#ifndef OBSWEBSOCKET_H #ifndef OBSWEBSOCKET_H
#define OBSWEBSOCKET_H #define OBSWEBSOCKET_H
#define PROP_AUTHENTICATED "authenticated" #define PROP_AUTHENTICATED "wsclient_authenticated"
#define OBS_WEBSOCKET_VERSION "0.3.2" #define OBS_WEBSOCKET_VERSION "0.3.2"
#endif // OBSWEBSOCKET_H #endif // OBSWEBSOCKET_H