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

359 lines
11 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];
} 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
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
connect_callback( struct mosquitto *mosq, void *userdata, int XP_UNUSED_DBG(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
{
add a basic password for mqtt
2020-06-11 22:11:56 +02:00
XP_LOGFF( "(err=%s)", mosquitto_strerror(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
XP_USE(mosq);
XP_USE(userdata);
/* int i; */
/* if(!result){ */
/* /\* Subscribe to broker information topics on successful connect. *\/ */
/* mosquitto_subscribe(mosq, NULL, "$SYS/#", 2); */
/* }else{ */
/* fprintf(stderr, "Connect failed\n"); */
/* } */
}
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 );
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 */
static bool
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
postMsg( MQTTConStorage* storage, XWStreamCtxt* stream, XP_U32 gameID,
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
{
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
XP_ASSERT(0); /* I need to go away! */
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
const XP_U8* bytes = stream_getPtr( stream );
XP_U16 len = stream_getSize( stream );
int mid;
#ifdef DEBUG
XP_UCHAR* sum = dutil_md5sum( storage->params->dutil, NULL_XWE, bytes, len );
XP_LOGFF( "sending %d bytes with sum %s", len, sum );
XP_FREEP( storage->params->mpool, &sum );
#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
XP_UCHAR topicStorage[128];
XP_UCHAR* topics[4];
XP_U16 nTopics = VSIZE(topics);
dvc_getMQTTPubTopics( storage->params->dutil, NULL_XWE,
invitee, gameID, topicStorage, VSIZE(topicStorage),
&nTopics, topics );
bool success = XP_TRUE;
for ( int ii = 0; success && ii < nTopics; ++ii ) {
int err = mosquitto_publish( storage->mosq, &mid, topics[ii],
len, bytes, DEFAULT_QOS, true );
XP_LOGFF( "mosquitto_publish(topic=%s) => %s; mid=%d", topics[ii],
mosquitto_strerror(err), mid );
success = 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
stream_destroy( stream, NULL_XWE );
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
return success;
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
}
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
static bool
postOne( MQTTConStorage* storage, const XP_UCHAR* topic, XWStreamCtxt* stream )
{
const XP_U8* bytes = stream_getPtr( stream );
XP_U16 len = stream_getSize( stream );
int mid;
int err = mosquitto_publish( storage->mosq, &mid, topic,
len, bytes, DEFAULT_QOS, true );
XP_LOGFF( "mosquitto_publish(topic=%s) => %s; mid=%d", topic,
mosquitto_strerror(err), mid );
XP_ASSERT( 0 == err );
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
LOG_FUNC();
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 ) {
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
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 );
more
2022-10-08 19:41:29 +02:00
int mid;
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
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],
more
2022-10-08 19:41:29 +02:00
mosquitto_strerror(err), mid );
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
}
more
2022-10-08 19:41:29 +02: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
}
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;
}
void
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
mqttc_invite( LaunchParams* params, XP_U32 timestamp, const NetLaunchInfo* nli,
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
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
XP_USE( timestamp );
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
XWStreamCtxt* stream = mem_stream_make_raw( MPPARM(params->mpool)
params->vtMgr );
add timestamp to saved msgs, modify mqtt header to include later I want receiver to know when message was originally created. This adds timestamp to messages and passes it via send proc. Client needs to send it where possible. So far, MQTT format can't include it without change, so I'm adding a new proto version. This change can read the new version. Once that's well-enough distributed I can start sending using it. Other transmission types than MQTT are for later.
2022-06-29 21:29:32 +02:00
dvc_makeMQTTInvite( params->dutil, NULL_XWE, stream, nli, 0 );
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
postMsg( storage, stream, nli->gameID, 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
}
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
static void
msgAndTopicProc( void* closure, const XP_UCHAR* topic, XWStreamCtxt* stream )
{
MQTTConStorage* storage = (MQTTConStorage*)closure;
(void)postOne( storage, topic, stream );
}
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
add timestamp to saved msgs, modify mqtt header to include later I want receiver to know when message was originally created. This adds timestamp to messages and passes it via send proc. Client needs to send it where possible. So far, MQTT format can't include it without change, so I'm adding a new proto version. This change can read the new version. Once that's well-enough distributed I can start sending using it. Other transmission types than MQTT are for later.
2022-06-29 21:29:32 +02:00
mqttc_send( LaunchParams* params, XP_U32 gameID, XP_U32 timestamp,
const XP_U8* buf, XP_U16 len, 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 );
snapshot: new mqtt msg format allowing multiple messages
2022-12-20 04:53:57 +01:00
dvc_makeMQTTMessages( params->dutil, NULL_XWE,
msgAndTopicProc, storage,
addressee, gameID, timestamp, buf, len );
return len;
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 );
XWStreamCtxt* stream = mem_stream_make_raw( MPPARM(params->mpool)
params->vtMgr );
add timestamp to saved msgs, modify mqtt header to include later I want receiver to know when message was originally created. This adds timestamp to messages and passes it via send proc. Client needs to send it where possible. So far, MQTT format can't include it without change, so I'm adding a new proto version. This change can read the new version. Once that's well-enough distributed I can start sending using it. Other transmission types than MQTT are for later.
2022-06-29 21:29:32 +02:00
dvc_makeMQTTNoSuchGame( params->dutil, NULL_XWE, stream, gameID, 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
postMsg( storage, stream, gameID, 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
}
Reference in a new issue Copy permalink