Miroirs/xwords
1
0
Fork 0
mirror of git://xwords.git.sourceforge.net/gitroot/xwords/xwords synced 2024-12-29 10:26:36 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
xwords/xwords4/linux/mqttcon.c

324 lines
9.8 KiB
C
Raw Normal View History

add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
/* -*- compile-command: "make MEMDEBUG=TRUE -j3"; -*- */
/*
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
* Copyright 2020 - 2022 by Eric House (xwords@eehouse.org). All rights
* reserved.
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
*
* This program 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 2
* of the License, or (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <mosquitto.h>
#include "mqttcon.h"
#include "gsrcwrap.h"
#include "device.h"
#include "strutils.h"
typedef struct _MQTTConStorage {
LaunchParams* params;
struct mosquitto* mosq;
MQTTDevID clientID;
gchar clientIDStr[32];
int msgPipe[2];
linux: subscribe only after connect succeeds
2023-01-11 20:10:45 +01:00
XP_Bool connected;
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
} MQTTConStorage;
#define DEFAULT_QOS 2
static MQTTConStorage*
getStorage( LaunchParams* params )
{
MQTTConStorage* storage = (MQTTConStorage*)params->mqttConStorage;
if ( NULL == storage ) {
storage = XP_CALLOC( params->mpool, sizeof(*storage) );
params->mqttConStorage = storage;
}
return storage;
}
static void
loadClientID( LaunchParams* params, MQTTConStorage* storage )
{
dvc_getMQTTDevID( params->dutil, NULL_XWE, &storage->clientID );
formatMQTTDevID( &storage->clientID, storage->clientIDStr,
VSIZE(storage->clientIDStr) );
force 16-letter devids
2020-06-01 08:42:44 +02:00
XP_ASSERT( 16 == strlen(storage->clientIDStr) );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
static void
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
onMessageReceived( struct mosquitto* XP_UNUSED_DBG(mosq), void *userdata,
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
const struct mosquitto_message* message )
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
{
XP_LOGFF( "(len=%d)", message->payloadlen );
MQTTConStorage* storage = (MQTTConStorage*)userdata;
XP_ASSERT( storage->mosq == mosq );
XP_ASSERT( message->payloadlen < 0x7FFF );
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
const int msgPipe = storage->msgPipe[1];
/* write topic, then message */
const char* topic = message->topic;
short msgLen = htons(1 + strlen(topic));
write( msgPipe, &msgLen, sizeof(msgLen) );
write( msgPipe, topic, 1 + strlen(topic) );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
short len = (short)message->payloadlen;
len = htons( len );
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
write( msgPipe, &len, sizeof(len) );
write( msgPipe, message->payload, message->payloadlen );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
static void
linux: subscribe only after connect succeeds
2023-01-11 20:10:45 +01:00
connect_callback( struct mosquitto* mosq, void* userdata,
int XP_UNUSED_DBG(connErr) )
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
{
linux: subscribe only after connect succeeds
2023-01-11 20:10:45 +01:00
XP_LOGFF( "(err=%s)", mosquitto_strerror(connErr) );
MQTTConStorage* storage = (MQTTConStorage*)userdata;
storage->connected = XP_TRUE;
XP_UCHAR topicStorage[256];
XP_UCHAR* topics[4];
XP_U16 nTopics = VSIZE(topics);
dvc_getMQTTSubTopics( storage->params->dutil, NULL_XWE,
topicStorage, VSIZE(topicStorage),
&nTopics, topics );
int mid;
int err = mosquitto_subscribe_multiple( mosq, &mid, nTopics, topics,
DEFAULT_QOS, 0, NULL );
XP_LOGFF( "mosquitto_subscribe(topics[0]=%s, etc) => %s, mid=%d", topics[0],
mosquitto_strerror(err), mid );
refactor message queue access Cleanup to reduce changes when queue storage changes, which is coming to optimize mqtt sends.
2023-02-02 04:08:04 +01:00
XP_USE(err);
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
static void
subscribe_callback( struct mosquitto *mosq, void *userdata, int mid,
int qos_count, const int *granted_qos)
{
XP_USE(mosq);
XP_USE(userdata);
XP_USE(mid);
XP_USE(qos_count);
XP_USE(granted_qos);
XP_LOGFF ("Subscribed (mid: %d): %d", mid, granted_qos[0]);
add a basic password for mqtt
2020-06-11 22:11:56 +02:00
for ( int ii = 1; ii < qos_count; ii++ ) {
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
XP_LOGFF(", %d", granted_qos[ii]);
}
}
static void
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
log_callback( struct mosquitto *mosq, void *userdata, int level,
cleanup (mostly non-DBG compile errors)
2021-03-19 21:03:39 +01:00
const char* str )
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
{
XP_USE(mosq);
XP_USE(userdata);
XP_USE(level);
remove or tweak logging
2021-03-15 15:52:54 +01:00
XP_USE(str);
/* XP_LOGFF( "msg: %s", str ); */
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
static gboolean
handle_gotmsg( GIOChannel* source, GIOCondition XP_UNUSED(condition), gpointer data )
{
// XP_LOGFF( "(len=%d)", message->payloadlen );
LOG_FUNC();
MQTTConStorage* storage = (MQTTConStorage*)data;
int pipe = g_io_channel_unix_get_fd( source );
XP_ASSERT( pipe == storage->msgPipe[0] );
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
short topicLen;
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#ifdef DEBUG
ssize_t nRead =
#endif
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
read( pipe, &topicLen, sizeof(topicLen) );
XP_ASSERT( nRead == sizeof(topicLen) );
topicLen = ntohs(topicLen);
XP_U8 topicBuf[topicLen];
#ifdef DEBUG
nRead =
#endif
read( pipe, topicBuf, topicLen );
XP_ASSERT( nRead == topicLen);
XP_ASSERT( '\0' == topicBuf[topicLen-1] );
short msgLen;
#ifdef DEBUG
nRead =
#endif
read( pipe, &msgLen, sizeof(msgLen) );
XP_ASSERT( nRead == sizeof(msgLen) );
msgLen = ntohs(msgLen);
XP_U8 msgBuf[msgLen];
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#ifdef DEBUG
nRead =
#endif
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
read( pipe, msgBuf, msgLen );
XP_ASSERT( nRead == msgLen );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
use persist flag and new per-game mqtt topics (too) I didn't understand MQTT at all. Per the docs anyway it only keeps a message around if its "persist" flag is set, and then it only keeps the most recent per topic. I expected that when a device connected, messages would be waiting for it, but that's apparently not true (some evidence to the contrary.) But having all games on a device share the same topic means only one message can be waiting. So switch to including gameID in the topic, subscribing to a wildcard topic and sending to a different one per game. For now, for legacy purposes, we'll keep sending to the old per-device topic.
2022-12-16 22:33:36 +01:00
dvc_parseMQTTPacket( storage->params->dutil, NULL_XWE,
(XP_UCHAR*)topicBuf, msgBuf, msgLen );
refactor message queue access Cleanup to reduce changes when queue storage changes, which is coming to optimize mqtt sends.
2023-02-02 04:08:04 +01:00
LOG_RETURN_VOID();
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
return TRUE;
} /* handle_gotmsg */
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
static bool
API cleanup and all done This should complete sending to multiple topics (for backwards compatibility) and supporting combined messages in the future (sending them is hard; receiving not so much.)
2022-12-20 20:55:30 +01:00
postOne( MQTTConStorage* storage, const XP_UCHAR* topic, const XP_U8* buf, XP_U16 len )
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
{
linux: subscribe only after connect succeeds
2023-01-11 20:10:45 +01:00
int err = -1;
if ( storage->connected ) {
int mid;
err = mosquitto_publish( storage->mosq, &mid, topic,
API cleanup and all done This should complete sending to multiple topics (for backwards compatibility) and supporting combined messages in the future (sending them is hard; receiving not so much.)
2022-12-20 20:55:30 +01:00
len, buf, DEFAULT_QOS, true );
linux: subscribe only after connect succeeds
2023-01-11 20:10:45 +01:00
XP_LOGFF( "mosquitto_publish(topic=%s, len=%d) => %s; mid=%d", topic,
len, mosquitto_strerror(err), mid );
} else {
XP_LOGFF( "not connected and so not sending" );
}
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
return 0 == err;
}
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
void
mqttc_init( LaunchParams* params )
{
more
2022-10-08 19:41:29 +02:00
if ( types_hasType( params->conTypes, COMMS_CONN_MQTT ) ) {
XP_ASSERT( !params->mqttConStorage );
MQTTConStorage* storage = getStorage( params );
storage->params = params;
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
more
2022-10-08 19:41:29 +02:00
loadClientID( params, storage );
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#ifdef DEBUG
more
2022-10-08 19:41:29 +02:00
int res =
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#endif
more
2022-10-08 19:41:29 +02:00
pipe( storage->msgPipe );
XP_ASSERT( !res );
ADD_SOCKET( storage, storage->msgPipe[0], handle_gotmsg );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
more
2022-10-08 19:41:29 +02:00
int err = mosquitto_lib_init();
XP_LOGFF( "mosquitto_lib_init() => %d", err );
XP_ASSERT( 0 == err );
bool cleanSession = false;
struct mosquitto* mosq = storage->mosq =
mosquitto_new( storage->clientIDStr, cleanSession, storage );
err = mosquitto_username_pw_set( mosq, "xwuser", "xw4r0cks" );
XP_LOGFF( "mosquitto_username_pw_set() => %s", mosquitto_strerror(err) );
mosquitto_log_callback_set( mosq, log_callback );
mosquitto_connect_callback_set( mosq, connect_callback );
mosquitto_message_callback_set( mosq, onMessageReceived );
mosquitto_subscribe_callback_set( mosq, subscribe_callback );
int keepalive = 60;
err = mosquitto_connect( mosq, params->connInfo.mqtt.hostName,
params->connInfo.mqtt.port, keepalive );
XP_LOGFF( "mosquitto_connect(host=%s) => %s", params->connInfo.mqtt.hostName,
mosquitto_strerror(err) );
if ( MOSQ_ERR_SUCCESS == err ) {
err = mosquitto_loop_start( mosq );
XP_ASSERT( !err );
} else {
XP_LOGFF( "failed to connect so not proceeding" );
}
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
} else {
more
2022-10-08 19:41:29 +02:00
XP_LOGFF( "MQTT disabled; doing nothing" );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
}
void
mqttc_cleanup( LaunchParams* params )
{
MQTTConStorage* storage = getStorage( params );
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#ifdef DEBUG
int err =
#endif
mosquitto_loop_stop( storage->mosq, true ); /* blocks until thread dies */
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
XP_LOGFF( "mosquitto_loop_stop() => %s", mosquitto_strerror(err) );
mosquitto_destroy( storage->mosq );
storage->mosq = NULL;
mosquitto_lib_cleanup();
XP_ASSERT( params->mqttConStorage == storage ); /* cheat */
XP_FREEP( params->mpool, &storage );
params->mqttConStorage = NULL;
}
const MQTTDevID*
mqttc_getDevID( LaunchParams* params )
{
MQTTConStorage* storage = getStorage( params );
return &storage->clientID;
}
const gchar*
mqttc_getDevIDStr( LaunchParams* params )
{
MQTTConStorage* storage = getStorage( params );
return storage->clientIDStr;
}
invitations work on linux
2022-12-20 18:20:02 +01:00
static void
API cleanup and all done This should complete sending to multiple topics (for backwards compatibility) and supporting combined messages in the future (sending them is hard; receiving not so much.)
2022-12-20 20:55:30 +01:00
msgAndTopicProc( void* closure, const XP_UCHAR* topic, const XP_U8* buf, XP_U16 len )
invitations work on linux
2022-12-20 18:20:02 +01:00
{
MQTTConStorage* storage = (MQTTConStorage*)closure;
API cleanup and all done This should complete sending to multiple topics (for backwards compatibility) and supporting combined messages in the future (sending them is hard; receiving not so much.)
2022-12-20 20:55:30 +01:00
(void)postOne( storage, topic, buf, len );
invitations work on linux
2022-12-20 18:20:02 +01:00
}
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
void
fix linux compile; log gameID as %X everywhere
2022-12-31 01:14:22 +01:00
mqttc_invite( LaunchParams* params, const NetLaunchInfo* nli,
snapshot: mqtt invites for gtk work via comms Merge that won't compile, but I want it to start fromp
2022-09-06 21:16:29 +02:00
const MQTTDevID* invitee )
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
{
MQTTConStorage* storage = getStorage( params );
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#ifdef DEBUG
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
gchar buf[32];
XP_LOGFF( "need to send to %s", formatMQTTDevID(invitee, buf, sizeof(buf) ) );
force 16-letter devids
2020-06-01 08:42:44 +02:00
XP_ASSERT( 16 == strlen(buf) );
add filtering to wordlist browser Add a basic regular expression engine to the dictiter, and to the UI add the ability to filter for "starts with", "contains" and "ends with", which translate into ANDed RE_*, _*RE_* and _*RE, respectively (with _ standing for blank/wildcard). The engine's tightly integrated with the next/prevWord() functions for greatest possible speed, but unless there's no pattern does slow things down a bit (especially when "ENDS WITH" is used.) The full engine is not exposed (users can't provide raw REs), and while the parser will accept nesting (e.g. ([AB]_*[CD]){2,5} to mean words from 2-5 tiles long starting with A or B and ending with C or D) the engine can't handle it. Which is why filtering for word length is handled separately from REs (but also tightly integrated.) Users can enter strings that don't map to tiles. They now get an error. It made sense for the error alert to have a "Show tiles" button, so there's now a dialog listing all the tiles in a wordlist, something the browser has needed all along.
2020-08-05 18:25:33 +02:00
#endif
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
invitations work on linux
2022-12-20 18:20:02 +01:00
dvc_makeMQTTInvites( params->dutil, NULL_XWE, msgAndTopicProc, storage,
fix linux compile; log gameID as %X everywhere
2022-12-31 01:14:22 +01:00
invitee, nli );
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
}
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
XP_S16
fix linux compile; log gameID as %X everywhere
2022-12-31 01:14:22 +01:00
mqttc_send( LaunchParams* params, XP_U32 gameID,
toward changing APIs to allow combined messages for mqtt
2023-03-18 03:21:57 +01:00
XP_U16 nMsgs, SendMsgsPacket msgs[],
XP_U16 streamVersion, const MQTTDevID* addressee )
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
{
MQTTConStorage* storage = getStorage( params );
toward changing APIs to allow combined messages for mqtt
2023-03-18 03:21:57 +01:00
XP_S16 nSent = dvc_makeMQTTMessages( params->dutil, NULL_XWE,
msgAndTopicProc, storage,
nMsgs, msgs, addressee,
gameID, streamVersion );
return nSent;
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
Once received, nuke invite on mqtt broker To prevent deleted games' ghost invitations from remaining as persisted on a topic and so being received over and over, have recipient of invitation send an empty message on the same topic to remove them. Any message sent once the game start would have replaced the invitation, but sometimes if the sender is deleted at the right time there's none.
2023-01-25 02:23:30 +01:00
void
mqttc_onInviteHandled( LaunchParams* params, const NetLaunchInfo* nli )
{
LOG_FUNC();
MQTTConStorage* storage = getStorage( params );
dvc_makeMQTTNukeInvite( params->dutil, NULL_XWE,
msgAndTopicProc, storage, nli );
}
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
void
mqttc_notifyGameGone( LaunchParams* params, const MQTTDevID* addressee, XP_U32 gameID )
{
MQTTConStorage* storage = getStorage( params );
API cleanup and all done This should complete sending to multiple topics (for backwards compatibility) and supporting combined messages in the future (sending them is hard; receiving not so much.)
2022-12-20 20:55:30 +01:00
dvc_makeMQTTNoSuchGames( params->dutil, NULL_XWE,
msgAndTopicProc, storage,
fix linux compile; log gameID as %X everywhere
2022-12-31 01:14:22 +01:00
addressee, gameID );
add mqtt as a new transport This is meant to replace the relay eventually, but for now it's a new option, like BT or SMS, to be chosen. Protocol is handled in common/ code for the first time, meaning that linux and android interact without the need to keep two platforms in sync. Linux uses lib-mosquitto, and Android uses eclipse's Paho client (the generic java version, not the one that uses four-year-old Service patterns and so crashes for SDK >= 26.)
2020-05-20 22:58:53 +02:00
}
Reference in a new issue Copy permalink