martin/aqhomecontrol
Public Access
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplified IPC code to use less different IPC messages. Share more code. More qork on MQTT code.

Browse Source
This commit is contained in:
Martin Preuss
2023-10-01 21:31:02 +02:00
parent 0f896c1729
commit 1e27223dfa
50 changed files with 1326 additions and 698 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
aqhome/data/device.t2d
View File

@@ -37,28 +37,35 @@
<flags>with_getbymember</flags>
</member>
<member name="roomId" type="uint64_t" maxlen="8">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags></flags>
</member>
<member name="name" type="char_ptr" maxlen="32">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own with_getbymember</flags>
</member>
<member name="deviceType" type="char_ptr" maxlen="64">
<member name="roomName" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own</flags>
</member>
<member name="location" type="char_ptr" maxlen="32">
<member name="nameForDriver" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own</flags>
</member>
<member name="nameForSystem" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own with_getbymember</flags>
</member>
<member name="nameForGui" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own with_getbymember</flags>
</member>
<member name="location" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
@@ -72,6 +79,21 @@
<flags>own</flags>
</member>
<member name="deviceType" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own</flags>
</member>
<member name="manufacturer" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own</flags>
</member>
</members>
</type>

14
aqhome/data/value.t2d
View File

@@ -73,6 +73,20 @@
<flags>own with_getbymember</flags>
</member>
<member name="deviceNameForDriver" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own</flags>
</member>
<member name="deviceNameForSystem" type="char_ptr" maxlen="128">
<default>0</default>
<preset>0</preset>
<access>public</access>
<flags>own</flags>
</member>
<member name="valueType" type="int" maxlen="8">
<default>0</default>
<preset>0</preset>

1
aqhome/ipc/0BUILD
View File

@@ -55,6 +55,7 @@
<headers dist="true" >
endpoint_ipc_p.h
msg_ipc_tag16_p.h
</headers>

242
aqhome/ipc/data/ipc_data.c
View File

@@ -12,5 +12,247 @@
#include <aqhome/ipc/data/ipc_data.h>
#include <aqhome/ipc/msg_ipc_tag16.h>
#include <aqhome/data/value.h>
#include <gwenhywfar/debug.h>
#include <gwenhywfar/tag16.h>
/* ------------------------------------------------------------------------------------------------
* defines
* ------------------------------------------------------------------------------------------------
*/
#define AQH_IPCDATA_VALUE_TAGS_ID 0x01
#define AQH_IPCDATA_VALUE_TAGS_DRIVER 0x02
#define AQH_IPCDATA_VALUE_TAGS_NAMEFORDRIVER 0x03
#define AQH_IPCDATA_VALUE_TAGS_NAMEFORSYSTEM 0x04
#define AQH_IPCDATA_VALUE_TAGS_TYPE 0x05
#define AQH_IPCDATA_VALUE_TAGS_UNITS 0x06
#define AQH_IPCDATA_VALUE_TAGS_TIMEOFCREATION 0x07
#define AQH_IPCDATA_VALUE_TAGS_DEVFORDRIVER 0x08
#define AQH_IPCDATA_VALUE_TAGS_DEVFORSYSTEM 0x09
/* ------------------------------------------------------------------------------------------------
* forward declarations
* ------------------------------------------------------------------------------------------------
*/
static void _writeValueFieldsAsTagsToBuffer(const AQH_VALUE *value, GWEN_BUFFER *buf);
static AQH_VALUE *_readValueFromTag(const uint8_t *ptr, uint32_t len);
/* ------------------------------------------------------------------------------------------------
* code
* ------------------------------------------------------------------------------------------------
*/
int AQH_DataIpc_WriteValueListAsTagsToBuffer(unsigned int tagType, const AQH_VALUE_LIST *valueList, GWEN_BUFFER *buf)
{
if (valueList) {
const AQH_VALUE *value;
value=AQH_Value_List_First(valueList);
while(value) {
int rv;
rv=AQH_DataIpc_WriteValueAsTagToBuffer(tagType, value, buf);
if (rv<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return rv;
}
value=AQH_Value_List_Next(value);
}
}
return 0;
}
int AQH_DataIpc_WriteValueAsTagToBuffer(unsigned int tagType, const AQH_VALUE *value, GWEN_BUFFER *buf)
{
int startPos;
int rv;
startPos=GWEN_Tag16_StartTagInBuffer(tagType, buf);
if (startPos<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", startPos);
return startPos;
}
_writeValueFieldsAsTagsToBuffer(value, buf);
rv=GWEN_Tag16_EndTagInBuffer(startPos, buf);
if (rv<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
return rv;
}
return 0;
}
void _writeValueFieldsAsTagsToBuffer(const AQH_VALUE *value, GWEN_BUFFER *buf)
{
const char *s;
GWEN_Tag16_WriteUint64TagToBuffer(AQH_IPCDATA_VALUE_TAGS_ID, AQH_Value_GetId(value), buf);
s=AQH_Value_GetDriver(value);
if (s && *s)
GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_DRIVER, s, buf);
s=AQH_Value_GetNameForDriver(value);
if (s && *s)
GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_NAMEFORDRIVER, s, buf);
s=AQH_Value_GetNameForSystem(value);
if (s && *s)
GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_NAMEFORSYSTEM, s, buf);
GWEN_Tag16_WriteUint32TagToBuffer(AQH_IPCDATA_VALUE_TAGS_TYPE, AQH_Value_GetValueType(value), buf);
s=AQH_Value_GetValueUnits(value);
if (s && *s)
GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_UNITS, s, buf);
GWEN_Tag16_WriteUint64TagToBuffer(AQH_IPCDATA_VALUE_TAGS_TIMEOFCREATION, AQH_Value_GetTimestampCreation(value), buf);
s=AQH_Value_GetDeviceNameForDriver(value);
if (s && *s)
GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_DEVFORDRIVER, s, buf);
s=AQH_Value_GetDeviceNameForSystem(value);
if (s && *s)
GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_DEVFORSYSTEM, s, buf);
}
AQH_VALUE_LIST *AQH_DataIpc_ReadValuesFromTagList(const GWEN_TAG16_LIST *tagList, unsigned int wantedTagType)
{
AQH_VALUE_LIST *valueList;
const GWEN_TAG16 *tag;
valueList=AQH_Value_List_new();
tag=GWEN_Tag16_List_First(tagList);
while(tag) {
unsigned int tagType;
AQH_VALUE *value;
tagType=GWEN_Tag16_GetTagType(tag);
if (tagType==wantedTagType) {
value=_readValueFromTag((const uint8_t*) GWEN_Tag16_GetTagData(tag), (uint32_t) GWEN_Tag16_GetTagLength(tag));
if (value)
AQH_Value_List_Add(value, valueList);
}
tag=GWEN_Tag16_List_Next(tag);
}
if (AQH_Value_List_GetCount(valueList)<1) {
AQH_Value_List_free(valueList);
return NULL;
}
return valueList;
}
AQH_VALUE *AQH_DataIpc_ReadValueFromTagList(const GWEN_TAG16_LIST *tagList, unsigned int wantedTagType)
{
if (tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, wantedTagType);
return tag?_readValueFromTag((const uint8_t*) GWEN_Tag16_GetTagData(tag), (uint32_t) GWEN_Tag16_GetTagLength(tag)):NULL;
}
return NULL;
}
AQH_VALUE *_readValueFromTag(const uint8_t *ptr, uint32_t len)
{
GWEN_TAG16_LIST *tagList;
tagList=GWEN_Tag16_List_fromBuffer(ptr, len, 0);
if (tagList) {
GWEN_TAG16 *tag;
AQH_VALUE *value;
value=AQH_Value_new();
tag=GWEN_Tag16_List_First(tagList);
while(tag) {
unsigned int tagType;
char *s;
tagType=GWEN_Tag16_GetTagType(tag);
switch(tagType) {
case AQH_IPCDATA_VALUE_TAGS_ID:
AQH_Value_SetId(value, GWEN_Tag16_GetTagDataAsUint64(tag, 0));
break;
case AQH_IPCDATA_VALUE_TAGS_DRIVER:
s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
AQH_Value_SetDriver(value, s);
free(s);
break;
case AQH_IPCDATA_VALUE_TAGS_NAMEFORDRIVER:
s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
AQH_Value_SetNameForDriver(value, s);
free(s);
break;
case AQH_IPCDATA_VALUE_TAGS_NAMEFORSYSTEM:
s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
AQH_Value_SetNameForSystem(value, s);
free(s);
break;
case AQH_IPCDATA_VALUE_TAGS_TYPE:
AQH_Value_SetValueType(value, GWEN_Tag16_GetTagDataAsUint32(tag, 0));
break;
case AQH_IPCDATA_VALUE_TAGS_UNITS:
s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
AQH_Value_SetValueUnits(value, s);
free(s);
break;
case AQH_IPCDATA_VALUE_TAGS_TIMEOFCREATION:
AQH_Value_SetTimestampCreation(value, GWEN_Tag16_GetTagDataAsUint64(tag, 0));
break;
case AQH_IPCDATA_VALUE_TAGS_DEVFORDRIVER:
s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
AQH_Value_SetDeviceNameForDriver(value, s);
free(s);
break;
case AQH_IPCDATA_VALUE_TAGS_DEVFORSYSTEM:
s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
AQH_Value_SetDeviceNameForSystem(value, s);
free(s);
break;
default:
DBG_INFO(AQH_LOGDOMAIN, "Unhandled tag typ %d (%02x)", tagType, tagType);
break;
}
tag=GWEN_Tag16_List_Next(tag);
}
GWEN_Tag16_List_free(tagList);
return value;
}
return NULL;
}

14
aqhome/ipc/data/ipc_data.h
View File

@@ -11,8 +11,12 @@
#include <aqhome/api.h>
#include <aqhome/data/value.h>
#include <gwenhywfar/msg_ipc.h>
#include <gwenhywfar/buffer.h>
#include <gwenhywfar/tag16.h>
#define AQH_IPC_PROTOCOL_DATA_ID 2
@@ -41,6 +45,16 @@
/* utils */
AQHOME_API int AQH_DataIpc_WriteValueListAsTagsToBuffer(unsigned int tagType, const AQH_VALUE_LIST *valueList, GWEN_BUFFER *buf);
AQHOME_API int AQH_DataIpc_WriteValueAsTagToBuffer(unsigned int tagType, const AQH_VALUE *value, GWEN_BUFFER *buf);
AQHOME_API AQH_VALUE_LIST *AQH_DataIpc_ReadValuesFromTagList(const GWEN_TAG16_LIST *tagList, unsigned int wantedTagType);
AQHOME_API AQH_VALUE *AQH_DataIpc_ReadValueFromTagList(const GWEN_TAG16_LIST *tagList, unsigned int wantedTagType);
#endif

30
aqhome/ipc/data/msg_data_connect.c
View File

@@ -49,28 +49,23 @@ GWEN_MSG *AQH_ConnectDataIpcMsg_new(uint16_t code, const char *clientId, const c
void AQH_ConnectDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy)
{
AQH_Tag16IpcMsg_ExtendAndParse(msg, doCopy);
}
void AQH_ConnectDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
if (GWEN_Msg_GetBytesInBuffer(msg)>=AQH_MSGDATA_CONNECT_MINSIZE) {
GWEN_TAG16_LIST *tagList;
char *clientId=NULL;
char *userId=NULL;
uint32_t flags=0;
char *clientId;
char *userId;
uint32_t flags;
tagList=AQH_Tag16IpcMsg_ParseTags(msg, 0);
if (tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_CONNECT_TAGS_CLIENTID);
clientId=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_CONNECT_TAGS_USERID);
userId=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_CONNECT_TAGS_FLAGS);
flags=tag?GWEN_Tag16_GetTagDataAsUint32(tag, 0):0;
}
clientId=AQH_Tag16IpcMsg_GetTagDataAsNewString(msg, AQH_MSGDATA_CONNECT_TAGS_CLIENTID, NULL);
userId=AQH_Tag16IpcMsg_GetTagDataAsNewString(msg, AQH_MSGDATA_CONNECT_TAGS_USERID, NULL);
flags=AQH_Tag16IpcMsg_GetTagDataAsUint32(msg, AQH_MSGDATA_CONNECT_TAGS_FLAGS, 0);
GWEN_Buffer_AppendArgs(dbuf,
"CONNECT (code=%d, proto=%d, proto version=%d, clientId=%s, userId=%s, flags=%08x)\n",
@@ -82,7 +77,6 @@ void AQH_ConnectDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf,
flags);
free(userId);
free(clientId);
GWEN_Tag16_List_free(tagList);
}
}

2
aqhome/ipc/data/msg_data_connect.h
View File

@@ -35,6 +35,8 @@ AQHOME_API GWEN_MSG *AQH_ConnectDataIpcMsg_new(uint16_t code,
const char *userId, const char *password,
uint32_t flags);
AQHOME_API void AQH_ConnectDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy);
AQHOME_API int AQH_ConnectDataIpcMsg_IsValid(const GWEN_MSG *msg);
AQHOME_API void AQH_ConnectDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);

24
aqhome/ipc/data/msg_data_getdata.c
View File

@@ -46,28 +46,23 @@ GWEN_MSG *AQH_GetDataDataIpcMsg_new(uint16_t code, const char *valueName, uint64
void AQH_GetDataDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy)
{
AQH_Tag16IpcMsg_ExtendAndParse(msg, doCopy);
}
void AQH_GetDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
if (GWEN_Msg_GetBytesInBuffer(msg)>=AQH_MSGDATA_GETDATA_MINSIZE) {
GWEN_TAG16_LIST *tagList;
char *valueName=NULL;
uint64_t tsBegin=0;
uint64_t tsEnd=0;
tagList=AQH_Tag16IpcMsg_ParseTags(msg, 0);
if (tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_GETDATA_TAGS_NAME);
valueName=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_GETDATA_TAGS_BEGIN);
tsBegin=tag?GWEN_Tag16_GetTagDataAsUint64(tag, 0):0;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_GETDATA_TAGS_END);
tsEnd=tag?GWEN_Tag16_GetTagDataAsUint64(tag, 0):0;
}
valueName=AQH_Tag16IpcMsg_GetTagDataAsNewString(msg, AQH_MSGDATA_GETDATA_TAGS_NAME, NULL);
tsBegin=AQH_Tag16IpcMsg_GetTagDataAsUint64(msg, AQH_MSGDATA_GETDATA_TAGS_BEGIN, 0);
tsEnd=AQH_Tag16IpcMsg_GetTagDataAsUint64(msg, AQH_MSGDATA_GETDATA_TAGS_END, 0);
GWEN_Buffer_AppendArgs(dbuf,
"GETDATA (code=%d, proto=%d, proto version=%d, name=%s, tsBegin=%lu, tsEnd=%lu)\n",
@@ -78,7 +73,6 @@ void AQH_GetDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf,
(unsigned long int) tsBegin,
(unsigned long int) tsEnd);
free(valueName);
GWEN_Tag16_List_free(tagList);
}
}

2
aqhome/ipc/data/msg_data_getdata.h
View File

@@ -29,6 +29,8 @@
AQHOME_API GWEN_MSG *AQH_GetDataDataIpcMsg_new(uint16_t code, const char *valueName, uint64_t tsBegin, uint64_t tsEnd);
AQHOME_API void AQH_GetDataDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy);
AQHOME_API void AQH_GetDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);

93
aqhome/ipc/data/msg_data_multidata.c
View File

@@ -27,19 +27,21 @@
GWEN_MSG *AQH_MultiDataDataIpcMsg_new(uint16_t code,
const char *valueName, const char *valueUnits, int valueType,
const uint64_t *i64Ptr, int numOfDataPoints)
GWEN_MSG *AQH_MultiDataDataIpcMsg_new(uint16_t code, const AQH_VALUE *value, const uint64_t *i64Ptr, int numOfDataPoints)
{
GWEN_MSG *msg;
GWEN_BUFFER *buf;
int rv;
buf=GWEN_Buffer_new(0, 256, 0, 1);
if (valueName && *valueName)
GWEN_Tag16_WriteStringTagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_NAME, valueName, buf);
if (valueUnits && *valueUnits)
GWEN_Tag16_WriteStringTagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_UNITS, valueUnits, buf);
GWEN_Tag16_WriteUint32TagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_TYPE, valueType, buf);
rv=AQH_DataIpc_WriteValueAsTagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_VALUE, value, buf);
if (rv<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return NULL;
}
if (i64Ptr && numOfDataPoints)
GWEN_Tag16_WriteTagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_DATA, (const uint8_t*)i64Ptr, numOfDataPoints*2*sizeof(uint64_t), buf);
@@ -51,32 +53,67 @@ GWEN_MSG *AQH_MultiDataDataIpcMsg_new(uint16_t code,
GWEN_MSG *AQH_MultiDataDataIpcMsg_newForOne(uint16_t code, const AQH_VALUE *value, uint64_t timeStamp, double dataPoint)
{
GWEN_MSG *msg;
GWEN_BUFFER *buf;
int rv;
union {double f; uint64_t i;} u;
uint64_t arrayToSend[2];
buf=GWEN_Buffer_new(0, 256, 0, 1);
rv=AQH_DataIpc_WriteValueAsTagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_VALUE, value, buf);
if (rv<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return NULL;
}
arrayToSend[0]=timeStamp;
u.f=dataPoint;
arrayToSend[1]=u.i;
GWEN_Tag16_WriteTagToBuffer(AQH_MSGDATA_MULTIDATA_TAGS_DATA, (const uint8_t*) arrayToSend, 2*sizeof(uint64_t), buf);
msg=AQH_Tag16IpcMsg_new(AQH_IPC_PROTOCOL_DATA_ID, AQH_IPC_PROTOCOL_DATA_VERSION, code,
GWEN_Buffer_GetUsedBytes(buf), (const uint8_t*) GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return msg;
}
void AQH_MultiDataDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy)
{
AQH_Tag16IpcMsg_ExtendAndParse(msg, doCopy);
}
AQH_VALUE *AQH_MultiDataDataIpcMsg_ReadValue(const GWEN_MSG *msg)
{
return AQH_DataIpc_ReadValueFromTagList(AQH_Tag16IpcMsg_GetTags(msg), AQH_MSGDATA_MULTIDATA_TAGS_VALUE);
}
void AQH_MultiDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
if (GWEN_Msg_GetBytesInBuffer(msg)>=AQH_MSGDATA_MULTIDATA_MINSIZE) {
GWEN_TAG16_LIST *tagList;
char *valueName=NULL;
char *valueUnits=NULL;
const GWEN_TAG16 *tag;
AQH_VALUE *value;
const char *valueName;
const char *valueUnits;
int valueType;
unsigned int numberOfPoints=0;
tagList=AQH_Tag16IpcMsg_ParseTags(msg, 0);
if (tagList) {
const GWEN_TAG16 *tag;
value=AQH_MultiDataDataIpcMsg_ReadValue(msg);
valueName=value?AQH_Value_GetNameForSystem(value):NULL;
valueUnits=value?AQH_Value_GetValueUnits(value):NULL;
valueType=value?AQH_Value_GetValueType(value):0;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_MULTIDATA_TAGS_NAME);
valueName=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_MULTIDATA_TAGS_UNITS);
valueUnits=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_MULTIDATA_TAGS_TYPE);
valueType=tag?GWEN_Tag16_GetTagDataAsUint32(tag, 0):0;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_MULTIDATA_TAGS_DATA);
numberOfPoints=(tag?GWEN_Tag16_GetTagLength(tag):0)/(2*sizeof(uint64_t));
}
tag=AQH_Tag16IpcMsg_FindFirstTagByType(msg, AQH_MSGDATA_MULTIDATA_TAGS_DATA);
numberOfPoints=(tag?GWEN_Tag16_GetTagLength(tag):0)/(2*sizeof(uint64_t));
GWEN_Buffer_AppendArgs(dbuf,
"MULTIDATA (code=%d, proto=%d, proto version=%d, name=%s, units=%s, type=%d, datapoints=%u)\n",
@@ -87,9 +124,7 @@ void AQH_MultiDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf
valueUnits?valueUnits:"<empty>",
valueType,
numberOfPoints);
free(valueUnits);
free(valueName);
GWEN_Tag16_List_free(tagList);
AQH_Value_free(value);
}
}

15
aqhome/ipc/data/msg_data_multidata.h
View File

@@ -17,16 +17,17 @@
#include <gwenhywfar/msg_ipc.h>
#define AQH_MSGDATA_MULTIDATA_TAGS_NAME 0x0001
#define AQH_MSGDATA_MULTIDATA_TAGS_UNITS 0x0002
#define AQH_MSGDATA_MULTIDATA_TAGS_TYPE 0x0003
#define AQH_MSGDATA_MULTIDATA_TAGS_DATA 0x0010
#define AQH_MSGDATA_MULTIDATA_TAGS_VALUE 0xc1
#define AQH_MSGDATA_MULTIDATA_TAGS_DATA 0xc2
AQHOME_API GWEN_MSG *AQH_MultiDataDataIpcMsg_new(uint16_t code,
const char *valueName, const char *valueUnits, int valueType,
const uint64_t *i64Ptr, int numOfDataPoints);
AQHOME_API GWEN_MSG *AQH_MultiDataDataIpcMsg_new(uint16_t code, const AQH_VALUE *value, const uint64_t *i64Ptr, int numOfDataPoints);
AQHOME_API GWEN_MSG *AQH_MultiDataDataIpcMsg_newForOne(uint16_t code, const AQH_VALUE *value, uint64_t timeStamp, double dataPoint);
AQHOME_API void AQH_MultiDataDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy);
AQHOME_API AQH_VALUE *AQH_MultiDataDataIpcMsg_ReadValue(const GWEN_MSG *msg);
AQHOME_API AQH_VALUE *AQH_ValuesDataIpcMsg_ReadFirstValue(const GWEN_MSG *msg);
AQHOME_API void AQH_MultiDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);

42
aqhome/ipc/data/msg_data_singledata.c
View File

@@ -31,6 +31,7 @@ GWEN_MSG *AQH_SingleDataDataIpcMsg_new(uint16_t code,
const char *valueName,
const char *valueUnits,
int valueType,
const char *deviceName,
uint64_t timestamp,
double datapoint)
{
@@ -45,6 +46,8 @@ GWEN_MSG *AQH_SingleDataDataIpcMsg_new(uint16_t code,
if (valueUnits && *valueUnits)
GWEN_Tag16_WriteStringTagToBuffer(AQH_MSGDATA_SINGLEDATA_TAGS_UNITS, valueUnits, buf);
GWEN_Tag16_WriteUint32TagToBuffer(AQH_MSGDATA_SINGLEDATA_TAGS_TYPE, valueType, buf);
if (deviceName && *deviceName)
GWEN_Tag16_WriteStringTagToBuffer(AQH_MSGDATA_SINGLEDATA_TAGS_DEV, deviceName, buf);
GWEN_Tag16_WriteUint64TagToBuffer(AQH_MSGDATA_SINGLEDATA_TAGS_TIME, timestamp, buf);
GWEN_Tag16_WriteUint64TagToBuffer(AQH_MSGDATA_SINGLEDATA_TAGS_DATA, u.i, buf);
@@ -56,50 +59,45 @@ GWEN_MSG *AQH_SingleDataDataIpcMsg_new(uint16_t code,
void AQH_SingleDataDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy)
{
AQH_Tag16IpcMsg_ExtendAndParse(msg, doCopy);
}
void AQH_SingleDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
if (GWEN_Msg_GetBytesInBuffer(msg)>=AQH_MSGDATA_SINGLEDATA_MINSIZE) {
GWEN_TAG16_LIST *tagList;
char *valueName=NULL;
char *valueUnits=NULL;
int valueType;
char *deviceName=NULL;
uint64_t timestamp;
union {double f; uint64_t i;} u;
tagList=AQH_Tag16IpcMsg_ParseTags(msg, 0);
if (tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_SINGLEDATA_TAGS_NAME);
valueName=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_SINGLEDATA_TAGS_UNITS);
valueUnits=tag?GWEN_Tag16_GetTagDataAsNewString(tag, NULL):NULL;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_SINGLEDATA_TAGS_TYPE);
valueType=tag?GWEN_Tag16_GetTagDataAsUint32(tag, 0):0;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_SINGLEDATA_TAGS_TIME);
timestamp=tag?GWEN_Tag16_GetTagDataAsUint64(tag, 0):0;
tag=GWEN_Tag16_List_FindFirstByTagType(tagList, AQH_MSGDATA_SINGLEDATA_TAGS_DATA);
u.i=tag?GWEN_Tag16_GetTagDataAsUint64(tag, 0):0;
}
valueName=AQH_Tag16IpcMsg_GetTagDataAsNewString(msg, AQH_MSGDATA_SINGLEDATA_TAGS_NAME, NULL);
valueUnits=AQH_Tag16IpcMsg_GetTagDataAsNewString(msg, AQH_MSGDATA_SINGLEDATA_TAGS_UNITS, NULL);
valueType=AQH_Tag16IpcMsg_GetTagDataAsUint32(msg, AQH_MSGDATA_SINGLEDATA_TAGS_TYPE, 0);
deviceName=AQH_Tag16IpcMsg_GetTagDataAsNewString(msg, AQH_MSGDATA_SINGLEDATA_TAGS_DEV, NULL);
timestamp=AQH_Tag16IpcMsg_GetTagDataAsUint64(msg, AQH_MSGDATA_SINGLEDATA_TAGS_TIME, 0);
u.i=AQH_Tag16IpcMsg_GetTagDataAsUint64(msg, AQH_MSGDATA_SINGLEDATA_TAGS_DATA, 0);
GWEN_Buffer_AppendArgs(dbuf,
"SINGLEDATA (code=%d, proto=%d, proto version=%d, name=%s, units=%s, type=%d, time=%lu, data=%f)\n",
"SINGLEDATA (code=%d, proto=%d, proto version=%d, name=%s, units=%s, type=%d, dev=%s, time=%lu, data=%f)\n",
GWEN_IpcMsg_GetCode(msg),
GWEN_IpcMsg_GetProtoId(msg),
GWEN_IpcMsg_GetProtoVersion(msg),
valueName?valueName:"<empty>",
valueUnits?valueUnits:"<empty>",
valueType,
deviceName?deviceName:"<empty>",
(unsigned long int) timestamp,
u.f);
free(deviceName);
free(valueUnits);
free(valueName);
GWEN_Tag16_List_free(tagList);
}
}

4
aqhome/ipc/data/msg_data_singledata.h
View File

@@ -24,6 +24,7 @@
#define AQH_MSGDATA_SINGLEDATA_TAGS_NAME 0x0001
#define AQH_MSGDATA_SINGLEDATA_TAGS_UNITS 0x0002
#define AQH_MSGDATA_SINGLEDATA_TAGS_TYPE 0x0003
#define AQH_MSGDATA_SINGLEDATA_TAGS_DEV 0x0004
#define AQH_MSGDATA_SINGLEDATA_TAGS_TIME 0x0010
#define AQH_MSGDATA_SINGLEDATA_TAGS_DATA 0x0011
@@ -33,9 +34,12 @@ AQHOME_API GWEN_MSG *AQH_SingleDataDataIpcMsg_new(uint16_t code,
const char *valueName,
const char *valueUnits,
int valueType,
const char *deviceName,
uint64_t timestamp,
double datapoint);
AQHOME_API void AQH_SingleDataDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy);
AQHOME_API void AQH_SingleDataDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);

16
aqhome/ipc/data/msg_data_value.c
View File

@@ -36,6 +36,7 @@ GWEN_MSG *AQH_ValueDataIpcMsg_new(uint16_t code,
GWEN_BUFFER *buf;
buf=GWEN_Buffer_new(0, 256, 0, 1);
if (valueName && *valueName)
GWEN_Tag16_WriteStringTagToBuffer(AQH_MSGDATA_VALUE_TAGS_NAME, valueName, buf);
if (valueUnits && *valueUnits)
@@ -50,6 +51,20 @@ GWEN_MSG *AQH_ValueDataIpcMsg_new(uint16_t code,
void AQH_ValueDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy)
{
AQH_Tag16IpcMsg_ExtendAndParse(msg, doCopy);
}
AQH_VALUE *AQH_ValueDataIpcMsg_ReadValue(const GWEN_MSG *msg)
{
//return AQH_DataIpc_ReadValueFromTagList(AQH_Tag16IpcMsg_GetTags(msg), AQH_MSGDATA_VALUES_TAGS_VALUE);
}
void AQH_ValueDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
@@ -59,6 +74,7 @@ void AQH_ValueDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, co
char *valueUnits=NULL;
int valueType;
tagList=AQH_Tag16IpcMsg_ParseTags(msg, 0);
if (tagList) {
const GWEN_TAG16 *tag;

6
aqhome/ipc/data/msg_data_value.h
View File

@@ -27,11 +27,15 @@
AQHOME_API GWEN_MSG *AQH_ValueDataIpcMsg_new(uint16_t code,
AQHOME_API GWEN_DEPRECATED GWEN_MSG *AQH_ValueDataIpcMsg_new(uint16_t code,
const char *valueName,
const char *valueUnits,
int valueType);
AQHOME_API void AQH_ValueDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy);
AQHOME_API AQH_VALUE *AQH_ValueDataIpcMsg_ReadValue(const GWEN_MSG *msg);
AQHOME_API void AQH_ValueDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);

274
aqhome/ipc/data/msg_data_values.c
View File

@@ -12,6 +12,7 @@
#include <aqhome/ipc/data/msg_data_values.h>
#include <aqhome/ipc/data/ipc_data.h>
#include <aqhome/ipc/msg_ipc_tag16.h>
#include <gwenhywfar/msg.h>
#include <gwenhywfar/buffer.h>
@@ -19,230 +20,113 @@
#include <gwenhywfar/debug.h>
#include <gwenhywfar/msg_ipc.h>
#include <gwenhywfar/text.h>
#include <gwenhywfar/tag16.h>
#include <string.h>
#define AQH_MSGDATA_VALUES_OFFS_FLAGS 0 /* 4 bytes */
#define AQH_MSGDATA_VALUES_OFFS_NUMVALUES 4 /* 4 bytes */
#define AQH_MSGDATA_VALUES_OFFS_VALUES 8 /* 8 byte */
#define AQH_MSGDATA_VALUES_VALUES_OFFS_ID 0 /* 8 byte */
#define AQH_MSGDATA_VALUES_VALUES_OFFS_NAME 8 /* 104 byte */
# define AQH_MSGDATA_VALUES_VALUES_SIZE_NAME 104 /* 104 byte */
#define AQH_MSGDATA_VALUES_VALUES_OFFS_UNITS 112 /* 16 bytes */
# define AQH_MSGDATA_VALUES_VALUES_SIZE_UNITS 16
#define AQH_MSGDATA_VALUES_VALUES_SIZE 128
#define AQH_MSGDATA_VALUES_MINSIZE (GWEN_MSGIPC_OFFS_PAYLOAD+AQH_MSGDATA_VALUES_OFFS_VALUES)
#define AQH_MSGDATA_VALUES_MINSIZE GWEN_MSGIPC_OFFS_PAYLOAD
static void _writeValue(const AQH_VALUE *value, uint8_t *ptr, int useSystemName);
/* ------------------------------------------------------------------------------------------------
* forward declarations
* ------------------------------------------------------------------------------------------------
*/
/* ------------------------------------------------------------------------------------------------
* code
* ------------------------------------------------------------------------------------------------
*/
GWEN_MSG *AQH_ValuesDataIpcMsg_new(uint16_t code, uint32_t flags, const AQH_VALUE_LIST *valueList, int useSystemName)
GWEN_MSG *AQH_ValuesDataIpcMsg_new(uint16_t code, uint32_t flags, const AQH_VALUE_LIST *valueList)
{
GWEN_MSG *msg;
uint8_t *ptr;
int count;
int payloadSize;
GWEN_BUFFER *buf;
int rv;
count=valueList?AQH_Value_List_GetCount(valueList):0;
payloadSize=AQH_MSGDATA_VALUES_OFFS_VALUES+(count*AQH_MSGDATA_VALUES_VALUES_SIZE);
buf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Tag16_WriteUint32TagToBuffer(AQH_MSGDATA_VALUES_TAGS_FLAGS, flags, buf);
rv=AQH_DataIpc_WriteValueListAsTagsToBuffer(AQH_MSGDATA_VALUES_TAGS_VALUE, valueList, buf);
if (rv<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return NULL;
}
msg=GWEN_IpcMsg_new(AQH_IPC_PROTOCOL_DATA_ID, AQH_IPC_PROTOCOL_DATA_VERSION, code, payloadSize, NULL);
ptr=GWEN_Msg_GetBuffer(msg)+GWEN_MSGIPC_OFFS_PAYLOAD;
*(ptr++)=flags & 0xff;
*(ptr++)=(flags>>8) & 0xff;
*(ptr++)=(flags>>16) & 0xff;
*(ptr++)=(flags>>24) & 0xff;
msg=AQH_Tag16IpcMsg_new(AQH_IPC_PROTOCOL_DATA_ID, AQH_IPC_PROTOCOL_DATA_VERSION, code,
GWEN_Buffer_GetUsedBytes(buf), (const uint8_t*) GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return msg;
}
*(ptr++)=count & 0xff;
*(ptr++)=(count>>8) & 0xff;
*(ptr++)=(count>>16) & 0xff;
*(ptr++)=(count>>24) & 0xff;
if (count>0) {
const AQH_VALUE *value;
value=AQH_Value_List_First(valueList);
while(value) {
_writeValue(value, ptr, useSystemName);
ptr+=AQH_MSGDATA_VALUES_VALUES_SIZE;
value=AQH_Value_List_Next(value);
GWEN_MSG *AQH_ValuesDataIpcMsg_newForOneValue(uint16_t code, uint32_t flags, const AQH_VALUE *value)
{
GWEN_MSG *msg;
GWEN_BUFFER *buf;
int rv;
buf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Tag16_WriteUint32TagToBuffer(AQH_MSGDATA_VALUES_TAGS_FLAGS, flags, buf);
rv=AQH_DataIpc_WriteValueAsTagToBuffer(AQH_MSGDATA_VALUES_TAGS_VALUE, value, buf);
if (rv<0) {
DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return NULL;
}
msg=AQH_Tag16IpcMsg_new(AQH_IPC_PROTOCOL_DATA_ID, AQH_IPC_PROTOCOL_DATA_VERSION, code,
GWEN_Buffer_GetUsedBytes(buf), (const uint8_t*) GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return msg;
}
void AQH_ValuesDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy)
{
AQH_Tag16IpcMsg_ExtendAndParse(msg, doCopy);
}
AQH_VALUE_LIST *AQH_ValuesDataIpcMsg_ReadValueList(const GWEN_MSG *msg)
{
const GWEN_TAG16_LIST *tagList;
tagList=AQH_Tag16IpcMsg_GetTags(msg);
if (tagList) {
AQH_VALUE_LIST *valueList;
valueList=AQH_DataIpc_ReadValuesFromTagList(tagList, AQH_MSGDATA_VALUES_TAGS_VALUE);
if (valueList==NULL) {
DBG_INFO(AQH_LOGDOMAIN, "No value list received");
}
return valueList;
}
else {
DBG_INFO(AQH_LOGDOMAIN, "No tag16 list received");
return NULL;
}
return msg;
}
GWEN_MSG *AQH_ValuesDataIpcMsg_newForOneValue(uint16_t code, uint32_t flags, const AQH_VALUE *value, int useSystemName)
AQH_VALUE *AQH_ValuesDataIpcMsg_ReadFirstValue(const GWEN_MSG *msg)
{
GWEN_MSG *msg;
uint8_t *ptr;
int count;
int payloadSize;
count=1;
payloadSize=AQH_MSGDATA_VALUES_OFFS_VALUES+AQH_MSGDATA_VALUES_VALUES_SIZE;
msg=GWEN_IpcMsg_new(AQH_IPC_PROTOCOL_DATA_ID, AQH_IPC_PROTOCOL_DATA_VERSION, code, payloadSize, NULL);
ptr=GWEN_Msg_GetBuffer(msg)+GWEN_MSGIPC_OFFS_PAYLOAD;
*(ptr++)=flags & 0xff;
*(ptr++)=(flags>>8) & 0xff;
*(ptr++)=(flags>>16) & 0xff;
*(ptr++)=(flags>>24) & 0xff;
*(ptr++)=count & 0xff;
*(ptr++)=(count>>8) & 0xff;
*(ptr++)=(count>>16) & 0xff;
*(ptr++)=(count>>24) & 0xff;
_writeValue(value, ptr, useSystemName);
return msg;
return AQH_DataIpc_ReadValueFromTagList(AQH_Tag16IpcMsg_GetTags(msg), AQH_MSGDATA_VALUES_TAGS_VALUE);
}
void _writeValue(const AQH_VALUE *value, uint8_t *ptr, int useSystemName)
{
uint64_t i64;
const char *name;
const char *units;
i64=AQH_Value_GetId(value);
name=useSystemName?AQH_Value_GetNameForSystem(value):AQH_Value_GetNameForDriver(value);
units=AQH_Value_GetValueUnits(value);
*(ptr++)=i64 & 0xff;
*(ptr++)=(i64>>8) & 0xff;
*(ptr++)=(i64>>16) & 0xff;
*(ptr++)=(i64>>24) & 0xff;
*(ptr++)=(i64>>32) & 0xff;
*(ptr++)=(i64>>40) & 0xff;
*(ptr++)=(i64>>48) & 0xff;
*(ptr++)=(i64>>56) & 0xff;
if (name) {
strncpy((char*) ptr, name, AQH_MSGDATA_VALUES_VALUES_SIZE_NAME-1);
ptr[AQH_MSGDATA_VALUES_VALUES_SIZE_NAME-1]=0;
}
else
memset(ptr, 0, AQH_MSGDATA_VALUES_VALUES_SIZE_NAME);
ptr+=AQH_MSGDATA_VALUES_VALUES_SIZE_NAME;
if (units) {
strncpy((char*) ptr, units, AQH_MSGDATA_VALUES_VALUES_SIZE_UNITS-1);
ptr[AQH_MSGDATA_VALUES_VALUES_SIZE_UNITS-1]=0;
}
else
memset(ptr, 0, AQH_MSGDATA_VALUES_VALUES_SIZE_UNITS);
ptr+=AQH_MSGDATA_VALUES_VALUES_SIZE_UNITS;
}
uint32_t AQH_ValuesDataIpcMsg_GetFlags(const GWEN_MSG *msg)
{
return GWEN_Msg_GetUint32At(msg, GWEN_MSGIPC_OFFS_PAYLOAD+AQH_MSGDATA_VALUES_OFFS_FLAGS, 0);
}
uint32_t AQH_ValuesDataIpcMsg_GetNumValues(const GWEN_MSG *msg)
{
return GWEN_Msg_GetUint32At(msg, GWEN_MSGIPC_OFFS_PAYLOAD+AQH_MSGDATA_VALUES_OFFS_NUMVALUES, 0);
}
uint64_t AQH_ValuesDataIpcMsg_GetValueId(const GWEN_MSG *msg, int idx)
{
uint32_t pos;
pos=
AQH_MSGDATA_VALUES_OFFS_VALUES+
(idx*AQH_MSGDATA_VALUES_VALUES_SIZE)+
AQH_MSGDATA_VALUES_VALUES_OFFS_ID;
return GWEN_Msg_GetUint64At(msg, GWEN_MSGIPC_OFFS_PAYLOAD+pos, 0);
}
const char *AQH_ValuesDataIpcMsg_GetValueName(const GWEN_MSG *msg, int idx)
{
uint32_t pos;
pos=
AQH_MSGDATA_VALUES_OFFS_VALUES+
(idx*AQH_MSGDATA_VALUES_VALUES_SIZE)+
AQH_MSGDATA_VALUES_VALUES_OFFS_NAME;
if (GWEN_Msg_GetBytesInBuffer(msg)>=pos+GWEN_MSGIPC_OFFS_PAYLOAD)
return (const char*) (GWEN_Msg_GetConstBuffer(msg)+GWEN_MSGIPC_OFFS_PAYLOAD+pos);
return NULL;
}
const char *AQH_ValuesDataIpcMsg_GetValueUnits(const GWEN_MSG *msg, int idx)
{
uint32_t pos;
pos=
AQH_MSGDATA_VALUES_OFFS_VALUES+
(idx*AQH_MSGDATA_VALUES_VALUES_SIZE)+
AQH_MSGDATA_VALUES_VALUES_OFFS_UNITS;
if (GWEN_Msg_GetBytesInBuffer(msg)>=pos+GWEN_MSGIPC_OFFS_PAYLOAD)
return (const char*) (GWEN_Msg_GetConstBuffer(msg)+GWEN_MSGIPC_OFFS_PAYLOAD+pos);
return NULL;
}
int AQH_ValuesDataIpcMsg_IsValid(const GWEN_MSG *msg)
{
int msgLen;
int numValues;
const uint8_t *ptr;
int i;
msgLen=GWEN_Msg_GetBytesInBuffer(msg);
if (msgLen<AQH_MSGDATA_VALUES_MINSIZE) {
DBG_ERROR(AQH_LOGDOMAIN, "Message too small (%d<%d)", GWEN_Msg_GetBytesInBuffer(msg), AQH_MSGDATA_VALUES_MINSIZE);
return 0;
}
numValues=(int)AQH_ValuesDataIpcMsg_GetNumValues(msg);
if (msgLen<(numValues*AQH_MSGDATA_VALUES_VALUES_SIZE)+AQH_MSGDATA_VALUES_OFFS_VALUES+GWEN_MSGIPC_OFFS_PAYLOAD) {
DBG_ERROR(AQH_LOGDOMAIN, "Message too small to contain %d values", numValues);
return 0;
}
ptr=GWEN_Msg_GetConstBuffer(msg)+GWEN_MSGIPC_OFFS_PAYLOAD+AQH_MSGDATA_VALUES_OFFS_VALUES;
for (i=0; i<numValues; i++) {
if (ptr[AQH_MSGDATA_VALUES_VALUES_OFFS_NAME+AQH_MSGDATA_VALUES_VALUES_SIZE_NAME-1]!=0) {
DBG_ERROR(AQH_LOGDOMAIN, "Name string for value %d is not null-terminated", i);
return 0;
}
if (ptr[AQH_MSGDATA_VALUES_VALUES_OFFS_UNITS+AQH_MSGDATA_VALUES_VALUES_SIZE_UNITS-1]!=0) {
DBG_ERROR(AQH_LOGDOMAIN, "Units string for value %d is not null-terminated", i);
return 0;
}
ptr+=AQH_MSGDATA_VALUES_VALUES_SIZE;
}
return 1;
return AQH_Tag16IpcMsg_GetTagDataAsUint32(msg, AQH_MSGDATA_VALUES_TAGS_FLAGS, 0);
}
@@ -251,12 +135,11 @@ void AQH_ValuesDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, c
{
if (GWEN_Msg_GetBytesInBuffer(msg)>=AQH_MSGDATA_VALUES_MINSIZE) {
GWEN_Buffer_AppendArgs(dbuf,
"VALUES (code=%d, proto=%d, proto version=%d, flags=0x%08x, values=%d)\n",
"VALUES (code=%d, proto=%d, proto version=%d, flags=0x%08x)\n",
GWEN_IpcMsg_GetCode(msg),
GWEN_IpcMsg_GetProtoId(msg),
GWEN_IpcMsg_GetProtoVersion(msg),
(unsigned int)AQH_ValuesDataIpcMsg_GetFlags(msg),
AQH_ValuesDataIpcMsg_GetNumValues(msg));
(unsigned int)AQH_ValuesDataIpcMsg_GetFlags(msg));
}
}
@@ -265,4 +148,3 @@ void AQH_ValuesDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, c

18
aqhome/ipc/data/msg_data_values.h
View File

@@ -23,19 +23,21 @@
#define AQH_MSGDATA_VALUES_FLAGS_LASTMSG 0x0001
#define AQH_MSGDATA_VALUES_TAGS_FLAGS 0x01
#define AQH_MSGDATA_VALUES_TAGS_VALUE 0xc2
AQHOME_API GWEN_MSG *AQH_ValuesDataIpcMsg_new(uint16_t code, uint32_t flags, const AQH_VALUE_LIST *valueList, int useSystemName);
AQHOME_API GWEN_MSG *AQH_ValuesDataIpcMsg_newForOneValue(uint16_t code, uint32_t flags, const AQH_VALUE *value, int useSystemName);
AQHOME_API GWEN_MSG *AQH_ValuesDataIpcMsg_new(uint16_t code, uint32_t flags, const AQH_VALUE_LIST *valueList);
AQHOME_API GWEN_MSG *AQH_ValuesDataIpcMsg_newForOneValue(uint16_t code, uint32_t flags, const AQH_VALUE *value);
AQHOME_API void AQH_ValuesDataIpcMsg_Parse(GWEN_MSG *msg, int doCopy);
AQHOME_API AQH_VALUE_LIST *AQH_ValuesDataIpcMsg_ReadValueList(const GWEN_MSG *msg);
AQHOME_API AQH_VALUE *AQH_ValuesDataIpcMsg_ReadFirstValue(const GWEN_MSG *msg);
AQHOME_API uint32_t AQH_ValuesDataIpcMsg_GetFlags(const GWEN_MSG *msg);
AQHOME_API uint32_t AQH_ValuesDataIpcMsg_GetNumValues(const GWEN_MSG *msg);
AQHOME_API uint64_t AQH_ValuesDataIpcMsg_GetValueId(const GWEN_MSG *msg, int idx);
AQHOME_API const char *AQH_ValuesDataIpcMsg_GetValueName(const GWEN_MSG *msg, int idx);
AQHOME_API const char *AQH_ValuesDataIpcMsg_GetValueUnits(const GWEN_MSG *msg, int idx);
AQHOME_API int AQH_ValuesDataIpcMsg_IsValid(const GWEN_MSG *msg);
AQHOME_API void AQH_ValuesDataIpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);

182
aqhome/ipc/msg_ipc_tag16.c
View File

@@ -11,21 +11,199 @@
#endif
#include <aqhome/ipc/msg_ipc_tag16.h>
#include "msg_ipc_tag16_p.h"
#include <gwenhywfar/msg_ipc.h>
#include <gwenhywfar/debug.h>
/* ------------------------------------------------------------------------------------------------
* forward declarations
* ------------------------------------------------------------------------------------------------
*/
static void GWENHYWFAR_CB _freeData(void *bp, void *p);
static GWEN_TAG16_LIST *_parseTags(const GWEN_MSG *msg, int doCopy);
/* ------------------------------------------------------------------------------------------------
* implementations
* ------------------------------------------------------------------------------------------------
*/
GWEN_INHERIT(GWEN_MSG, AQH_MSG_IPC_TAG16);
GWEN_MSG *AQH_Tag16IpcMsg_new(uint8_t protoId, uint8_t protoVer, uint16_t code, uint32_t payloadLen, const uint8_t *payload)
{
return GWEN_IpcMsg_new(protoId, protoVer, code, payloadLen, payload);
GWEN_MSG *msg;
msg=GWEN_IpcMsg_new(protoId, protoVer, code, payloadLen, payload);
AQH_Tag16IpcMsg_Extend(msg);
return msg;
}
void AQH_Tag16IpcMsg_Extend(GWEN_MSG *msg)
{
AQH_MSG_IPC_TAG16 *xmsg;
GWEN_NEW_OBJECT(AQH_MSG_IPC_TAG16, xmsg);
GWEN_INHERIT_SETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg, xmsg, _freeData);
}
void _freeData(void *bp, void *p)
{
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=(AQH_MSG_IPC_TAG16*) p;
GWEN_Tag16_List_free(xmsg->tagList);
}
GWEN_TAG16_LIST *AQH_Tag16IpcMsg_GetTags(const GWEN_MSG *msg)
{
if (msg) {
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=GWEN_INHERIT_GETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg);
if (xmsg) {
return xmsg->tagList;
}
else {
DBG_INFO(AQH_LOGDOMAIN, "Not a Tag16IpcMsg message");
return NULL;
}
}
else {
DBG_INFO(AQH_LOGDOMAIN, "NULLPOINTER");
return NULL;
}
}
void AQH_Tag16IpcMsg_ReadTags(GWEN_MSG *msg, int doCopy)
{
if (msg) {
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=GWEN_INHERIT_GETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg);
if (xmsg) {
if (xmsg->tagList) {
DBG_INFO(AQH_LOGDOMAIN, "Tags already parsed");
}
else {
xmsg->tagList=_parseTags(msg, doCopy);
if (xmsg->tagList==NULL) {
DBG_INFO(AQH_LOGDOMAIN, "No tags received");
}
}
}
else {
DBG_INFO(AQH_LOGDOMAIN, "Not a Tag16IpcMsg message");
}
}
else {
DBG_INFO(AQH_LOGDOMAIN, "NULLPOINTER");
}
}
void AQH_Tag16IpcMsg_ExtendAndParse(GWEN_MSG *msg, int doCopy)
{
if (!(GWEN_INHERIT_ISOFTYPE(GWEN_MSG, AQH_MSG_IPC_TAG16, msg)))
AQH_Tag16IpcMsg_Extend(msg);
AQH_Tag16IpcMsg_ReadTags(msg, doCopy);
}
char *AQH_Tag16IpcMsg_GetTagDataAsNewString(const GWEN_MSG *msg, unsigned int tagType, const char *defaultValue)
{
if (msg) {
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=GWEN_INHERIT_GETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg);
if (xmsg && xmsg->tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(xmsg->tagList, tagType);
if (tag)
return GWEN_Tag16_GetTagDataAsNewString(tag, defaultValue);
}
}
return defaultValue?strdup(defaultValue):NULL;
}
uint32_t AQH_Tag16IpcMsg_GetTagDataAsUint32(const GWEN_MSG *msg, unsigned int tagType, uint32_t defaultValue)
{
if (msg) {
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=GWEN_INHERIT_GETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg);
if (xmsg && xmsg->tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(xmsg->tagList, tagType);
return tag?GWEN_Tag16_GetTagDataAsUint32(tag, defaultValue):defaultValue;
}
}
return defaultValue;
}
uint64_t AQH_Tag16IpcMsg_GetTagDataAsUint64(const GWEN_MSG *msg, unsigned int tagType, uint64_t defaultValue)
{
if (msg) {
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=GWEN_INHERIT_GETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg);
if (xmsg && xmsg->tagList) {
const GWEN_TAG16 *tag;
tag=GWEN_Tag16_List_FindFirstByTagType(xmsg->tagList, tagType);
return tag?GWEN_Tag16_GetTagDataAsUint64(tag, defaultValue):defaultValue;
}
}
return defaultValue;
}
const GWEN_TAG16 *AQH_Tag16IpcMsg_FindFirstTagByType(const GWEN_MSG *msg, unsigned int tagType)
{
if (msg) {
AQH_MSG_IPC_TAG16 *xmsg;
xmsg=GWEN_INHERIT_GETDATA(GWEN_MSG, AQH_MSG_IPC_TAG16, msg);
if (xmsg && xmsg->tagList)
return GWEN_Tag16_List_FindFirstByTagType(xmsg->tagList, tagType);
}
return NULL;
}
GWEN_TAG16_LIST *AQH_Tag16IpcMsg_ParseTags(const GWEN_MSG *msg, int doCopy)
{
return _parseTags(msg, doCopy);
}
GWEN_TAG16_LIST *_parseTags(const GWEN_MSG *msg, int doCopy)
{
uint32_t msgSize;

17
aqhome/ipc/msg_ipc_tag16.h
View File

@@ -18,9 +18,24 @@
AQHOME_API GWEN_MSG *AQH_Tag16IpcMsg_new(uint8_t protoId, uint8_t protoVer, uint16_t code, uint32_t payloadLen, const uint8_t *payload);
AQHOME_API GWEN_TAG16_LIST *AQH_Tag16IpcMsg_ParseTags(const GWEN_MSG *msg, int doCopy);
AQHOME_API void AQH_Tag16IpcMsg_ExtendAndParse(GWEN_MSG *msg, int doCopy);
AQHOME_API void AQH_Tag16IpcMsg_Extend(GWEN_MSG *msg);
AQHOME_API void AQH_Tag16IpcMsg_ReadTags(GWEN_MSG *msg, int doCopy);
AQHOME_API GWEN_TAG16_LIST *AQH_Tag16IpcMsg_GetTags(const GWEN_MSG *msg);
AQHOME_API GWEN_DEPRECATED GWEN_TAG16_LIST *AQH_Tag16IpcMsg_ParseTags(const GWEN_MSG *msg, int doCopy);
AQHOME_API void AQH_Tag16IpcMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);
AQHOME_API const GWEN_TAG16 *AQH_Tag16IpcMsg_FindFirstTagByType(const GWEN_MSG *msg, unsigned int tagType);
AQHOME_API char *AQH_Tag16IpcMsg_GetTagDataAsNewString(const GWEN_MSG *msg, unsigned int tagType, const char *defaultValue);
AQHOME_API uint32_t AQH_Tag16IpcMsg_GetTagDataAsUint32(const GWEN_MSG *msg, unsigned int tagType, uint32_t defaultValue);
AQHOME_API uint64_t AQH_Tag16IpcMsg_GetTagDataAsUint64(const GWEN_MSG *msg, unsigned int tagType, uint64_t defaultValue);
#endif

25
aqhome/ipc/msg_ipc_tag16_p.h Normal file
View File

@@ -0,0 +1,25 @@
/****************************************************************************
* This file is part of the project AqHome.
* AqHome (c) by 2023 Martin Preuss, all rights reserved.
*
* The license for this file can be found in the file COPYING which you
* should have received along with this file.
****************************************************************************/
#ifndef AQH_MSG_IPC_TAG16_P_H
#define AQH_MSG_IPC_TAG16_P_H
#include <aqhome/ipc/msg_ipc_tag16.h>
typedef struct AQH_MSG_IPC_TAG16 AQH_MSG_IPC_TAG16;
struct AQH_MSG_IPC_TAG16 {
GWEN_TAG16_LIST *tagList;
};
#endif

52
aqhome/libtest.c
View File

@@ -26,6 +26,7 @@
#include <gwenhywfar/buffer.h>
#include <gwenhywfar/endpoint_tcpd.h>
#include <gwenhywfar/endpoint_msgio.h>
#include <gwenhywfar/endpoint_multilayer.h>
#include <unistd.h>
#include <time.h>
@@ -113,7 +114,6 @@ int testMqttConnection2()
AQH_Init();
epClient=AQH_MqttClientEndpoint_new("TESTCLIENT1234", "127.0.0.1", 1883, NULL, 1);
for (loop=0;; loop++) {
DBG_INFO(GWEN_LOGDOMAIN, "Loop %d:", loop);
GWEN_MsgEndpoint_IoLoop(epClient, 2000); /* 2000 ms */
@@ -199,6 +199,55 @@ int testMqttSubscribe2(int argc, char **argv)
int testMqttSubscribe3(int argc, char **argv)
{
GWEN_MSG_ENDPOINT *epClient;
int rv;
//const char *host="127.0.0.1";
const char *host="192.168.117.192";
AQH_Init();
if (argc>1)
host=argv[1];
DBG_ERROR(AQH_LOGDOMAIN, "Connecting to %s (%s)", host, argv[1]);
epClient=AQH_MqttClientEndpoint_new("TESTCLIENT1234", host, 1883, NULL, 1);
GWEN_MsgEndpoint_AddFlags(epClient, AQH_ENDPOINT2_MQTTCLIENT_FLAGS_SUBSCRIBEALL);
rv=GWEN_MultilayerEndpoint_StartConnect(epClient);
if (rv<0 && rv!=GWEN_ERROR_IN_PROGRESS) {
DBG_ERROR(NULL, "Error on startConnect: %d", rv);
return 2;
}
for (;;) {
GWEN_MSG *msg;
GWEN_MsgEndpoint_IoLoop(epClient, 2000); /* 2000 ms */
msg=GWEN_MsgEndpoint_TakeFirstReceivedMessage(epClient);
if (msg) {
if ((AQH_MqttMsg_GetMsgTypeAndFlags(msg) & 0xf0)==(AQH_MQTTMSG_MSGTYPE_PUBLISH & 0xf0)) {
GWEN_BUFFER *buf;
buf=GWEN_Buffer_new(0, 256, 0, 1);
AQH_PublishMqttMsg_DumpToBuffer(msg, buf, "received");
fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
}
else {
DBG_ERROR(NULL, "Received this message:");
GWEN_Text_DumpString((const char*) GWEN_Msg_GetConstBuffer(msg), GWEN_Msg_GetBytesInBuffer(msg), 2);
}
GWEN_Msg_free(msg);
}
}
return 0;
}
int _mqttConnect2(GWEN_MSG_ENDPOINT *epClient)
{
int loop;
@@ -423,6 +472,7 @@ int main(int argc, char **argv)
//return testMqttConnection2();
//return testMqttSubscribe2(argc, argv);
//return testHttpDaemon();
return testMqttSubscribe3(argc, argv);
return 0;
}

347
aqhome/mqtt/endpoint_mqttc.c
View File

@@ -16,9 +16,12 @@
#include "aqhome/mqtt/msg_mqtt_connect.h"
#include "aqhome/mqtt/msg_mqtt_connack.h"
#include "aqhome/mqtt/msg_mqtt_publish.h"
#include "aqhome/mqtt/msg_mqtt_subscribe.h"
#include "aqhome/mqtt/msg_mqtt_suback.h"
#include <gwenhywfar/endpoint_tcpc.h>
#include <gwenhywfar/endpoint_msgio.h>
#include <gwenhywfar/endpoint_multilayer.h>
#include <gwenhywfar/debug.h>
#include <gwenhywfar/inherit.h>
@@ -27,6 +30,12 @@
#define AQH_ENDPOINT2_MQTTC_RECONNECT_TIME 5
#define AQH_ENDPOINT2_MQTTC_CONNECT_TIMEOUT 10
#define AQH_ENDPOINT2_MQTTC_STAGE_NONE 0
#define AQH_ENDPOINT2_MQTTC_STAGE_CONNREQ 1
#define AQH_ENDPOINT2_MQTTC_STAGE_SUBREQ 2
#define AQH_ENDPOINT2_MQTTC_STAGE_UP 10
/* ------------------------------------------------------------------------------------------------
@@ -34,22 +43,15 @@
* ------------------------------------------------------------------------------------------------
*/
static void _addSockets(GWEN_MSG_ENDPOINT *ep, GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_UNUSED GWEN_SOCKETSET *xSet);
static void _checkSockets(GWEN_MSG_ENDPOINT *ep, GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet);
static int _startConnect(GWEN_MSG_ENDPOINT *ep);
static void _moveMessagesBetweenLists(GWEN_MSG_LIST *srcList, GWEN_MSG_LIST *dstList);
static void _addSocketsWhenUnconnected(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet);
static void _addSocketsWhenConnecting(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet);
static void _addSocketsWhenConnected(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet);
static void _checkSocketsWhenConnecting(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet);
static void _checkSocketsWhenConnected(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet);
static int _startConnect(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild);
static void _checkSockets(GWEN_MSG_ENDPOINT *ep,
GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet,
GWEN_SOCKETSET *writeSet,
GWEN_SOCKETSET *xSet);
static void _lookForAndHandleConnAck(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild);
static void _lookForAndHandleSubAck(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild);
static int _sendSubscribeMsg(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild, const char *topicFilter);
@@ -67,9 +69,11 @@ GWEN_MSG_ENDPOINT *AQH_MqttClientEndpoint_new(const char *clientId,
GWEN_MSG_ENDPOINT *ep;
GWEN_MSG_ENDPOINT *epChild;
ep=GWEN_MsgEndpoint_new(name?name:AQH_ENDPOINT2_MQTT_NAME, groupId);
GWEN_MsgEndpoint_SetAddSocketsFn(ep, _addSockets);
GWEN_MsgEndpoint_SetCheckSocketsFn(ep, _checkSockets);
ep=GWEN_MultilayerEndpoint_new(name?name:AQH_ENDPOINT2_MQTT_NAME, groupId);
GWEN_MultilayerEndpoint_SetConnectTimeoutInSeconds(ep, AQH_ENDPOINT2_MQTTC_CONNECT_TIMEOUT);
GWEN_MultilayerEndpoint_SetReconnectTimeInSeconds(ep, AQH_ENDPOINT2_MQTTC_RECONNECT_TIME);
GWEN_MultilayerEndpoint_SetStartConnectFn(ep, _startConnect);
GWEN_MultilayerEndpoint_SetCheckSocketsFn(ep, _checkSockets);
epChild=GWEN_TcpcEndpoint_new(host, port, NULL, groupId);
GWEN_MsgIoEndpoint_Extend(epChild);
@@ -82,36 +86,6 @@ GWEN_MSG_ENDPOINT *AQH_MqttClientEndpoint_new(const char *clientId,
int AQH_MqttClientEndpoint_StartConnect(GWEN_MSG_ENDPOINT *ep)
{
if (ep) {
if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED) {
int rv;
/* connect, set state */
rv=_startConnect(ep);
if (rv<0 && rv!=GWEN_ERROR_IN_PROGRESS) {
DBG_INFO(AQH_LOGDOMAIN, "Endpoint %s: Error connecting (%d)", GWEN_MsgEndpoint_GetName(ep), rv);
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTING);
}
else {
DBG_INFO(AQH_LOGDOMAIN, "Endpoint %s: Connecting.", GWEN_MsgEndpoint_GetName(ep));
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTING);
}
return rv;
}
else {
DBG_ERROR(AQH_LOGDOMAIN, "Endpoint %s: Not unconnected", GWEN_MsgEndpoint_GetName(ep));
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "No endpoint");
}
return GWEN_ERROR_GENERIC;
}
uint16_t AQH_MqttClientEndpoint_GetKeepAliveTime(const GWEN_MSG_ENDPOINT *ep)
{
if (ep) {
@@ -155,152 +129,52 @@ uint16_t AQH_MqttClientEndpoint_GetNextPacketId(const GWEN_MSG_ENDPOINT *ep)
void _moveMessagesBetweenLists(GWEN_MSG_LIST *srcList, GWEN_MSG_LIST *dstList)
void _checkSockets(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
GWEN_MSG *msg;
while( (msg=GWEN_Msg_List_First(srcList)) ) {
GWEN_Msg_List_Del(msg);
GWEN_Msg_List_Add(msg, dstList);
}
}
void _addSockets(GWEN_MSG_ENDPOINT *ep, GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
if (ep) {
GWEN_MSG_ENDPOINT *epChild;
epChild=GWEN_MsgEndpoint_Tree2_GetFirstChild(ep);
if (epChild) {
if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED)
_addSocketsWhenUnconnected(ep, epChild, readSet, writeSet, xSet);
else {
if (GWEN_MsgEndpoint_GetState(epChild)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED) {
DBG_ERROR(AQH_LOGDOMAIN, "Error on tcp layer, disconnecting");
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
else {
if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_CONNECTING)
_addSocketsWhenConnecting(ep, epChild, readSet, writeSet, xSet);
if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_CONNECTED)
_addSocketsWhenConnected(ep, epChild, readSet, writeSet, xSet);
}
}
} /* if (epChild) */
} /* if (ep) */
}
void _checkSockets(GWEN_MSG_ENDPOINT *ep, GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
DBG_DEBUG(AQH_LOGDOMAIN, "Checking sockets in state %d", GWEN_MsgEndpoint_GetState(ep));
if (ep) {
GWEN_MSG_ENDPOINT *epChild;
epChild=GWEN_MsgEndpoint_Tree2_GetFirstChild(ep);
if (epChild) {
if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED) {
/* nothing to do here */
} /* if GWEN_MSG_ENDPOINT_STATE_UNCONNECTED */
else {
if (GWEN_MsgEndpoint_GetState(epChild)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED) {
DBG_ERROR(AQH_LOGDOMAIN, "Error on tcp layer, disconnecting");
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
else {
if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_CONNECTING)
_checkSocketsWhenConnecting(ep, epChild, readSet, writeSet, xSet);
else if (GWEN_MsgEndpoint_GetState(ep)==GWEN_MSG_ENDPOINT_STATE_CONNECTED)
_checkSocketsWhenConnected(ep, epChild, readSet, writeSet, xSet);
}
}
}
}
}
void _addSocketsWhenUnconnected(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
time_t now;
now=time(NULL);
if ((now-GWEN_MsgEndpoint_GetTimeOfLastStateChange(ep))>=AQH_ENDPOINT2_MQTTC_RECONNECT_TIME) {
int rv;
/* (re)connect, set state */
DBG_INFO(AQH_LOGDOMAIN, "Starting to (re-)connect");
rv=AQH_MqttClientEndpoint_StartConnect(ep);
if (rv<0 && rv!=GWEN_ERROR_IN_PROGRESS) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
}
}
}
void _addSocketsWhenConnecting(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
time_t now;
now=time(NULL);
if ((now-GWEN_MsgEndpoint_GetTimeOfLastStateChange(ep))>=AQH_ENDPOINT2_MQTTC_CONNECT_TIMEOUT ||
GWEN_MsgEndpoint_GetState(epChild)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED) {
DBG_ERROR(AQH_LOGDOMAIN, "Timeout on connect");
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
else
GWEN_MsgEndpoint_AddSockets(epChild, readSet, writeSet, xSet);
}
void _addSocketsWhenConnected(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
if (GWEN_MsgEndpoint_GetState(epChild)==GWEN_MSG_ENDPOINT_STATE_UNCONNECTED) {
DBG_ERROR(AQH_LOGDOMAIN, "Error on tcp layer, disconnecting");
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
else {
/* move to-send messages to child */
_moveMessagesBetweenLists(GWEN_MsgEndpoint_GetSendMessageList(ep), GWEN_MsgEndpoint_GetSendMessageList(epChild));
GWEN_MsgEndpoint_AddSockets(epChild, readSet, writeSet, xSet);
}
}
void _checkSocketsWhenConnected(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
_moveMessagesBetweenLists(GWEN_MsgEndpoint_GetSendMessageList(ep), GWEN_MsgEndpoint_GetSendMessageList(epChild));
GWEN_MsgEndpoint_CheckSockets(epChild, readSet, writeSet, xSet);
_moveMessagesBetweenLists(GWEN_MsgEndpoint_GetReceivedMessageList(epChild), GWEN_MsgEndpoint_GetReceivedMessageList(ep));
}
void _checkSocketsWhenConnecting(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild,
GWEN_SOCKETSET *readSet, GWEN_SOCKETSET *writeSet, GWEN_SOCKETSET *xSet)
{
GWEN_MSG *msg;
int stage;
GWEN_MsgEndpoint_CheckSockets(epChild, readSet, writeSet, xSet); /* let base layer work */
stage=GWEN_MultilayerEndpoint_GetStage(ep);
switch(stage) {
case AQH_ENDPOINT2_MQTTC_STAGE_CONNREQ: _lookForAndHandleConnAck(ep, epChild); break;
case AQH_ENDPOINT2_MQTTC_STAGE_SUBREQ: _lookForAndHandleSubAck(ep, epChild); break;
default: break;
}
}
int _startConnect(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild)
{
if (epChild) {
int rv;
GWEN_MSG *msg;
rv=GWEN_TcpcEndpoint_StartConnect(epChild);
if (rv<0 && rv!=GWEN_ERROR_IN_PROGRESS) {
DBG_INFO(AQH_LOGDOMAIN, "Error starting to connect child layer (%d)", rv);
return rv;
}
msg=AQH_MqttEndpoint_CreateMsgConnect(epChild);
if (msg) {
GWEN_MsgEndpoint_AddSendMessage(epChild, msg);
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTING);
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_CONNREQ);
return rv; /* result from GWEN_TcpcEndpoint_StartConnect() above */
}
}
return GWEN_ERROR_GENERIC;
}
void _lookForAndHandleConnAck(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild)
{
GWEN_MSG *msg;
msg=GWEN_MsgEndpoint_GetFirstReceivedMessage(epChild);
while(msg) {
GWEN_MSG *msgNext;
@@ -308,17 +182,38 @@ void _checkSocketsWhenConnecting(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChi
msgNext=GWEN_Msg_List_Next(msg);
msgType=AQH_MqttMsg_GetMsgTypeAndFlags(msg) & 0xf0;
if (msgType==AQH_MQTTMSG_MSGTYPE_CONNACK) {
int code;
GWEN_Msg_List_Del(msg); /* remove from list */
code=AQH_ConnAckMqttMsg_GetResultCode(msg);
if (code==AQH_MQTTMSG_CONNACK_RESULT_ACCEPTED) {
DBG_INFO(AQH_LOGDOMAIN, "Positive CONNACK response, connected");
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTED);
DBG_INFO(AQH_LOGDOMAIN, "Positive CONNACK response");
if (GWEN_MsgEndpoint_GetFlags(ep) & AQH_ENDPOINT2_MQTTCLIENT_FLAGS_SUBSCRIBEALL) {
int rv;
DBG_INFO(AQH_LOGDOMAIN, "Sending subscribe message");
rv=_sendSubscribeMsg(ep, epChild, "#");
if (rv<0) {
DBG_ERROR(AQH_LOGDOMAIN, "Error sending SUBSCRIBE request (%d)", rv);
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_NONE);
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
else {
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_SUBREQ);
}
}
else {
DBG_INFO(AQH_LOGDOMAIN, "Connected (no auto-subscription requested)");
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_UP);
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTED);
}
}
else {
DBG_ERROR(AQH_LOGDOMAIN, "Negative CONNACK response (%d)", code);
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_NONE);
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
@@ -334,30 +229,64 @@ void _checkSocketsWhenConnecting(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChi
int _startConnect(GWEN_MSG_ENDPOINT *ep)
void _lookForAndHandleSubAck(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild)
{
GWEN_MSG_ENDPOINT *epChild;
GWEN_MSG *msg;
epChild=GWEN_MsgEndpoint_Tree2_GetFirstChild(ep);
if (epChild) {
int rv;
GWEN_MSG *msg;
msg=GWEN_MsgEndpoint_GetFirstReceivedMessage(epChild);
while(msg) {
GWEN_MSG *msgNext;
uint8_t msgType;
rv=GWEN_TcpcEndpoint_StartConnect(epChild);
if (rv<0 && rv!=GWEN_ERROR_IN_PROGRESS) {
DBG_INFO(AQH_LOGDOMAIN, "Error starting to connect child layer (%d)", rv);
return rv;
msgNext=GWEN_Msg_List_Next(msg);
msgType=AQH_MqttMsg_GetMsgTypeAndFlags(msg) & 0xf0;
if (msgType==AQH_MQTTMSG_MSGTYPE_SUBACK) {
int code;
GWEN_Msg_List_Del(msg); /* remove from list */
code=AQH_SubAckMqttMsg_GetResultCode(msg);
if (code!=128) {
DBG_INFO(AQH_LOGDOMAIN, "Positive SUBACK response, connected (%d, %02x)", code, code);
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_UP);
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTED);
}
else {
DBG_ERROR(AQH_LOGDOMAIN, "Negative SUBACK response (%d)", code);
GWEN_MultilayerEndpoint_SetStage(ep, AQH_ENDPOINT2_MQTTC_STAGE_NONE);
GWEN_MsgEndpoint_Disconnect(epChild);
GWEN_MsgEndpoint_Disconnect(ep);
}
GWEN_Msg_free(msg);
break;
}
msg=AQH_MqttEndpoint_CreateMsgConnect(epChild);
if (msg) {
GWEN_MsgEndpoint_AddSendMessage(epChild, msg);
GWEN_MsgEndpoint_SetState(ep, GWEN_MSG_ENDPOINT_STATE_CONNECTING);
return rv; /* result from GWEN_TcpcEndpoint_StartConnect() above */
else {
DBG_ERROR(AQH_LOGDOMAIN, "Ignoring response (%d)", msgType);
}
msg=msgNext;
} /* while */
}
int _sendSubscribeMsg(GWEN_MSG_ENDPOINT *ep, GWEN_MSG_ENDPOINT *epChild, const char *topicFilter)
{
uint16_t pckId;
GWEN_MSG *msgOut;
DBG_INFO(AQH_LOGDOMAIN, "Sending SUBSCRIBE %s", topicFilter);
pckId=AQH_MqttClientEndpoint_GetNextPacketId(ep);
msgOut=GWEN_SubscribeMqttMsg_new(AQH_MQTTMSG_MSGTYPE_SUBSCRIBE, pckId, topicFilter, 0);
if (msgOut==NULL) {
DBG_ERROR(AQH_LOGDOMAIN, "Error creating message");
return GWEN_ERROR_INTERNAL;
}
return GWEN_ERROR_GENERIC;
GWEN_MsgEndpoint_AddSendMessage(epChild, msgOut);
return 0;
}

2
aqhome/mqtt/endpoint_mqttc.h
View File

@@ -19,6 +19,8 @@
extern "C" {
#endif
#define AQH_ENDPOINT2_MQTTCLIENT_FLAGS_SUBSCRIBEALL 0x0001
/**
*/

5
aqhome/mqtt/msg_mqtt.c
View File

@@ -13,6 +13,7 @@
#include "aqhome/mqtt/msg_mqtt.h"
#include <gwenhywfar/text.h>
#include <gwenhywfar/debug.h>
#include <string.h>
@@ -84,6 +85,10 @@ int AQH_MqttMsg_IsMsgComplete(const GWEN_MSG *msg)
void AQH_MqttMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
GWEN_Text_DumpString2Buffer((const char*) GWEN_Msg_GetConstBuffer(msg),
GWEN_Msg_GetBytesInBuffer(msg),
dbuf,
2);
}

32
aqhome/mqtt/msg_mqtt_suback.c
View File

@@ -41,6 +41,38 @@ GWEN_MSG *GWEN_SubAckMqttMsg_new(uint8_t flags, uint16_t packetId, uint8_t resul
int AQH_SubAckMqttMsg_GetResultCode(const GWEN_MSG *msg)
{
const uint8_t *msgPtr;
uint32_t msgLen;
msgPtr=GWEN_Msg_GetConstBuffer(msg);
msgLen=GWEN_Msg_GetBytesInBuffer(msg);
if (msgLen>1) {
uint32_t flags;
uint32_t payloadLen;
const uint8_t *payloadPtr;
flags=AQH_MqttMsg_GetMsgTypeAndFlags(msg);
payloadLen=GWEN_Msg_GetParsedPayloadSize(msg);
payloadPtr=msgPtr+GWEN_Msg_GetParsedPayloadOffset(msg);
if (payloadLen>0) {
if (flags & (AQH_MQTTMSG_FLAGS_QOS2 | AQH_MQTTMSG_FLAGS_QOS1)) {
payloadLen--;
payloadPtr++;
}
if (payloadLen>1)
return (int) (payloadPtr[0]);
}
}
return GWEN_ERROR_GENERIC;
}
void AQH_SubAckMqttMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText)
{
const uint8_t *msgPtr;

1
aqhome/mqtt/msg_mqtt_suback.h
View File

@@ -21,6 +21,7 @@
AQHOME_API GWEN_MSG *GWEN_SubAckMqttMsg_new(uint8_t flags, uint16_t packetId, uint8_t result);
AQHOME_API void AQH_SubAckMqttMsg_DumpToBuffer(const GWEN_MSG *msg, GWEN_BUFFER *dbuf, const char *sText);
AQHOME_API int AQH_SubAckMqttMsg_GetResultCode(const GWEN_MSG *msg);