public/AutoPatch
4
Fork 0
Code Activity

Updated D-BUS proxy to be compliant to the last releases of BrandMeister

Browse source
This commit is contained in:
Artem Prilutskiy 2019-02-02 20:46:23 +03:00
parent a89bc58ede
commit 1c09eace91
4 changed files with 250 additions and 272 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

259
CallCapture/PatchCord.cpp
View file

@ -1,9 +1,9 @@
// Copyright 2015-2016 by Artem Prilutskiy // Copyright 2015-2016 by Artem Prilutskiy
#include "PatchCord.h" #include "PatchCord.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <syslog.h> #include <syslog.h>
#include <stdio.h> #include <stdio.h>
@ -15,9 +15,8 @@
#define AUTOPATCH_LINK_NAME "AutoPatch" #define AUTOPATCH_LINK_NAME "AutoPatch"
// From PatchCord.h // From PatchCord.h
#define VALUE_CORD_OUTGOING_SOURCE_ID 1 #define VALUE_CORD_OUTGOING_SOURCE_ID 1
#define VALUE_CORD_INCOMING_SOURCE_ID 4 #define VALUE_CORD_INCOMING_SOURCE_ID 4
#define VALUE_CORD_TALKER_ALIAS 7
#define BANNER_RENEWAL_INTERVAL 60 #define BANNER_RENEWAL_INTERVAL 60
@ -51,176 +50,151 @@ uint32_t PatchCord::getTalkerID()
void PatchCord::setTalkerAlias(const char* value) void PatchCord::setTalkerAlias(const char* value)
{ {
char* buffer; size_t length = strlen(value) + 12;
asprintf(&buffer, "set alias %s", value); char* buffer = (char*)alloca(length);
sprintf(buffer, "set alias %s", value);
getContextBanner(); getContextBanner();
invokeCommand(buffer); invokeCommand(buffer);
free(buffer);
} }
void PatchCord::getContextBanner() void PatchCord::getContextBanner()
{ {
time_t now = time(NULL); time_t now = time(NULL);
if ((banner != NULL) && if ((banner == NULL) ||
(renewal >= now)) (renewal < now))
{ {
// Save RPC calls and use cached value DBusMessage* request = dbus_message_new_method_call(
return; name, OBJECT_PATH, INTERFACE_NAME, "getContextList");
}
DBusMessage* message = dbus_message_new_method_call( const char* name = AUTOPATCH_LINK_NAME;
name, OBJECT_PATH, INTERFACE_NAME, "getContextList");
const char* name = AUTOPATCH_LINK_NAME; dbus_message_append_args(request,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &number,
DBUS_TYPE_INVALID);
dbus_message_append_args(message, DBusMessage* response = makeCall(request);
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &number,
DBUS_TYPE_INVALID);
DBusPendingCall* pending; if (response != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{
dbus_connection_flush(connection);
dbus_message_unref(message);
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending);
char** array;
int count;
if ((dbus_message_get_args(message, NULL,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &array, &count,
DBUS_TYPE_INVALID)) &&
(count > 0))
{ {
if ((banner == NULL) || char** array;
(strcmp(banner, *array) != 0)) int count;
if ((dbus_message_get_args(response, NULL,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &array, &count,
DBUS_TYPE_INVALID)) &&
(count > 0))
{ {
free(banner); if ((banner == NULL) ||
banner = strdup(*array); (strcmp(banner, array[0]) != 0))
{
free(banner);
banner = strdup(array[0]);
}
dbus_free_string_array(array);
} }
dbus_free_string_array(array);
}
dbus_pending_call_unref(pending);
}
dbus_message_unref(message);
renewal = now + BANNER_RENEWAL_INTERVAL; dbus_message_unref(response);
}
renewal = now + BANNER_RENEWAL_INTERVAL;
}
} }
void PatchCord::invokeCommand(const char* command) void PatchCord::invokeCommand(const char* command)
{ {
DBusMessage* message = dbus_message_new_method_call( if (banner != NULL)
name, OBJECT_PATH, INTERFACE_NAME, "invokeCommand");
dbus_message_append_args(message,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_STRING, &command,
DBUS_TYPE_INVALID);
DBusPendingCall* pending;
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection); DBusMessage* request = dbus_message_new_method_call(
dbus_message_unref(message); name, OBJECT_PATH, INTERFACE_NAME, "invokeCommand");
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending); dbus_message_append_args(request,
dbus_pending_call_unref(pending); DBUS_TYPE_STRING, &banner,
DBUS_TYPE_STRING, &command,
DBUS_TYPE_INVALID);
makeCall(request, true);
} }
dbus_message_unref(message);
} }
void PatchCord::setSpecificValue(uint32_t key, uint32_t value) void PatchCord::setSpecificValue(uint32_t key, uint32_t value)
{ {
DBusMessage* message = dbus_message_new_method_call( if (banner != NULL)
name, OBJECT_PATH, INTERFACE_NAME, "setSpecificValue");
dbus_message_append_args(message,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_UINT32, &key,
DBUS_TYPE_UINT32, &value,
DBUS_TYPE_INVALID);
DBusPendingCall* pending;
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection); DBusMessage* request = dbus_message_new_method_call(
dbus_message_unref(message); name, OBJECT_PATH, INTERFACE_NAME, "setSpecificValue");
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending); dbus_message_append_args(request,
dbus_pending_call_unref(pending); DBUS_TYPE_STRING, &banner,
DBUS_TYPE_UINT32, &key,
DBUS_TYPE_UINT32, &value,
DBUS_TYPE_INVALID);
makeCall(request, true);
} }
dbus_message_unref(message);
} }
uint32_t PatchCord::getSpecificValue(uint32_t key) uint32_t PatchCord::getSpecificValue(uint32_t key)
{ {
DBusMessage* message = dbus_message_new_method_call(
name, OBJECT_PATH, INTERFACE_NAME, "getContextData");
dbus_message_append_args(message,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_INVALID);
uint32_t value = 0; uint32_t value = 0;
DBusPendingCall* pending; if (banner != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection); DBusMessage* request = dbus_message_new_method_call(
dbus_message_unref(message); name, OBJECT_PATH, INTERFACE_NAME, "getContextData");
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending); dbus_message_append_args(request,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_INVALID);
const char* name; DBusMessage* response = makeCall(request);
const char* address;
dbus_uint32_t type;
dbus_uint32_t state;
dbus_uint32_t number;
dbus_uint32_t* values;
int count;
if (dbus_message_get_args(message, NULL, if (response != NULL)
DBUS_TYPE_STRING, &banner, {
DBUS_TYPE_STRING, &name, const char* name;
DBUS_TYPE_UINT32, &type, const char* address;
DBUS_TYPE_UINT32, &number, dbus_uint32_t type;
DBUS_TYPE_STRING, &address, dbus_uint32_t mode;
DBUS_TYPE_UINT32, &state, dbus_uint32_t state;
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &values, &count, dbus_uint32_t number;
DBUS_TYPE_INVALID)) dbus_uint32_t* values;
value = values[key]; int count;
dbus_pending_call_unref(pending); if (dbus_message_get_args(response, NULL,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &type,
DBUS_TYPE_UINT32, &number,
DBUS_TYPE_STRING, &address,
DBUS_TYPE_UINT32, &mode,
DBUS_TYPE_UINT32, &state,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &values, &count,
DBUS_TYPE_INVALID))
value = values[key];
dbus_message_unref(response);
}
} }
dbus_message_unref(message);
return value; return value;
} }
uint32_t PatchCord::getPrivateIDForCall(const char* call) uint32_t PatchCord::getPrivateIDForCall(const char* call)
{ {
DBusMessage* message = dbus_message_new_method_call( uint32_t value = 0;
DBusMessage* request = dbus_message_new_method_call(
name, OBJECT_PATH, INTERFACE_NAME, "getStationData"); name, OBJECT_PATH, INTERFACE_NAME, "getStationData");
dbus_message_append_args(message, dbus_message_append_args(request,
DBUS_TYPE_STRING, &call, DBUS_TYPE_STRING, &call,
DBUS_TYPE_INVALID); DBUS_TYPE_INVALID);
uint32_t value = 0; DBusMessage* response = makeCall(request);
DBusPendingCall* pending; if (response != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection);
dbus_message_unref(message);
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending);
dbus_uint32_t number; dbus_uint32_t number;
dbus_uint32_t algorithm; dbus_uint32_t algorithm;
dbus_uint32_t key; dbus_uint32_t key;
@ -232,7 +206,7 @@ uint32_t PatchCord::getPrivateIDForCall(const char* call)
const char* text; const char* text;
const char* symbol; const char* symbol;
if (dbus_message_get_args(message, NULL, if (dbus_message_get_args(response, NULL,
DBUS_TYPE_UINT32, &number, DBUS_TYPE_UINT32, &number,
DBUS_TYPE_UINT32, &algorithm, DBUS_TYPE_UINT32, &algorithm,
DBUS_TYPE_UINT32, &key, DBUS_TYPE_UINT32, &key,
@ -246,33 +220,27 @@ uint32_t PatchCord::getPrivateIDForCall(const char* call)
DBUS_TYPE_INVALID)) DBUS_TYPE_INVALID))
value = number; value = number;
dbus_pending_call_unref(pending); dbus_message_unref(response);
} }
dbus_message_unref(message);
return value; return value;
} }
bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text) bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text)
{ {
DBusMessage* message = dbus_message_new_method_call( bool result = false;
DBusMessage* request = dbus_message_new_method_call(
name, OBJECT_PATH, INTERFACE_NAME, "getStationData"); name, OBJECT_PATH, INTERFACE_NAME, "getStationData");
dbus_message_append_args(message, dbus_message_append_args(request,
DBUS_TYPE_UINT32, &number, DBUS_TYPE_UINT32, &number,
DBUS_TYPE_INVALID); DBUS_TYPE_INVALID);
bool result = false; DBusMessage* response = makeCall(request);
DBusPendingCall* pending; if (response != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection);
dbus_message_unref(message);
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending);
dbus_uint32_t number; dbus_uint32_t number;
dbus_uint32_t algorithm; dbus_uint32_t algorithm;
dbus_uint32_t key; dbus_uint32_t key;
@ -284,7 +252,7 @@ bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text)
const char* value2; const char* value2;
const char* symbol; const char* symbol;
if (dbus_message_get_args(message, NULL, if (dbus_message_get_args(response, NULL,
DBUS_TYPE_UINT32, &number, DBUS_TYPE_UINT32, &number,
DBUS_TYPE_UINT32, &algorithm, DBUS_TYPE_UINT32, &algorithm,
DBUS_TYPE_UINT32, &key, DBUS_TYPE_UINT32, &key,
@ -302,9 +270,28 @@ bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text)
result = true; result = true;
} }
dbus_pending_call_unref(pending); dbus_message_unref(response);
} }
dbus_message_unref(message);
return result; return result;
} }
DBusMessage* PatchCord::makeCall(DBusMessage* request, bool omission)
{
DBusPendingCall* pending;
DBusMessage* response = NULL;
if (dbus_connection_send_with_reply(connection, request, &pending, -1))
{
dbus_connection_flush(connection);
dbus_pending_call_block(pending);
response = dbus_pending_call_steal_reply(pending);
dbus_pending_call_unref(pending);
}
dbus_message_unref(request);
if (omission && response)
{
dbus_message_unref(response);
return NULL;
}
return response;
}

2
CallCapture/PatchCord.h
View file

@ -39,6 +39,8 @@ class PatchCord
void setSpecificValue(uint32_t key, uint32_t value); void setSpecificValue(uint32_t key, uint32_t value);
uint32_t getSpecificValue(uint32_t key); uint32_t getSpecificValue(uint32_t key);
DBusMessage* makeCall(DBusMessage* request, bool omission = false);
}; };
#endif #endif

259
SVXLink/echolink/PatchCord.cpp
View file

@ -1,9 +1,9 @@
// Copyright 2015-2016 by Artem Prilutskiy // Copyright 2015-2016 by Artem Prilutskiy
#include "PatchCord.h" #include "PatchCord.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <syslog.h> #include <syslog.h>
#include <stdio.h> #include <stdio.h>
@ -15,9 +15,8 @@
#define AUTOPATCH_LINK_NAME "AutoPatch" #define AUTOPATCH_LINK_NAME "AutoPatch"
// From PatchCord.h // From PatchCord.h
#define VALUE_CORD_OUTGOING_SOURCE_ID 1 #define VALUE_CORD_OUTGOING_SOURCE_ID 1
#define VALUE_CORD_INCOMING_SOURCE_ID 4 #define VALUE_CORD_INCOMING_SOURCE_ID 4
#define VALUE_CORD_TALKER_ALIAS 7
#define BANNER_RENEWAL_INTERVAL 60 #define BANNER_RENEWAL_INTERVAL 60
@ -51,176 +50,151 @@ uint32_t PatchCord::getTalkerID()
void PatchCord::setTalkerAlias(const char* value) void PatchCord::setTalkerAlias(const char* value)
{ {
char* buffer; size_t length = strlen(value) + 12;
asprintf(&buffer, "set alias %s", value); char* buffer = (char*)alloca(length);
sprintf(buffer, "set alias %s", value);
getContextBanner(); getContextBanner();
invokeCommand(buffer); invokeCommand(buffer);
free(buffer);
} }
void PatchCord::getContextBanner() void PatchCord::getContextBanner()
{ {
time_t now = time(NULL); time_t now = time(NULL);
if ((banner != NULL) && if ((banner == NULL) ||
(renewal >= now)) (renewal < now))
{ {
// Save RPC calls and use cached value DBusMessage* request = dbus_message_new_method_call(
return; name, OBJECT_PATH, INTERFACE_NAME, "getContextList");
}
DBusMessage* message = dbus_message_new_method_call( const char* name = AUTOPATCH_LINK_NAME;
name, OBJECT_PATH, INTERFACE_NAME, "getContextList");
const char* name = AUTOPATCH_LINK_NAME; dbus_message_append_args(request,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &number,
DBUS_TYPE_INVALID);
dbus_message_append_args(message, DBusMessage* response = makeCall(request);
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &number,
DBUS_TYPE_INVALID);
DBusPendingCall* pending; if (response != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{
dbus_connection_flush(connection);
dbus_message_unref(message);
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending);
char** array;
int count;
if ((dbus_message_get_args(message, NULL,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &array, &count,
DBUS_TYPE_INVALID)) &&
(count > 0))
{ {
if ((banner == NULL) || char** array;
(strcmp(banner, *array) != 0)) int count;
if ((dbus_message_get_args(response, NULL,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &array, &count,
DBUS_TYPE_INVALID)) &&
(count > 0))
{ {
free(banner); if ((banner == NULL) ||
banner = strdup(*array); (strcmp(banner, array[0]) != 0))
{
free(banner);
banner = strdup(array[0]);
}
dbus_free_string_array(array);
} }
dbus_free_string_array(array);
}
dbus_pending_call_unref(pending);
}
dbus_message_unref(message);
renewal = now + BANNER_RENEWAL_INTERVAL; dbus_message_unref(response);
}
renewal = now + BANNER_RENEWAL_INTERVAL;
}
} }
void PatchCord::invokeCommand(const char* command) void PatchCord::invokeCommand(const char* command)
{ {
DBusMessage* message = dbus_message_new_method_call( if (banner != NULL)
name, OBJECT_PATH, INTERFACE_NAME, "invokeCommand");
dbus_message_append_args(message,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_STRING, &command,
DBUS_TYPE_INVALID);
DBusPendingCall* pending;
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection); DBusMessage* request = dbus_message_new_method_call(
dbus_message_unref(message); name, OBJECT_PATH, INTERFACE_NAME, "invokeCommand");
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending); dbus_message_append_args(request,
dbus_pending_call_unref(pending); DBUS_TYPE_STRING, &banner,
DBUS_TYPE_STRING, &command,
DBUS_TYPE_INVALID);
makeCall(request, true);
} }
dbus_message_unref(message);
} }
void PatchCord::setSpecificValue(uint32_t key, uint32_t value) void PatchCord::setSpecificValue(uint32_t key, uint32_t value)
{ {
DBusMessage* message = dbus_message_new_method_call( if (banner != NULL)
name, OBJECT_PATH, INTERFACE_NAME, "setSpecificValue");
dbus_message_append_args(message,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_UINT32, &key,
DBUS_TYPE_UINT32, &value,
DBUS_TYPE_INVALID);
DBusPendingCall* pending;
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection); DBusMessage* request = dbus_message_new_method_call(
dbus_message_unref(message); name, OBJECT_PATH, INTERFACE_NAME, "setSpecificValue");
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending); dbus_message_append_args(request,
dbus_pending_call_unref(pending); DBUS_TYPE_STRING, &banner,
DBUS_TYPE_UINT32, &key,
DBUS_TYPE_UINT32, &value,
DBUS_TYPE_INVALID);
makeCall(request, true);
} }
dbus_message_unref(message);
} }
uint32_t PatchCord::getSpecificValue(uint32_t key) uint32_t PatchCord::getSpecificValue(uint32_t key)
{ {
DBusMessage* message = dbus_message_new_method_call(
name, OBJECT_PATH, INTERFACE_NAME, "getContextData");
dbus_message_append_args(message,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_INVALID);
uint32_t value = 0; uint32_t value = 0;
DBusPendingCall* pending; if (banner != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection); DBusMessage* request = dbus_message_new_method_call(
dbus_message_unref(message); name, OBJECT_PATH, INTERFACE_NAME, "getContextData");
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending); dbus_message_append_args(request,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_INVALID);
const char* name; DBusMessage* response = makeCall(request);
const char* address;
dbus_uint32_t type;
dbus_uint32_t state;
dbus_uint32_t number;
dbus_uint32_t* values;
int count;
if (dbus_message_get_args(message, NULL, if (response != NULL)
DBUS_TYPE_STRING, &banner, {
DBUS_TYPE_STRING, &name, const char* name;
DBUS_TYPE_UINT32, &type, const char* address;
DBUS_TYPE_UINT32, &number, dbus_uint32_t type;
DBUS_TYPE_STRING, &address, dbus_uint32_t mode;
DBUS_TYPE_UINT32, &state, dbus_uint32_t state;
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &values, &count, dbus_uint32_t number;
DBUS_TYPE_INVALID)) dbus_uint32_t* values;
value = values[key]; int count;
dbus_pending_call_unref(pending); if (dbus_message_get_args(response, NULL,
DBUS_TYPE_STRING, &banner,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &type,
DBUS_TYPE_UINT32, &number,
DBUS_TYPE_STRING, &address,
DBUS_TYPE_UINT32, &mode,
DBUS_TYPE_UINT32, &state,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &values, &count,
DBUS_TYPE_INVALID))
value = values[key];
dbus_message_unref(response);
}
} }
dbus_message_unref(message);
return value; return value;
} }
uint32_t PatchCord::getPrivateIDForCall(const char* call) uint32_t PatchCord::getPrivateIDForCall(const char* call)
{ {
DBusMessage* message = dbus_message_new_method_call( uint32_t value = 0;
DBusMessage* request = dbus_message_new_method_call(
name, OBJECT_PATH, INTERFACE_NAME, "getStationData"); name, OBJECT_PATH, INTERFACE_NAME, "getStationData");
dbus_message_append_args(message, dbus_message_append_args(request,
DBUS_TYPE_STRING, &call, DBUS_TYPE_STRING, &call,
DBUS_TYPE_INVALID); DBUS_TYPE_INVALID);
uint32_t value = 0; DBusMessage* response = makeCall(request);
DBusPendingCall* pending; if (response != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection);
dbus_message_unref(message);
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending);
dbus_uint32_t number; dbus_uint32_t number;
dbus_uint32_t algorithm; dbus_uint32_t algorithm;
dbus_uint32_t key; dbus_uint32_t key;
@ -232,7 +206,7 @@ uint32_t PatchCord::getPrivateIDForCall(const char* call)
const char* text; const char* text;
const char* symbol; const char* symbol;
if (dbus_message_get_args(message, NULL, if (dbus_message_get_args(response, NULL,
DBUS_TYPE_UINT32, &number, DBUS_TYPE_UINT32, &number,
DBUS_TYPE_UINT32, &algorithm, DBUS_TYPE_UINT32, &algorithm,
DBUS_TYPE_UINT32, &key, DBUS_TYPE_UINT32, &key,
@ -246,33 +220,27 @@ uint32_t PatchCord::getPrivateIDForCall(const char* call)
DBUS_TYPE_INVALID)) DBUS_TYPE_INVALID))
value = number; value = number;
dbus_pending_call_unref(pending); dbus_message_unref(response);
} }
dbus_message_unref(message);
return value; return value;
} }
bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text) bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text)
{ {
DBusMessage* message = dbus_message_new_method_call( bool result = false;
DBusMessage* request = dbus_message_new_method_call(
name, OBJECT_PATH, INTERFACE_NAME, "getStationData"); name, OBJECT_PATH, INTERFACE_NAME, "getStationData");
dbus_message_append_args(message, dbus_message_append_args(request,
DBUS_TYPE_UINT32, &number, DBUS_TYPE_UINT32, &number,
DBUS_TYPE_INVALID); DBUS_TYPE_INVALID);
bool result = false; DBusMessage* response = makeCall(request);
DBusPendingCall* pending; if (response != NULL)
if (dbus_connection_send_with_reply(connection, message, &pending, -1))
{ {
dbus_connection_flush(connection);
dbus_message_unref(message);
dbus_pending_call_block(pending);
message = dbus_pending_call_steal_reply(pending);
dbus_uint32_t number; dbus_uint32_t number;
dbus_uint32_t algorithm; dbus_uint32_t algorithm;
dbus_uint32_t key; dbus_uint32_t key;
@ -284,7 +252,7 @@ bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text)
const char* value2; const char* value2;
const char* symbol; const char* symbol;
if (dbus_message_get_args(message, NULL, if (dbus_message_get_args(response, NULL,
DBUS_TYPE_UINT32, &number, DBUS_TYPE_UINT32, &number,
DBUS_TYPE_UINT32, &algorithm, DBUS_TYPE_UINT32, &algorithm,
DBUS_TYPE_UINT32, &key, DBUS_TYPE_UINT32, &key,
@ -302,9 +270,28 @@ bool PatchCord::getCredentialsForID(uint32_t number, char* call, char* text)
result = true; result = true;
} }
dbus_pending_call_unref(pending); dbus_message_unref(response);
} }
dbus_message_unref(message);
return result; return result;
} }
DBusMessage* PatchCord::makeCall(DBusMessage* request, bool omission)
{
DBusPendingCall* pending;
DBusMessage* response = NULL;
if (dbus_connection_send_with_reply(connection, request, &pending, -1))
{
dbus_connection_flush(connection);
dbus_pending_call_block(pending);
response = dbus_pending_call_steal_reply(pending);
dbus_pending_call_unref(pending);
}
dbus_message_unref(request);
if (omission && response)
{
dbus_message_unref(response);
return NULL;
}
return response;
}

2
SVXLink/echolink/PatchCord.h
View file

@ -39,6 +39,8 @@ class PatchCord
void setSpecificValue(uint32_t key, uint32_t value); void setSpecificValue(uint32_t key, uint32_t value);
uint32_t getSpecificValue(uint32_t key); uint32_t getSpecificValue(uint32_t key);
DBusMessage* makeCall(DBusMessage* request, bool omission = false);
}; };
#endif #endif