GitHub/paho.mqtt-sn.embedded-c
1
0
Fork 0
mirror of https://github.com/eclipse/paho.mqtt-sn.embedded-c.git synced 2025-12-15 16:36:52 +01:00
Code Issues Projects Releases Wiki Activity

Change TAB to 4spaces

Browse Source 
Signed-off-by: tomoaki <tomoaki@tomy-tech.com>
This commit is contained in:
tomoaki
2021-02-16 15:51:54 +09:00
parent d05bf8eaf4
commit 69b229daae
60 changed files with 5973 additions and 5726 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
MQTTSNGateway/src/MQTTGWConnectionHandler.cpp
View File

@@ -22,7 +22,7 @@ using namespace MQTTSNGW;
MQTTGWConnectionHandler::MQTTGWConnectionHandler(Gateway* gateway) MQTTGWConnectionHandler::MQTTGWConnectionHandler(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTGWConnectionHandler::~MQTTGWConnectionHandler() MQTTGWConnectionHandler::~MQTTGWConnectionHandler()
@@ -30,70 +30,79 @@ MQTTGWConnectionHandler::~MQTTGWConnectionHandler()
} }
void MQTTGWConnectionHandler::handleConnack(Client* client, MQTTGWPacket* packet) void MQTTGWConnectionHandler::handleConnack(Client* client,
MQTTGWPacket* packet)
{ {
uint8_t rc = MQTT_SERVER_UNAVAILABLE; uint8_t rc = MQTT_SERVER_UNAVAILABLE;
Connack resp; Connack resp;
packet->getCONNACK(&resp); packet->getCONNACK(&resp);
/* convert MQTT ReturnCode to MQTT-SN one */ /* convert MQTT ReturnCode to MQTT-SN one */
if (resp.rc == MQTT_CONNECTION_ACCEPTED) if (resp.rc == MQTT_CONNECTION_ACCEPTED)
{ {
rc = MQTTSN_RC_ACCEPTED; rc = MQTTSN_RC_ACCEPTED;
} }
else if (resp.rc == MQTT_UNACCEPTABLE_PROTOCOL_VERSION) else if (resp.rc == MQTT_UNACCEPTABLE_PROTOCOL_VERSION)
{ {
rc = MQTTSN_RC_NOT_SUPPORTED; rc = MQTTSN_RC_NOT_SUPPORTED;
WRITELOG(" ClientID : %s Requested Protocol version is not supported.\n", client->getClientId()); WRITELOG(
} " ClientID : %s Requested Protocol version is not supported.\n",
else if (resp.rc == MQTT_IDENTIFIER_REJECTED) client->getClientId());
{ }
rc = MQTTSN_RC_NOT_SUPPORTED; else if (resp.rc == MQTT_IDENTIFIER_REJECTED)
WRITELOG(" ClientID : %s ClientID is collect UTF-8 but not allowed by the Server.\n", {
client->getClientId()); rc = MQTTSN_RC_NOT_SUPPORTED;
} WRITELOG(
else if (resp.rc == MQTT_SERVER_UNAVAILABLE) " ClientID : %s ClientID is collect UTF-8 but not allowed by the Server.\n",
{ client->getClientId());
rc = MQTTSN_RC_REJECTED_CONGESTED; }
WRITELOG(" ClientID : %s The Network Connection has been made but the MQTT service is unavailable.\n", else if (resp.rc == MQTT_SERVER_UNAVAILABLE)
client->getClientId()); {
} rc = MQTTSN_RC_REJECTED_CONGESTED;
else if (resp.rc == MQTT_BAD_USERNAME_OR_PASSWORD) WRITELOG(
{ " ClientID : %s The Network Connection has been made but the MQTT service is unavailable.\n",
rc = MQTTSN_RC_NOT_SUPPORTED; client->getClientId());
WRITELOG(" Gateway Configuration Error: The data in the user name or password is malformed.\n"); }
} else if (resp.rc == MQTT_BAD_USERNAME_OR_PASSWORD)
else if (resp.rc == MQTT_NOT_AUTHORIZED) {
{ rc = MQTTSN_RC_NOT_SUPPORTED;
rc = MQTTSN_RC_NOT_SUPPORTED; WRITELOG(
WRITELOG(" Gateway Configuration Error: The Client is not authorized to connect.\n"); " Gateway Configuration Error: The data in the user name or password is malformed.\n");
} }
else if (resp.rc == MQTT_NOT_AUTHORIZED)
{
rc = MQTTSN_RC_NOT_SUPPORTED;
WRITELOG(
" Gateway Configuration Error: The Client is not authorized to connect.\n");
}
MQTTSNPacket* snPacket = new MQTTSNPacket(); MQTTSNPacket* snPacket = new MQTTSNPacket();
snPacket->setCONNACK(rc); snPacket->setCONNACK(rc);
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setClientSendEvent(client, snPacket); ev1->setClientSendEvent(client, snPacket);
client->connackSended(rc); // update the client's status client->connackSended(rc); // update the client's status
_gateway->getClientSendQue()->post(ev1); _gateway->getClientSendQue()->post(ev1);
} }
void MQTTGWConnectionHandler::handlePingresp(Client* client, MQTTGWPacket* packet) void MQTTGWConnectionHandler::handlePingresp(Client* client,
MQTTGWPacket* packet)
{ {
MQTTSNPacket* snPacket = new MQTTSNPacket(); MQTTSNPacket* snPacket = new MQTTSNPacket();
snPacket->setPINGRESP(); snPacket->setPINGRESP();
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setClientSendEvent(client, snPacket); ev1->setClientSendEvent(client, snPacket);
client->updateStatus(snPacket); client->updateStatus(snPacket);
_gateway->getClientSendQue()->post(ev1); _gateway->getClientSendQue()->post(ev1);
} }
void MQTTGWConnectionHandler::handleDisconnect(Client* client, MQTTGWPacket* packet) void MQTTGWConnectionHandler::handleDisconnect(Client* client,
MQTTGWPacket* packet)
{ {
MQTTSNPacket* snPacket = new MQTTSNPacket(); MQTTSNPacket* snPacket = new MQTTSNPacket();
snPacket->setDISCONNECT(0); snPacket->setDISCONNECT(0);
client->disconnected(); client->disconnected();
client->getNetwork()->close(); client->getNetwork()->close();
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setClientSendEvent(client, snPacket); ev1->setClientSendEvent(client, snPacket);
} }

12
MQTTSNGateway/src/MQTTGWConnectionHandler.h
View File

@@ -26,13 +26,13 @@ namespace MQTTSNGW
class MQTTGWConnectionHandler class MQTTGWConnectionHandler
{ {
public: public:
MQTTGWConnectionHandler(Gateway* gateway); MQTTGWConnectionHandler(Gateway* gateway);
~MQTTGWConnectionHandler(); ~MQTTGWConnectionHandler();
void handleConnack(Client* client, MQTTGWPacket* packet); void handleConnack(Client* client, MQTTGWPacket* packet);
void handlePingresp(Client* client, MQTTGWPacket* packet); void handlePingresp(Client* client, MQTTGWPacket* packet);
void handleDisconnect(Client* client, MQTTGWPacket* packet); void handleDisconnect(Client* client, MQTTGWPacket* packet);
private: private:
Gateway* _gateway; Gateway* _gateway;
}; };
} }

829
MQTTSNGateway/src/MQTTGWPacket.cpp
View File

@@ -29,8 +29,9 @@ void writeInt(unsigned char** pptr, int msgId);
* List of the predefined MQTT v3 packet names. * List of the predefined MQTT v3 packet names.
*/ */
static const char* mqtt_packet_names[] = static const char* mqtt_packet_names[] =
{ "RESERVED", "CONNECT", "CONNACK", "PUBLISH", "PUBACK", "PUBREC", "PUBREL", "PUBCOMP", "SUBSCRIBE", "SUBACK", { "RESERVED", "CONNECT", "CONNACK", "PUBLISH", "PUBACK", "PUBREC", "PUBREL",
"UNSUBSCRIBE", "UNSUBACK", "PINGREQ", "PINGRESP", "DISCONNECT" }; "PUBCOMP", "SUBSCRIBE", "SUBACK", "UNSUBSCRIBE", "UNSUBACK", "PINGREQ",
"PINGRESP", "DISCONNECT" };
/** /**
* Encodes the message length according to the MQTT algorithm * Encodes the message length according to the MQTT algorithm
@@ -40,17 +41,17 @@ static const char* mqtt_packet_names[] =
*/ */
int MQTTPacket_encode(char* buf, int length) int MQTTPacket_encode(char* buf, int length)
{ {
int rc = 0; int rc = 0;
do do
{ {
char d = length % 128; char d = length % 128;
length /= 128; length /= 128;
/* if there are more digits to encode, set the top bit of this digit */ /* if there are more digits to encode, set the top bit of this digit */
if (length > 0) if (length > 0)
d |= 0x80; d |= 0x80;
buf[rc++] = d; buf[rc++] = d;
} while (length > 0); } while (length > 0);
return rc; return rc;
} }
/** /**
@@ -60,10 +61,10 @@ int MQTTPacket_encode(char* buf, int length)
*/ */
int readInt(char** pptr) int readInt(char** pptr)
{ {
char* ptr = *pptr; char* ptr = *pptr;
int len = 256 * ((unsigned char) (*ptr)) + (unsigned char) (*(ptr + 1)); int len = 256 * ((unsigned char) (*ptr)) + (unsigned char) (*(ptr + 1));
*pptr += 2; *pptr += 2;
return len; return len;
} }
/** /**
@@ -80,20 +81,20 @@ int readInt(char** pptr)
*/ */
char* readUTFlen(char** pptr, char* enddata, int* len) char* readUTFlen(char** pptr, char* enddata, int* len)
{ {
char* string = NULL; char* string = NULL;
if (enddata - (*pptr) > 1) /* enough length to read the integer? */ if (enddata - (*pptr) > 1) /* enough length to read the integer? */
{ {
*len = readInt(pptr); *len = readInt(pptr);
if (&(*pptr)[*len] <= enddata) if (&(*pptr)[*len] <= enddata)
{ {
string = (char*)calloc(*len + 1, 1); string = (char*) calloc(*len + 1, 1);
memcpy(string, *pptr, (size_t)*len); memcpy(string, *pptr, (size_t) *len);
string[*len] = '\0'; string[*len] = '\0';
*pptr += *len; *pptr += *len;
} }
} }
return string; return string;
} }
/** /**
@@ -108,8 +109,8 @@ char* readUTFlen(char** pptr, char* enddata, int* len)
*/ */
char* readUTF(char** pptr, char* enddata) char* readUTF(char** pptr, char* enddata)
{ {
int len; int len;
return readUTFlen(pptr, enddata, &len); return readUTFlen(pptr, enddata, &len);
} }
/** /**
@@ -119,9 +120,9 @@ char* readUTF(char** pptr, char* enddata)
*/ */
unsigned char readChar(char** pptr) unsigned char readChar(char** pptr)
{ {
unsigned char c = **pptr; unsigned char c = **pptr;
(*pptr)++; (*pptr)++;
return c; return c;
} }
/** /**
@@ -131,8 +132,8 @@ unsigned char readChar(char** pptr)
*/ */
void writeChar(unsigned char** pptr, char c) void writeChar(unsigned char** pptr, char c)
{ {
**pptr = c; **pptr = c;
(*pptr)++; (*pptr)++;
} }
/** /**
@@ -142,10 +143,10 @@ void writeChar(unsigned char** pptr, char c)
*/ */
void writeInt(unsigned char** pptr, int anInt) void writeInt(unsigned char** pptr, int anInt)
{ {
**pptr = (unsigned char)(anInt / 256); **pptr = (unsigned char) (anInt / 256);
(*pptr)++; (*pptr)++;
**pptr = (unsigned char)(anInt % 256); **pptr = (unsigned char) (anInt % 256);
(*pptr)++; (*pptr)++;
} }
/** /**
@@ -155,10 +156,10 @@ void writeInt(unsigned char** pptr, int anInt)
*/ */
void writeUTF(unsigned char** pptr, const char* string) void writeUTF(unsigned char** pptr, const char* string)
{ {
int len = (int)strlen(string); int len = (int) strlen(string);
writeInt(pptr, len); writeInt(pptr, len);
memcpy(*pptr, string, (size_t)len); memcpy(*pptr, string, (size_t) len);
*pptr += len; *pptr += len;
} }
/** /**
@@ -167,479 +168,485 @@ void writeUTF(unsigned char** pptr, const char* string)
*/ */
MQTTGWPacket::MQTTGWPacket() MQTTGWPacket::MQTTGWPacket()
{ {
_data = 0; _data = 0;
_header.byte = 0; _header.byte = 0;
_remainingLength = 0; _remainingLength = 0;
} }
MQTTGWPacket::~MQTTGWPacket() MQTTGWPacket::~MQTTGWPacket()
{ {
if (_data) if (_data)
{ {
free(_data); free(_data);
} }
} }
int MQTTGWPacket::recv(Network* network) int MQTTGWPacket::recv(Network* network)
{ {
int len = 0; int len = 0;
int multiplier = 1; int multiplier = 1;
unsigned char c; unsigned char c;
/* read First Byte of Packet */ /* read First Byte of Packet */
int rc = network->recv((unsigned char*)&_header.byte, 1); int rc = network->recv((unsigned char*) &_header.byte, 1);
if ( rc <= 0) if (rc <= 0)
{ {
return rc; return rc;
} }
/* read RemainingLength */ /* read RemainingLength */
do do
{ {
if (++len > MAX_NO_OF_REMAINING_LENGTH_BYTES) if (++len > MAX_NO_OF_REMAINING_LENGTH_BYTES)
{ {
return -2; return -2;
} }
if (network->recv(&c, 1) == -1) if (network->recv(&c, 1) == -1)
{ {
return -1; return -1;
} }
_remainingLength += (c & 127) * multiplier; _remainingLength += (c & 127) * multiplier;
multiplier *= 128; multiplier *= 128;
} while ((c & 128) != 0); } while ((c & 128) != 0);
if ( _remainingLength > 0 ) if (_remainingLength > 0)
{ {
/* allocate buffer */ /* allocate buffer */
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
if ( !_data ) if (!_data)
{ {
return -3; return -3;
} }
/* read Payload */ /* read Payload */
int remlen = network->recv(_data, _remainingLength); int remlen = network->recv(_data, _remainingLength);
if (remlen == -1 ) if (remlen == -1)
{ {
return -1; return -1;
} }
else if ( remlen != _remainingLength ) else if (remlen != _remainingLength)
{ {
return -2; return -2;
} }
} }
return 1 + len + _remainingLength; return 1 + len + _remainingLength;
} }
int MQTTGWPacket::send(Network* network) int MQTTGWPacket::send(Network* network)
{ {
unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE]; unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE];
memset(buf, 0, MQTTSNGW_MAX_PACKET_SIZE); memset(buf, 0, MQTTSNGW_MAX_PACKET_SIZE);
int len = getPacketData(buf); int len = getPacketData(buf);
return network->send(buf, len); return network->send(buf, len);
} }
int MQTTGWPacket::getAck(Ack* ack) int MQTTGWPacket::getAck(Ack* ack)
{ {
if (PUBACK != _header.bits.type && PUBREC != _header.bits.type && PUBREL != _header.bits.type if (PUBACK != _header.bits.type && PUBREC != _header.bits.type
&& PUBCOMP != _header.bits.type && UNSUBACK != _header.bits.type) && PUBREL != _header.bits.type && PUBCOMP != _header.bits.type
{ && UNSUBACK != _header.bits.type)
return 0; {
} return 0;
char* ptr = (char*) _data; }
ack->header.byte = _header.byte; char* ptr = (char*) _data;
ack->msgId = readInt((char**) &ptr); ack->header.byte = _header.byte;
return 1; ack->msgId = readInt((char**) &ptr);
return 1;
} }
int MQTTGWPacket::getCONNACK(Connack* resp) int MQTTGWPacket::getCONNACK(Connack* resp)
{ {
if (_header.bits.type != CONNACK) if (_header.bits.type != CONNACK)
{ {
return 0; return 0;
} }
char* ptr = (char*) _data; char* ptr = (char*) _data;
resp->header.byte = _header.byte; resp->header.byte = _header.byte;
resp->flags.all = *ptr++; resp->flags.all = *ptr++;
resp->rc = readChar(&ptr); resp->rc = readChar(&ptr);
return 1; return 1;
} }
int MQTTGWPacket::getSUBACK(unsigned short* msgId, unsigned char* rc) int MQTTGWPacket::getSUBACK(unsigned short* msgId, unsigned char* rc)
{ {
if (_header.bits.type != SUBACK) if (_header.bits.type != SUBACK)
{ {
return 0; return 0;
} }
char *ptr = (char*) _data; char *ptr = (char*) _data;
*msgId = readInt((char**) &ptr); *msgId = readInt((char**) &ptr);
*rc = readChar(&ptr); *rc = readChar(&ptr);
return 1; return 1;
} }
int MQTTGWPacket::getPUBLISH(Publish* pub) int MQTTGWPacket::getPUBLISH(Publish* pub)
{ {
if (_header.bits.type != PUBLISH) if (_header.bits.type != PUBLISH)
{ {
return 0; return 0;
} }
char* ptr = (char*) _data; char* ptr = (char*) _data;
pub->header = _header; pub->header = _header;
pub->topiclen = readInt((char**) &ptr); pub->topiclen = readInt((char**) &ptr);
pub->topic = (char*) _data + 2; pub->topic = (char*) _data + 2;
ptr += pub->topiclen; ptr += pub->topiclen;
if (_header.bits.qos > 0) if (_header.bits.qos > 0)
{ {
pub->msgId = readInt(&ptr); pub->msgId = readInt(&ptr);
pub->payloadlen = _remainingLength - pub->topiclen - 4; pub->payloadlen = _remainingLength - pub->topiclen - 4;
} }
else else
{ {
pub->msgId = 0; pub->msgId = 0;
pub->payloadlen = _remainingLength - pub->topiclen - 2; pub->payloadlen = _remainingLength - pub->topiclen - 2;
} }
pub->payload = ptr; pub->payload = ptr;
return 1; return 1;
} }
int MQTTGWPacket::setCONNECT(Connect* connect, unsigned char* username, unsigned char* password) int MQTTGWPacket::setCONNECT(Connect* connect, unsigned char* username,
unsigned char* password)
{ {
clearData(); clearData();
_header = connect->header; _header = connect->header;
_remainingLength = ((connect->version == 3) ? 12 : 10) + (int)strlen(connect->clientID) + 2; _remainingLength = ((connect->version == 3) ? 12 : 10)
if (connect->flags.bits.will) + (int) strlen(connect->clientID) + 2;
{ if (connect->flags.bits.will)
_remainingLength += (int)strlen(connect->willTopic) + 2 + (int)strlen(connect->willMsg) + 2; {
} _remainingLength += (int) strlen(connect->willTopic) + 2
if ( connect->flags.bits.username ) + (int) strlen(connect->willMsg) + 2;
{ }
_remainingLength += (int)strlen((char*) username) + 2; if (connect->flags.bits.username)
} {
if (connect->flags.bits.password) _remainingLength += (int) strlen((char*) username) + 2;
{ }
_remainingLength += (int)strlen((char*) password) + 2; if (connect->flags.bits.password)
} {
_remainingLength += (int) strlen((char*) password) + 2;
}
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
unsigned char* ptr = _data; unsigned char* ptr = _data;
if (connect->version == 3) if (connect->version == 3)
{ {
writeUTF(&ptr, "MQIsdp"); writeUTF(&ptr, "MQIsdp");
writeChar(&ptr, (char) 3); writeChar(&ptr, (char) 3);
} }
else if (connect->version == 4) else if (connect->version == 4)
{ {
writeUTF(&ptr, "MQTT"); writeUTF(&ptr, "MQTT");
writeChar(&ptr, (char) 4); writeChar(&ptr, (char) 4);
} }
else else
{ {
return 0; return 0;
} }
writeChar(&ptr, connect->flags.all); writeChar(&ptr, connect->flags.all);
writeInt(&ptr, connect->keepAliveTimer); writeInt(&ptr, connect->keepAliveTimer);
writeUTF(&ptr, connect->clientID); writeUTF(&ptr, connect->clientID);
if (connect->flags.bits.will) if (connect->flags.bits.will)
{ {
writeUTF(&ptr, connect->willTopic); writeUTF(&ptr, connect->willTopic);
writeUTF(&ptr, connect->willMsg); writeUTF(&ptr, connect->willMsg);
} }
if (connect->flags.bits.username) if (connect->flags.bits.username)
{ {
writeUTF(&ptr, (const char*) username); writeUTF(&ptr, (const char*) username);
} }
if (connect->flags.bits.password) if (connect->flags.bits.password)
{ {
writeUTF(&ptr, (const char*) password); writeUTF(&ptr, (const char*) password);
} }
return 1; return 1;
} }
int MQTTGWPacket::setSUBSCRIBE(const char* topic, unsigned char qos, unsigned short msgId) int MQTTGWPacket::setSUBSCRIBE(const char* topic, unsigned char qos,
unsigned short msgId)
{ {
clearData(); clearData();
_header.byte = 0; _header.byte = 0;
_header.bits.type = SUBSCRIBE; _header.bits.type = SUBSCRIBE;
_header.bits.qos = 1; // Reserved _header.bits.qos = 1; // Reserved
_remainingLength = (int)strlen(topic) + 5; _remainingLength = (int) strlen(topic) + 5;
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
if (_data) if (_data)
{ {
unsigned char* ptr = _data; unsigned char* ptr = _data;
writeInt(&ptr, msgId); writeInt(&ptr, msgId);
writeUTF(&ptr, topic); writeUTF(&ptr, topic);
writeChar(&ptr, (char) qos); writeChar(&ptr, (char) qos);
return 1; return 1;
} }
clearData(); clearData();
return 0; return 0;
} }
int MQTTGWPacket::setUNSUBSCRIBE(const char* topic, unsigned short msgid) int MQTTGWPacket::setUNSUBSCRIBE(const char* topic, unsigned short msgid)
{ {
clearData(); clearData();
_header.byte = 0; _header.byte = 0;
_header.bits.type = UNSUBSCRIBE; _header.bits.type = UNSUBSCRIBE;
_header.bits.qos = 1; _header.bits.qos = 1;
_remainingLength = (int)strlen(topic) + 4; _remainingLength = (int) strlen(topic) + 4;
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
if (_data) if (_data)
{ {
unsigned char* ptr = _data; unsigned char* ptr = _data;
writeInt(&ptr, msgid); writeInt(&ptr, msgid);
writeUTF(&ptr, topic); writeUTF(&ptr, topic);
return 1; return 1;
} }
clearData(); clearData();
return 0; return 0;
} }
int MQTTGWPacket::setPUBLISH(Publish* pub) int MQTTGWPacket::setPUBLISH(Publish* pub)
{ {
clearData(); clearData();
_header.byte = pub->header.byte; _header.byte = pub->header.byte;
_header.bits.type = PUBLISH; _header.bits.type = PUBLISH;
_remainingLength = 4 + pub->topiclen + pub->payloadlen; _remainingLength = 4 + pub->topiclen + pub->payloadlen;
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
if (_data) if (_data)
{ {
unsigned char* ptr = _data; unsigned char* ptr = _data;
writeInt(&ptr, pub->topiclen); writeInt(&ptr, pub->topiclen);
memcpy(ptr, pub->topic, pub->topiclen); memcpy(ptr, pub->topic, pub->topiclen);
ptr += pub->topiclen; ptr += pub->topiclen;
if ( _header.bits.qos > 0 ) if (_header.bits.qos > 0)
{ {
writeInt(&ptr, pub->msgId); writeInt(&ptr, pub->msgId);
} }
else else
{ {
_remainingLength -= 2; _remainingLength -= 2;
} }
memcpy(ptr, pub->payload, pub->payloadlen); memcpy(ptr, pub->payload, pub->payloadlen);
return 1; return 1;
} }
else else
{ {
clearData(); clearData();
return 0; return 0;
} }
} }
int MQTTGWPacket::setAck(unsigned char msgType, unsigned short msgid) int MQTTGWPacket::setAck(unsigned char msgType, unsigned short msgid)
{ {
clearData(); clearData();
_remainingLength = 2; _remainingLength = 2;
_header.bits.type = msgType; _header.bits.type = msgType;
_header.bits.qos = (msgType == PUBREL) ? 1 : 0; _header.bits.qos = (msgType == PUBREL) ? 1 : 0;
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
if (_data) if (_data)
{ {
unsigned char* data = _data; unsigned char* data = _data;
writeInt(&data, msgid); writeInt(&data, msgid);
return 1; return 1;
} }
return 0; return 0;
} }
int MQTTGWPacket::setHeader(unsigned char msgType) int MQTTGWPacket::setHeader(unsigned char msgType)
{ {
clearData(); clearData();
if (msgType < CONNECT || msgType > DISCONNECT) if (msgType < CONNECT || msgType > DISCONNECT)
{ {
return 0; return 0;
} }
_header.bits.type = msgType; _header.bits.type = msgType;
return 0; return 0;
} }
int MQTTGWPacket::getType(void) int MQTTGWPacket::getType(void)
{ {
return _header.bits.type; return _header.bits.type;
} }
const char* MQTTGWPacket::getName(void) const char* MQTTGWPacket::getName(void)
{ {
return getType() > DISCONNECT ? "UNKNOWN" : mqtt_packet_names[getType()]; return getType() > DISCONNECT ? "UNKNOWN" : mqtt_packet_names[getType()];
} }
int MQTTGWPacket::getPacketData(unsigned char* buf) int MQTTGWPacket::getPacketData(unsigned char* buf)
{ {
unsigned char* ptr = buf; unsigned char* ptr = buf;
*ptr++ = _header.byte; *ptr++ = _header.byte;
int len = MQTTPacket_encode((char*)ptr, _remainingLength); int len = MQTTPacket_encode((char*) ptr, _remainingLength);
ptr += len; ptr += len;
memcpy(ptr, _data, _remainingLength); memcpy(ptr, _data, _remainingLength);
return 1 + len + _remainingLength; return 1 + len + _remainingLength;
} }
int MQTTGWPacket::getPacketLength(void) int MQTTGWPacket::getPacketLength(void)
{ {
char buf[4]; char buf[4];
return 1 + MQTTPacket_encode(buf, _remainingLength) + _remainingLength; return 1 + MQTTPacket_encode(buf, _remainingLength) + _remainingLength;
} }
void MQTTGWPacket::clearData(void) void MQTTGWPacket::clearData(void)
{ {
if (_data) if (_data)
{ {
free(_data); free(_data);
} }
_header.byte = 0; _header.byte = 0;
_remainingLength = 0; _remainingLength = 0;
} }
char* MQTTGWPacket::getMsgId(char* pbuf) char* MQTTGWPacket::getMsgId(char* pbuf)
{ {
int type = getType(); int type = getType();
switch ( type ) switch (type)
{ {
case PUBLISH: case PUBLISH:
Publish pub; Publish pub;
pub.msgId = 0; pub.msgId = 0;
getPUBLISH(&pub); getPUBLISH(&pub);
if ( _header.bits.dup ) if (_header.bits.dup)
{ {
sprintf(pbuf, "+%04X", pub.msgId); sprintf(pbuf, "+%04X", pub.msgId);
} }
else else
{ {
sprintf(pbuf, " %04X", pub.msgId); sprintf(pbuf, " %04X", pub.msgId);
} }
break; break;
case SUBSCRIBE: case SUBSCRIBE:
case UNSUBSCRIBE: case UNSUBSCRIBE:
case PUBACK: case PUBACK:
case PUBREC: case PUBREC:
case PUBREL: case PUBREL:
case PUBCOMP: case PUBCOMP:
case SUBACK: case SUBACK:
case UNSUBACK: case UNSUBACK:
sprintf(pbuf, " %02X%02X", _data[0], _data[1]); sprintf(pbuf, " %02X%02X", _data[0], _data[1]);
break; break;
default: default:
sprintf(pbuf, " "); sprintf(pbuf, " ");
break; break;
} }
if ( strcmp(pbuf, " 0000") == 0 ) if (strcmp(pbuf, " 0000") == 0)
{ {
sprintf(pbuf, " "); sprintf(pbuf, " ");
} }
return pbuf; return pbuf;
} }
int MQTTGWPacket::getMsgId(void) int MQTTGWPacket::getMsgId(void)
{ {
int type = getType(); int type = getType();
int msgId = 0; int msgId = 0;
switch ( type ) switch (type)
{ {
case PUBLISH: case PUBLISH:
Publish pub; Publish pub;
pub.msgId = 0; pub.msgId = 0;
getPUBLISH(&pub); getPUBLISH(&pub);
msgId = pub.msgId; msgId = pub.msgId;
break; break;
case PUBACK: case PUBACK:
case PUBREC: case PUBREC:
case PUBREL: case PUBREL:
case PUBCOMP: case PUBCOMP:
case SUBSCRIBE: case SUBSCRIBE:
case UNSUBSCRIBE: case UNSUBSCRIBE:
case SUBACK: case SUBACK:
case UNSUBACK: case UNSUBACK:
msgId = 256 * (unsigned char)_data[0] + (unsigned char)_data[1]; msgId = 256 * (unsigned char) _data[0] + (unsigned char) _data[1];
break; break;
default: default:
break; break;
} }
return msgId; return msgId;
} }
void MQTTGWPacket::setMsgId(int msgId) void MQTTGWPacket::setMsgId(int msgId)
{ {
int type = getType(); int type = getType();
unsigned char* ptr = 0; unsigned char* ptr = 0;
switch ( type ) switch (type)
{ {
case PUBLISH: case PUBLISH:
Publish pub; Publish pub;
pub.topiclen = 0; pub.topiclen = 0;
pub.msgId = 0; pub.msgId = 0;
getPUBLISH(&pub); getPUBLISH(&pub);
pub.msgId = msgId; pub.msgId = msgId;
ptr = _data + pub.topiclen; ptr = _data + pub.topiclen;
writeInt(&ptr, pub.msgId); writeInt(&ptr, pub.msgId);
*ptr++ = (unsigned char)(msgId / 256); *ptr++ = (unsigned char) (msgId / 256);
*ptr = (unsigned char)(msgId % 256); *ptr = (unsigned char) (msgId % 256);
break; break;
case SUBSCRIBE: case SUBSCRIBE:
case UNSUBSCRIBE: case UNSUBSCRIBE:
case PUBACK: case PUBACK:
case PUBREC: case PUBREC:
case PUBREL: case PUBREL:
case PUBCOMP: case PUBCOMP:
case SUBACK: case SUBACK:
case UNSUBACK: case UNSUBACK:
ptr = _data; ptr = _data;
*ptr++ = (unsigned char)(msgId / 256); *ptr++ = (unsigned char) (msgId / 256);
*ptr = (unsigned char)(msgId % 256); *ptr = (unsigned char) (msgId % 256);
break; break;
default: default:
break; break;
} }
} }
char* MQTTGWPacket::print(char* pbuf) char* MQTTGWPacket::print(char* pbuf)
{ {
uint8_t packetData[MQTTSNGW_MAX_PACKET_SIZE]; uint8_t packetData[MQTTSNGW_MAX_PACKET_SIZE];
char* ptr = pbuf; char* ptr = pbuf;
char** pptr = &pbuf; char** pptr = &pbuf;
int len = getPacketData(packetData); int len = getPacketData(packetData);
int size = len > SIZE_OF_LOG_PACKET ? SIZE_OF_LOG_PACKET : len; int size = len > SIZE_OF_LOG_PACKET ? SIZE_OF_LOG_PACKET : len;
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
{ {
sprintf(*pptr, " %02X", packetData[i]); sprintf(*pptr, " %02X", packetData[i]);
*pptr += 3; *pptr += 3;
} }
**pptr = 0; **pptr = 0;
return ptr; return ptr;
} }
MQTTGWPacket& MQTTGWPacket::operator =(MQTTGWPacket& packet) MQTTGWPacket& MQTTGWPacket::operator =(MQTTGWPacket& packet)
{ {
clearData(); clearData();
this->_header.byte = packet._header.byte; this->_header.byte = packet._header.byte;
this->_remainingLength = packet._remainingLength; this->_remainingLength = packet._remainingLength;
_data = (unsigned char*)calloc(_remainingLength, 1); _data = (unsigned char*) calloc(_remainingLength, 1);
if (_data) if (_data)
{ {
memcpy(this->_data, packet._data, _remainingLength); memcpy(this->_data, packet._data, _remainingLength);
} }
else else
{ {
clearData(); clearData();
} }
return *this; return *this;
} }
UTF8String MQTTGWPacket::getTopic(void) UTF8String MQTTGWPacket::getTopic(void)
{ {
UTF8String str = {0, nullptr}; UTF8String str =
if ( _header.bits.type == SUBSCRIBE || _header.bits.type == UNSUBSCRIBE ) { 0, nullptr };
{ if (_header.bits.type == SUBSCRIBE || _header.bits.type == UNSUBSCRIBE)
char* ptr = (char*)(_data + 2); {
str.len = readInt(&ptr); char* ptr = (char*) (_data + 2);
str.data = (char*)(_data + 4); str.len = readInt(&ptr);
} str.data = (char*) (_data + 4);
return str; }
return str;
} }

250
MQTTSNGateway/src/MQTTGWPacket.h
View File

@@ -31,89 +31,100 @@ typedef void* (*pf)(unsigned char, char*, size_t);
enum msgTypes enum msgTypes
{ {
CONNECT = 1, CONNACK, PUBLISH, PUBACK, PUBREC, PUBREL, CONNECT = 1,
PUBCOMP, SUBSCRIBE, SUBACK, UNSUBSCRIBE, UNSUBACK, CONNACK,
PINGREQ, PINGRESP, DISCONNECT PUBLISH,
PUBACK,
PUBREC,
PUBREL,
PUBCOMP,
SUBSCRIBE,
SUBACK,
UNSUBSCRIBE,
UNSUBACK,
PINGREQ,
PINGRESP,
DISCONNECT
}; };
/** /**
* Bitfields for the MQTT header byte. * Bitfields for the MQTT header byte.
*/ */
typedef union typedef union
{ {
/*unsigned*/ char byte; /**< the whole byte */ /*unsigned*/
char byte; /**< the whole byte */
#if defined(REVERSED) #if defined(REVERSED)
struct struct
{ {
unsigned int type : 4; /**< message type nibble */ unsigned int type : 4; /**< message type nibble */
bool dup : 1; /**< DUP flag bit */ bool dup : 1; /**< DUP flag bit */
unsigned int qos : 2; /**< QoS value, 0, 1 or 2 */ unsigned int qos : 2; /**< QoS value, 0, 1 or 2 */
bool retain : 1; /**< retained flag bit */ bool retain : 1; /**< retained flag bit */
} bits; }bits;
#else #else
struct struct
{ {
bool retain : 1; /**< retained flag bit */ bool retain :1; /**< retained flag bit */
unsigned int qos : 2; /**< QoS value, 0, 1 or 2 */ unsigned int qos :2; /**< QoS value, 0, 1 or 2 */
bool dup : 1; /**< DUP flag bit */ bool dup :1; /**< DUP flag bit */
unsigned int type : 4; /**< message type nibble */ unsigned int type :4; /**< message type nibble */
} bits; } bits;
#endif #endif
} Header; } Header;
/** /**
* Data for a connect packet. * Data for a connect packet.
*/ */
enum MQTT_connackCodes{ enum MQTT_connackCodes
MQTT_CONNECTION_ACCEPTED , {
MQTT_UNACCEPTABLE_PROTOCOL_VERSION, MQTT_CONNECTION_ACCEPTED,
MQTT_IDENTIFIER_REJECTED, MQTT_UNACCEPTABLE_PROTOCOL_VERSION,
MQTT_SERVER_UNAVAILABLE, MQTT_IDENTIFIER_REJECTED,
MQTT_BAD_USERNAME_OR_PASSWORD, MQTT_SERVER_UNAVAILABLE,
MQTT_NOT_AUTHORIZED MQTT_BAD_USERNAME_OR_PASSWORD,
MQTT_NOT_AUTHORIZED
}; };
typedef struct typedef struct
{ {
Header header; /**< MQTT header byte */ Header header; /**< MQTT header byte */
union union
{ {
unsigned char all; /**< all connect flags */ unsigned char all; /**< all connect flags */
#if defined(REVERSED) #if defined(REVERSED)
struct struct
{ {
bool username : 1; /**< 3.1 user name */ bool username : 1; /**< 3.1 user name */
bool password : 1; /**< 3.1 password */ bool password : 1; /**< 3.1 password */
bool willRetain : 1; /**< will retain setting */ bool willRetain : 1; /**< will retain setting */
unsigned int willQoS : 2; /**< will QoS value */ unsigned int willQoS : 2; /**< will QoS value */
bool will : 1; /**< will flag */ bool will : 1; /**< will flag */
bool cleanstart : 1; /**< cleansession flag */ bool cleanstart : 1; /**< cleansession flag */
int : 1; /**< unused */ int : 1; /**< unused */
} bits; }bits;
#else #else
struct struct
{ {
int : 1; /**< unused */ int :1; /**< unused */
bool cleanstart : 1; /**< cleansession flag */ bool cleanstart :1; /**< cleansession flag */
bool will : 1; /**< will flag */ bool will :1; /**< will flag */
unsigned int willQoS : 2; /**< will QoS value */ unsigned int willQoS :2; /**< will QoS value */
bool willRetain : 1; /**< will retain setting */ bool willRetain :1; /**< will retain setting */
bool password : 1; /**< 3.1 password */ bool password :1; /**< 3.1 password */
bool username : 1; /**< 3.1 user name */ bool username :1; /**< 3.1 user name */
} bits; } bits;
#endif #endif
} flags; /**< connect flags byte */ } flags; /**< connect flags byte */
char *Protocol, /**< MQTT protocol name */ char *Protocol, /**< MQTT protocol name */
*clientID, /**< string client id */ *clientID, /**< string client id */
*willTopic, /**< will topic */ *willTopic, /**< will topic */
*willMsg; /**< will payload */ *willMsg; /**< will payload */
int keepAliveTimer; /**< keepalive timeout value in seconds */ int keepAliveTimer; /**< keepalive timeout value in seconds */
unsigned char version; /**< MQTT version number */ unsigned char version; /**< MQTT version number */
} Connect; } Connect;
#define MQTTPacket_Connect_Initializer {{0}, {0}, nullptr, nullptr, nullptr, nullptr, 0, 0} #define MQTTPacket_Connect_Initializer {{0}, {0}, nullptr, nullptr, nullptr, nullptr, 0, 0}
@@ -121,57 +132,54 @@ typedef struct
#define MQTTPacket_connectData_initializer { {'M', 'Q', 'T', 'C'}, 0, 4, {NULL, {0, NULL}}, 60, 1, 0, \ #define MQTTPacket_connectData_initializer { {'M', 'Q', 'T', 'C'}, 0, 4, {NULL, {0, NULL}}, 60, 1, 0, \
MQTTPacket_willOptions_initializer, {NULL, {0, NULL}}, {NULL, {0, NULL}} } MQTTPacket_willOptions_initializer, {NULL, {0, NULL}}, {NULL, {0, NULL}} }
/** /**
* Data for a willMessage. * Data for a willMessage.
*/ */
typedef struct typedef struct
{ {
char* topic; char* topic;
char* msg; char* msg;
int retained; int retained;
int qos; int qos;
}willMessages; } willMessages;
/** /**
* Data for a connack packet. * Data for a connack packet.
*/ */
typedef struct typedef struct
{ {
Header header; /**< MQTT header byte */ Header header; /**< MQTT header byte */
union union
{ {
unsigned char all; /**< all connack flags */ unsigned char all; /**< all connack flags */
#if defined(REVERSED) #if defined(REVERSED)
struct struct
{ {
unsigned int reserved : 7; /**< message type nibble */ unsigned int reserved : 7; /**< message type nibble */
bool sessionPresent : 1; /**< was a session found on the server? */ bool sessionPresent : 1; /**< was a session found on the server? */
} bits; }bits;
#else #else
struct struct
{ {
bool sessionPresent : 1; /**< was a session found on the server? */ bool sessionPresent :1; /**< was a session found on the server? */
unsigned int reserved : 7; /**< message type nibble */ unsigned int reserved :7; /**< message type nibble */
} bits; } bits;
#endif #endif
} flags; /**< connack flags byte */ } flags; /**< connack flags byte */
char rc; /**< connack return code */ char rc; /**< connack return code */
} Connack; } Connack;
/** /**
* Data for a publish packet. * Data for a publish packet.
*/ */
typedef struct typedef struct
{ {
Header header; /**< MQTT header byte */ Header header; /**< MQTT header byte */
char* topic; /**< topic string */ char* topic; /**< topic string */
int topiclen; int topiclen;
int msgId; /**< MQTT message id */ int msgId; /**< MQTT message id */
char* payload; /**< binary payload, length delimited */ char* payload; /**< binary payload, length delimited */
int payloadlen; /**< payload length */ int payloadlen; /**< payload length */
} Publish; } Publish;
#define MQTTPacket_Publish_Initializer {{0}, nullptr, 0, 0, nullptr, 0} #define MQTTPacket_Publish_Initializer {{0}, nullptr, 0, 0, nullptr, 0}
@@ -181,8 +189,8 @@ typedef struct
*/ */
typedef struct typedef struct
{ {
Header header; /**< MQTT header byte */ Header header; /**< MQTT header byte */
int msgId; /**< MQTT message id */ int msgId; /**< MQTT message id */
} Ack; } Ack;
/** /**
@@ -190,8 +198,8 @@ typedef struct
*/ */
typedef struct typedef struct
{ {
unsigned char len; unsigned char len;
char* data; char* data;
} UTF8String; } UTF8String;
/** /**
@@ -200,39 +208,41 @@ typedef struct
class MQTTGWPacket class MQTTGWPacket
{ {
public: public:
MQTTGWPacket(); MQTTGWPacket();
~MQTTGWPacket(); ~MQTTGWPacket();
int recv(Network* network); int recv(Network* network);
int send(Network* network); int send(Network* network);
int getType(void); int getType(void);
int getPacketData(unsigned char* buf); int getPacketData(unsigned char* buf);
int getPacketLength(void); int getPacketLength(void);
const char* getName(void); const char* getName(void);
int getAck(Ack* ack); int getAck(Ack* ack);
int getCONNACK(Connack* resp); int getCONNACK(Connack* resp);
int getSUBACK(unsigned short* msgId, unsigned char* rc); int getSUBACK(unsigned short* msgId, unsigned char* rc);
int getPUBLISH(Publish* pub); int getPUBLISH(Publish* pub);
int setCONNECT(Connect* conect, unsigned char* username, unsigned char* password); int setCONNECT(Connect* conect, unsigned char* username,
int setPUBLISH(Publish* pub); unsigned char* password);
int setAck(unsigned char msgType, unsigned short msgid); int setPUBLISH(Publish* pub);
int setHeader(unsigned char msgType); int setAck(unsigned char msgType, unsigned short msgid);
int setSUBSCRIBE(const char* topic, unsigned char qos, unsigned short msgId); int setHeader(unsigned char msgType);
int setUNSUBSCRIBE(const char* topics, unsigned short msgid); int setSUBSCRIBE(const char* topic, unsigned char qos,
unsigned short msgId);
int setUNSUBSCRIBE(const char* topics, unsigned short msgid);
UTF8String getTopic(void); UTF8String getTopic(void);
char* getMsgId(char* buf); char* getMsgId(char* buf);
int getMsgId(void); int getMsgId(void);
void setMsgId(int msgId); void setMsgId(int msgId);
char* print(char* buf); char* print(char* buf);
MQTTGWPacket& operator =(MQTTGWPacket& packet); MQTTGWPacket& operator =(MQTTGWPacket& packet);
private: private:
void clearData(void); void clearData(void);
Header _header; Header _header;
int _remainingLength; int _remainingLength;
unsigned char* _data; unsigned char* _data;
}; };
} }

425
MQTTSNGateway/src/MQTTGWPublishHandler.cpp
View File

@@ -27,7 +27,7 @@ char* currentDateTime(void);
MQTTGWPublishHandler::MQTTGWPublishHandler(Gateway* gateway) MQTTGWPublishHandler::MQTTGWPublishHandler(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTGWPublishHandler::~MQTTGWPublishHandler() MQTTGWPublishHandler::~MQTTGWPublishHandler()
@@ -37,266 +37,285 @@ MQTTGWPublishHandler::~MQTTGWPublishHandler()
void MQTTGWPublishHandler::handlePublish(Client* client, MQTTGWPacket* packet) void MQTTGWPublishHandler::handlePublish(Client* client, MQTTGWPacket* packet)
{ {
if ( !client->isActive() && !client->isSleep() && !client->isAwake()) if (!client->isActive() && !client->isSleep() && !client->isAwake())
{ {
WRITELOG("%s The client is neither active nor sleep %s%s\n", ERRMSG_HEADER, client->getStatus(), ERRMSG_FOOTER); WRITELOG("%s The client is neither active nor sleep %s%s\n",
return; ERRMSG_HEADER, client->getStatus(), ERRMSG_FOOTER);
} return;
}
/* client is sleeping. save PUBLISH */ /* client is sleeping. save PUBLISH */
if ( client->isSleep() ) if (client->isSleep())
{ {
Publish pub; Publish pub;
packet->getPUBLISH(&pub); packet->getPUBLISH(&pub);
WRITELOG(FORMAT_Y_G_G, currentDateTime(), packet->getName(), WRITELOG(FORMAT_Y_G_G, currentDateTime(), packet->getName(),
RIGHTARROW, client->getClientId(), "is sleeping. a message was saved."); RIGHTARROW, client->getClientId(), "is sleeping. a message was saved.");
if (pub.header.bits.qos == 1) if (pub.header.bits.qos == 1)
{ {
replyACK(client, &pub, PUBACK); replyACK(client, &pub, PUBACK);
} }
else if ( pub.header.bits.qos == 2) else if (pub.header.bits.qos == 2)
{ {
replyACK(client, &pub, PUBREC); replyACK(client, &pub, PUBREC);
} }
MQTTGWPacket* msg = new MQTTGWPacket(); MQTTGWPacket* msg = new MQTTGWPacket();
*msg = *packet; *msg = *packet;
if ( msg->getType() == 0 ) if (msg->getType() == 0)
{ {
WRITELOG("%s MQTTGWPublishHandler::handlePublish can't allocate memories for Packet.%s\n", ERRMSG_HEADER,ERRMSG_FOOTER); WRITELOG(
delete msg; "%s MQTTGWPublishHandler::handlePublish can't allocate memories for Packet.%s\n",
return; ERRMSG_HEADER, ERRMSG_FOOTER);
} delete msg;
client->setClientSleepPacket(msg); return;
return; }
} client->setClientSleepPacket(msg);
return;
}
Publish pub; Publish pub;
packet->getPUBLISH(&pub); packet->getPUBLISH(&pub);
MQTTSNPacket* snPacket = new MQTTSNPacket(); MQTTSNPacket* snPacket = new MQTTSNPacket();
/* create MQTTSN_topicid */ /* create MQTTSN_topicid */
MQTTSN_topicid topicId; MQTTSN_topicid topicId;
uint16_t id = 0; uint16_t id = 0;
if (pub.topiclen <= 2) if (pub.topiclen <= 2)
{ {
topicId.type = MQTTSN_TOPIC_TYPE_SHORT; topicId.type = MQTTSN_TOPIC_TYPE_SHORT;
*(topicId.data.short_name) = *pub.topic; *(topicId.data.short_name) = *pub.topic;
*(topicId.data.short_name + 1) = *(pub.topic + 1); *(topicId.data.short_name + 1) = *(pub.topic + 1);
} }
else else
{ {
topicId.data.long_.len = pub.topiclen; topicId.data.long_.len = pub.topiclen;
topicId.data.long_.name = pub.topic; topicId.data.long_.name = pub.topic;
Topic* tp = client->getTopics()->getTopicByName(&topicId); Topic* tp = client->getTopics()->getTopicByName(&topicId);
if ( tp ) if (tp)
{ {
topicId.type = tp->getType(); topicId.type = tp->getType();
topicId.data.long_.len = pub.topiclen; topicId.data.long_.len = pub.topiclen;
topicId.data.long_.name = pub.topic; topicId.data.long_.name = pub.topic;
topicId.data.id = tp->getTopicId(); topicId.data.id = tp->getTopicId();
} }
else else
{ {
/* This message might be subscribed with wild card. */ /* This message might be subscribed with wild card. */
topicId.type = MQTTSN_TOPIC_TYPE_NORMAL; topicId.type = MQTTSN_TOPIC_TYPE_NORMAL;
Topic* topic = client->getTopics()->match(&topicId); Topic* topic = client->getTopics()->match(&topicId);
if (topic == nullptr) if (topic == nullptr)
{ {
WRITELOG(" Invalid Topic. PUBLISH message is canceled.\n"); WRITELOG(" Invalid Topic. PUBLISH message is canceled.\n");
if (pub.header.bits.qos == 1) if (pub.header.bits.qos == 1)
{ {
replyACK(client, &pub, PUBACK); replyACK(client, &pub, PUBACK);
} }
else if ( pub.header.bits.qos == 2 ) else if (pub.header.bits.qos == 2)
{ {
replyACK(client, &pub, PUBREC); replyACK(client, &pub, PUBREC);
} }
delete snPacket; delete snPacket;
return; return;
} }
/* add the Topic and get a TopicId */ /* add the Topic and get a TopicId */
topic = client->getTopics()->add(&topicId); topic = client->getTopics()->add(&topicId);
id = topic->getTopicId(); id = topic->getTopicId();
if (id > 0) if (id > 0)
{ {
/* create REGISTER */ /* create REGISTER */
MQTTSNPacket* regPacket = new MQTTSNPacket(); MQTTSNPacket* regPacket = new MQTTSNPacket();
MQTTSNString topicName = MQTTSNString_initializer; MQTTSNString topicName = MQTTSNString_initializer;
topicName.lenstring.len = topicId.data.long_.len; topicName.lenstring.len = topicId.data.long_.len;
topicName.lenstring.data = topicId.data.long_.name; topicName.lenstring.data = topicId.data.long_.name;
uint16_t regackMsgId = client->getNextSnMsgId(); uint16_t regackMsgId = client->getNextSnMsgId();
regPacket->setREGISTER(id, regackMsgId, &topicName); regPacket->setREGISTER(id, regackMsgId, &topicName);
/* send REGISTER */ /* send REGISTER */
Event* evrg = new Event(); Event* evrg = new Event();
evrg->setClientSendEvent(client, regPacket); evrg->setClientSendEvent(client, regPacket);
_gateway->getClientSendQue()->post(evrg); _gateway->getClientSendQue()->post(evrg);
/* send PUBLISH */ /* send PUBLISH */
topicId.data.id = id; topicId.data.id = id;
snPacket->setPUBLISH((uint8_t) pub.header.bits.dup, (int) pub.header.bits.qos, snPacket->setPUBLISH((uint8_t) pub.header.bits.dup,
(uint8_t) pub.header.bits.retain, (uint16_t) pub.msgId, topicId, (uint8_t*) pub.payload, (int) pub.header.bits.qos,
pub.payloadlen); (uint8_t) pub.header.bits.retain, (uint16_t) pub.msgId,
client->getWaitREGACKPacketList()->setPacket(snPacket, regackMsgId); topicId, (uint8_t*) pub.payload, pub.payloadlen);
return; client->getWaitREGACKPacketList()->setPacket(snPacket,
} regackMsgId);
else return;
{ }
WRITELOG("%sMQTTGWPublishHandler Can't create a Topic.%s\n", ERRMSG_HEADER,ERRMSG_FOOTER); else
delete snPacket; {
return; WRITELOG("%sMQTTGWPublishHandler Can't create a Topic.%s\n",
} ERRMSG_HEADER, ERRMSG_FOOTER);
} delete snPacket;
} return;
}
}
}
snPacket->setPUBLISH((uint8_t) pub.header.bits.dup, (int) pub.header.bits.qos, (uint8_t) pub.header.bits.retain, snPacket->setPUBLISH((uint8_t) pub.header.bits.dup,
(uint16_t) pub.msgId, topicId, (uint8_t*) pub.payload, pub.payloadlen); (int) pub.header.bits.qos, (uint8_t) pub.header.bits.retain,
Event* ev1 = new Event(); (uint16_t) pub.msgId, topicId, (uint8_t*) pub.payload,
ev1->setClientSendEvent(client, snPacket); pub.payloadlen);
_gateway->getClientSendQue()->post(ev1); Event* ev1 = new Event();
ev1->setClientSendEvent(client, snPacket);
_gateway->getClientSendQue()->post(ev1);
} }
void MQTTGWPublishHandler::replyACK(Client* client, Publish* pub, int type) void MQTTGWPublishHandler::replyACK(Client* client, Publish* pub, int type)
{ {
MQTTGWPacket* pubAck = new MQTTGWPacket(); MQTTGWPacket* pubAck = new MQTTGWPacket();
pubAck->setAck(type, (uint16_t)pub->msgId); pubAck->setAck(type, (uint16_t) pub->msgId);
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, pubAck); ev1->setBrokerSendEvent(client, pubAck);
_gateway->getBrokerSendQue()->post(ev1); _gateway->getBrokerSendQue()->post(ev1);
} }
void MQTTGWPublishHandler::handlePuback(Client* client, MQTTGWPacket* packet) void MQTTGWPublishHandler::handlePuback(Client* client, MQTTGWPacket* packet)
{ {
Ack ack; Ack ack;
packet->getAck(&ack); packet->getAck(&ack);
TopicIdMapElement* topicId = client->getWaitedPubTopicId((uint16_t)ack.msgId); TopicIdMapElement* topicId = client->getWaitedPubTopicId(
if (topicId) (uint16_t) ack.msgId);
{ if (topicId)
MQTTSNPacket* mqttsnPacket = new MQTTSNPacket(); {
mqttsnPacket->setPUBACK(topicId->getTopicId(), (uint16_t)ack.msgId, 0); MQTTSNPacket* mqttsnPacket = new MQTTSNPacket();
mqttsnPacket->setPUBACK(topicId->getTopicId(), (uint16_t) ack.msgId, 0);
client->eraseWaitedPubTopicId((uint16_t)ack.msgId); client->eraseWaitedPubTopicId((uint16_t) ack.msgId);
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setClientSendEvent(client, mqttsnPacket); ev1->setClientSendEvent(client, mqttsnPacket);
_gateway->getClientSendQue()->post(ev1); _gateway->getClientSendQue()->post(ev1);
return; return;
} }
WRITELOG(" PUBACK from the Broker is invalid. PacketID : %04X ClientID : %s \n", (uint16_t)ack.msgId, client->getClientId()); WRITELOG(
" PUBACK from the Broker is invalid. PacketID : %04X ClientID : %s \n",
(uint16_t) ack.msgId, client->getClientId());
} }
void MQTTGWPublishHandler::handleAck(Client* client, MQTTGWPacket* packet, int type) void MQTTGWPublishHandler::handleAck(Client* client, MQTTGWPacket* packet,
int type)
{ {
Ack ack; Ack ack;
packet->getAck(&ack); packet->getAck(&ack);
if ( client->isActive() || client->isAwake() ) if (client->isActive() || client->isAwake())
{ {
MQTTSNPacket* mqttsnPacket = new MQTTSNPacket(); MQTTSNPacket* mqttsnPacket = new MQTTSNPacket();
if (type == PUBREC) if (type == PUBREC)
{ {
mqttsnPacket->setPUBREC((uint16_t) ack.msgId); mqttsnPacket->setPUBREC((uint16_t) ack.msgId);
} }
else if (type == PUBREL) else if (type == PUBREL)
{ {
mqttsnPacket->setPUBREL((uint16_t) ack.msgId); mqttsnPacket->setPUBREL((uint16_t) ack.msgId);
} }
else if (type == PUBCOMP) else if (type == PUBCOMP)
{ {
mqttsnPacket->setPUBCOMP((uint16_t) ack.msgId); mqttsnPacket->setPUBCOMP((uint16_t) ack.msgId);
} }
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setClientSendEvent(client, mqttsnPacket); ev1->setClientSendEvent(client, mqttsnPacket);
_gateway->getClientSendQue()->post(ev1); _gateway->getClientSendQue()->post(ev1);
} }
else if ( client->isSleep() ) else if (client->isSleep())
{ {
if (type == PUBREL) if (type == PUBREL)
{ {
MQTTGWPacket* pubComp = new MQTTGWPacket(); MQTTGWPacket* pubComp = new MQTTGWPacket();
pubComp->setAck(PUBCOMP, (uint16_t)ack.msgId); pubComp->setAck(PUBCOMP, (uint16_t) ack.msgId);
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, pubComp); ev1->setBrokerSendEvent(client, pubComp);
_gateway->getBrokerSendQue()->post(ev1); _gateway->getBrokerSendQue()->post(ev1);
} }
} }
} }
void MQTTGWPublishHandler::handleAggregatePuback(Client* client,
MQTTGWPacket* packet)
void MQTTGWPublishHandler::handleAggregatePuback(Client* client, MQTTGWPacket* packet)
{ {
uint16_t msgId = packet->getMsgId(); uint16_t msgId = packet->getMsgId();
uint16_t clientMsgId = 0; uint16_t clientMsgId = 0;
Client* newClient = _gateway->getAdapterManager()->convertClient(msgId, &clientMsgId); Client* newClient = _gateway->getAdapterManager()->convertClient(msgId,
if ( newClient != nullptr ) &clientMsgId);
{ if (newClient != nullptr)
packet->setMsgId((int)clientMsgId); {
handlePuback(newClient, packet); packet->setMsgId((int) clientMsgId);
} handlePuback(newClient, packet);
}
} }
void MQTTGWPublishHandler::handleAggregateAck(Client* client, MQTTGWPacket* packet, int type) void MQTTGWPublishHandler::handleAggregateAck(Client* client,
MQTTGWPacket* packet, int type)
{ {
uint16_t msgId = packet->getMsgId(); uint16_t msgId = packet->getMsgId();
uint16_t clientMsgId = 0; uint16_t clientMsgId = 0;
Client* newClient = _gateway->getAdapterManager()->convertClient(msgId, &clientMsgId); Client* newClient = _gateway->getAdapterManager()->convertClient(msgId,
if ( newClient != nullptr ) &clientMsgId);
{ if (newClient != nullptr)
packet->setMsgId((int)clientMsgId); {
handleAck(newClient, packet,type); packet->setMsgId((int) clientMsgId);
} handleAck(newClient, packet, type);
}
} }
void MQTTGWPublishHandler::handleAggregatePubrel(Client* client, MQTTGWPacket* packet) void MQTTGWPublishHandler::handleAggregatePubrel(Client* client,
MQTTGWPacket* packet)
{ {
Publish pub; Publish pub;
packet->getPUBLISH(&pub); packet->getPUBLISH(&pub);
replyACK(client, &pub, PUBCOMP); replyACK(client, &pub, PUBCOMP);
} }
void MQTTGWPublishHandler::handleAggregatePublish(Client* client, MQTTGWPacket* packet) void MQTTGWPublishHandler::handleAggregatePublish(Client* client,
MQTTGWPacket* packet)
{ {
Publish pub; Publish pub;
packet->getPUBLISH(&pub); packet->getPUBLISH(&pub);
string* topicName = new string(pub.topic, pub.topiclen); // topic deletes topicName when the topic is deleted
Topic topic = Topic(topicName, MQTTSN_TOPIC_TYPE_NORMAL);
string* topicName = new string(pub.topic, pub.topiclen); // topic deletes topicName when the topic is deleted // ToDo: need to refactor
Topic topic = Topic(topicName, MQTTSN_TOPIC_TYPE_NORMAL); ClientTopicElement* elm =
_gateway->getAdapterManager()->getAggregater()->getClientElement(
&topic);
// ToDo: need to refactor while (elm != nullptr)
ClientTopicElement* elm = _gateway->getAdapterManager()->getAggregater()->getClientElement(&topic); {
Client* devClient = elm->getClient();
MQTTGWPacket* msg = new MQTTGWPacket();
*msg = *packet;
while ( elm != nullptr ) if (msg->getType() == 0)
{ {
Client* devClient = elm->getClient(); WRITELOG(
MQTTGWPacket* msg = new MQTTGWPacket(); "%s MQTTGWPublishHandler::handleAggregatePublish can't allocate memories for Packet.%s\n",
*msg = *packet; ERRMSG_HEADER, ERRMSG_FOOTER);
delete msg;
break;
}
if ( msg->getType() == 0 ) Event* ev = new Event();
{ ev->setBrokerRecvEvent(devClient, msg);
WRITELOG("%s MQTTGWPublishHandler::handleAggregatePublish can't allocate memories for Packet.%s\n", ERRMSG_HEADER,ERRMSG_FOOTER); _gateway->getPacketEventQue()->post(ev);
delete msg;
break;
}
Event* ev = new Event(); elm = elm->getNextClientElement();
ev->setBrokerRecvEvent(devClient, msg); }
_gateway->getPacketEventQue()->post(ev);
elm = elm->getNextClientElement();
}
} }

24
MQTTSNGateway/src/MQTTGWPublishHandler.h
View File

@@ -26,25 +26,23 @@ namespace MQTTSNGW
class MQTTGWPublishHandler class MQTTGWPublishHandler
{ {
public: public:
MQTTGWPublishHandler(Gateway* gateway); MQTTGWPublishHandler(Gateway* gateway);
~MQTTGWPublishHandler(); ~MQTTGWPublishHandler();
void handlePublish(Client* client, MQTTGWPacket* packet); void handlePublish(Client* client, MQTTGWPacket* packet);
void handlePuback(Client* client, MQTTGWPacket* packet); void handlePuback(Client* client, MQTTGWPacket* packet);
void handleAck(Client* client, MQTTGWPacket* packet, int type); void handleAck(Client* client, MQTTGWPacket* packet, int type);
void handleAggregatePublish(Client* client, MQTTGWPacket* packet); void handleAggregatePublish(Client* client, MQTTGWPacket* packet);
void handleAggregatePuback(Client* client, MQTTGWPacket* packet); void handleAggregatePuback(Client* client, MQTTGWPacket* packet);
void handleAggregateAck(Client* client, MQTTGWPacket* packet, int type); void handleAggregateAck(Client* client, MQTTGWPacket* packet, int type);
void handleAggregatePubrel(Client* client, MQTTGWPacket* packet); void handleAggregatePubrel(Client* client, MQTTGWPacket* packet);
private: private:
void replyACK(Client* client, Publish* pub, int type); void replyACK(Client* client, Publish* pub, int type);
Gateway* _gateway; Gateway* _gateway;
}; };
} }
#endif /* MQTTGWPUBLISHHANDLER_H_ */ #endif /* MQTTGWPUBLISHHANDLER_H_ */

108
MQTTSNGateway/src/MQTTGWSubscribeHandler.cpp
View File

@@ -22,7 +22,7 @@ using namespace MQTTSNGW;
MQTTGWSubscribeHandler::MQTTGWSubscribeHandler(Gateway* gateway) MQTTGWSubscribeHandler::MQTTGWSubscribeHandler(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTGWSubscribeHandler::~MQTTGWSubscribeHandler() MQTTGWSubscribeHandler::~MQTTGWSubscribeHandler()
@@ -32,68 +32,74 @@ MQTTGWSubscribeHandler::~MQTTGWSubscribeHandler()
void MQTTGWSubscribeHandler::handleSuback(Client* client, MQTTGWPacket* packet) void MQTTGWSubscribeHandler::handleSuback(Client* client, MQTTGWPacket* packet)
{ {
uint16_t msgId; uint16_t msgId;
uint8_t rc; uint8_t rc;
uint8_t returnCode; uint8_t returnCode;
int qos = 0; int qos = 0;
packet->getSUBACK(&msgId, &rc); packet->getSUBACK(&msgId, &rc);
TopicIdMapElement* topicId = client->getWaitedSubTopicId(msgId); TopicIdMapElement* topicId = client->getWaitedSubTopicId(msgId);
if (topicId) if (topicId)
{ {
MQTTSNPacket* snPacket = new MQTTSNPacket(); MQTTSNPacket* snPacket = new MQTTSNPacket();
if (rc == 0x80) if (rc == 0x80)
{ {
returnCode = MQTTSN_RC_REJECTED_INVALID_TOPIC_ID; returnCode = MQTTSN_RC_REJECTED_INVALID_TOPIC_ID;
} }
else else
{ {
returnCode = MQTTSN_RC_ACCEPTED; returnCode = MQTTSN_RC_ACCEPTED;
qos = rc; qos = rc;
} }
snPacket->setSUBACK(qos, topicId->getTopicId(), msgId, returnCode); snPacket->setSUBACK(qos, topicId->getTopicId(), msgId, returnCode);
Event* evt = new Event(); Event* evt = new Event();
evt->setClientSendEvent(client, snPacket); evt->setClientSendEvent(client, snPacket);
_gateway->getClientSendQue()->post(evt); _gateway->getClientSendQue()->post(evt);
client->eraseWaitedSubTopicId(msgId); client->eraseWaitedSubTopicId(msgId);
} }
} }
void MQTTGWSubscribeHandler::handleUnsuback(Client* client, MQTTGWPacket* packet) void MQTTGWSubscribeHandler::handleUnsuback(Client* client,
MQTTGWPacket* packet)
{ {
Ack ack; Ack ack;
packet->getAck(&ack); packet->getAck(&ack);
MQTTSNPacket* snPacket = new MQTTSNPacket(); MQTTSNPacket* snPacket = new MQTTSNPacket();
snPacket->setUNSUBACK(ack.msgId); snPacket->setUNSUBACK(ack.msgId);
Event* evt = new Event(); Event* evt = new Event();
evt->setClientSendEvent(client, snPacket); evt->setClientSendEvent(client, snPacket);
_gateway->getClientSendQue()->post(evt); _gateway->getClientSendQue()->post(evt);
} }
void MQTTGWSubscribeHandler::handleAggregateSuback(Client* client, MQTTGWPacket* packet) void MQTTGWSubscribeHandler::handleAggregateSuback(Client* client,
MQTTGWPacket* packet)
{ {
uint16_t msgId = packet->getMsgId(); uint16_t msgId = packet->getMsgId();
uint16_t clientMsgId = 0; uint16_t clientMsgId = 0;
Client* newClient = _gateway->getAdapterManager()->getAggregater()->convertClient(msgId, &clientMsgId); Client* newClient =
if ( newClient != nullptr ) _gateway->getAdapterManager()->getAggregater()->convertClient(msgId,
{ &clientMsgId);
packet->setMsgId((int)clientMsgId); if (newClient != nullptr)
handleSuback(newClient, packet); {
} packet->setMsgId((int) clientMsgId);
handleSuback(newClient, packet);
}
} }
void MQTTGWSubscribeHandler::handleAggregateUnsuback(Client* client, MQTTGWPacket* packet) void MQTTGWSubscribeHandler::handleAggregateUnsuback(Client* client,
MQTTGWPacket* packet)
{ {
uint16_t msgId = packet->getMsgId(); uint16_t msgId = packet->getMsgId();
uint16_t clientMsgId = 0; uint16_t clientMsgId = 0;
Client* newClient = _gateway->getAdapterManager()->getAggregater()->convertClient(msgId, &clientMsgId); Client* newClient =
if ( newClient != nullptr ) _gateway->getAdapterManager()->getAggregater()->convertClient(msgId,
{ &clientMsgId);
packet->setMsgId((int)clientMsgId); if (newClient != nullptr)
handleUnsuback(newClient, packet); {
} packet->setMsgId((int) clientMsgId);
handleUnsuback(newClient, packet);
}
} }

14
MQTTSNGateway/src/MQTTGWSubscribeHandler.h
View File

@@ -27,15 +27,15 @@ namespace MQTTSNGW
class MQTTGWSubscribeHandler class MQTTGWSubscribeHandler
{ {
public: public:
MQTTGWSubscribeHandler(Gateway* gateway); MQTTGWSubscribeHandler(Gateway* gateway);
~MQTTGWSubscribeHandler(); ~MQTTGWSubscribeHandler();
void handleSuback(Client* clnode, MQTTGWPacket* packet); void handleSuback(Client* clnode, MQTTGWPacket* packet);
void handleUnsuback(Client* clnode, MQTTGWPacket* packet); void handleUnsuback(Client* clnode, MQTTGWPacket* packet);
void handleAggregateSuback(Client* client, MQTTGWPacket* packet); void handleAggregateSuback(Client* client, MQTTGWPacket* packet);
void handleAggregateUnsuback(Client* client, MQTTGWPacket* packet); void handleAggregateUnsuback(Client* client, MQTTGWPacket* packet);
private: private:
Gateway* _gateway; Gateway* _gateway;
}; };
} }

230
MQTTSNGateway/src/MQTTSNAggregateConnectionHandler.cpp
View File

@@ -26,9 +26,10 @@ using namespace MQTTSNGW;
/*===================================== /*=====================================
Class MQTTSNAggregateConnectionHandler Class MQTTSNAggregateConnectionHandler
=====================================*/ =====================================*/
MQTTSNAggregateConnectionHandler::MQTTSNAggregateConnectionHandler(Gateway* gateway) MQTTSNAggregateConnectionHandler::MQTTSNAggregateConnectionHandler(
Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTSNAggregateConnectionHandler::~MQTTSNAggregateConnectionHandler() MQTTSNAggregateConnectionHandler::~MQTTSNAggregateConnectionHandler()
@@ -36,130 +37,131 @@ MQTTSNAggregateConnectionHandler::~MQTTSNAggregateConnectionHandler()
} }
/* /*
* CONNECT * CONNECT
*/ */
void MQTTSNAggregateConnectionHandler::handleConnect(Client* client, MQTTSNPacket* packet) void MQTTSNAggregateConnectionHandler::handleConnect(Client* client,
MQTTSNPacket* packet)
{ {
MQTTSNPacket_connectData data; MQTTSNPacket_connectData data;
if ( packet->getCONNECT(&data) == 0 ) if (packet->getCONNECT(&data) == 0)
{ {
return; return;
} }
/* return CONNACK when the client is sleeping */ /* return CONNACK when the client is sleeping */
if ( client->isSleep() || client->isAwake() ) if (client->isSleep() || client->isAwake())
{ {
MQTTSNPacket* packet = new MQTTSNPacket(); MQTTSNPacket* packet = new MQTTSNPacket();
packet->setCONNACK(MQTTSN_RC_ACCEPTED); packet->setCONNACK(MQTTSN_RC_ACCEPTED);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientSendEvent(client, packet); ev->setClientSendEvent(client, packet);
_gateway->getClientSendQue()->post(ev); _gateway->getClientSendQue()->post(ev);
sendStoredPublish(client); sendStoredPublish(client);
return; return;
} }
//* clear ConnectData of Client */ //* clear ConnectData of Client */
Connect* connectData = client->getConnectData(); Connect* connectData = client->getConnectData();
memset(connectData, 0, sizeof(Connect)); memset(connectData, 0, sizeof(Connect));
client->disconnected(); client->disconnected();
Topics* topics = client->getTopics(); Topics* topics = client->getTopics();
/* CONNECT was not sent yet. prepare Connect data */ /* CONNECT was not sent yet. prepare Connect data */
client->setSessionStatus(false);
if (data.cleansession)
{
/* reset the table of msgNo and TopicId pare */
client->clearWaitedPubTopicId();
client->clearWaitedSubTopicId();
client->setSessionStatus(false); /* renew the TopicList */
if (data.cleansession) if (topics)
{ {
/* reset the table of msgNo and TopicId pare */ Topic* tp = topics->getFirstTopic();
client->clearWaitedPubTopicId(); while (tp != nullptr)
client->clearWaitedSubTopicId(); {
if (tp->getType() == MQTTSN_TOPIC_TYPE_NORMAL)
{
_gateway->getAdapterManager()->getAggregater()->removeAggregateTopic(
tp, client);
}
tp = topics->getNextTopic(tp);
}
topics->eraseNormal();
}
client->setSessionStatus(true);
}
/* renew the TopicList */ if (data.willFlag)
if (topics) {
{ /* create & send WILLTOPICREQ message to the client */
Topic* tp = topics->getFirstTopic(); MQTTSNPacket* reqTopic = new MQTTSNPacket();
while( tp != nullptr ) reqTopic->setWILLTOPICREQ();
{ Event* evwr = new Event();
if ( tp->getType() == MQTTSN_TOPIC_TYPE_NORMAL ) evwr->setClientSendEvent(client, reqTopic);
{
_gateway->getAdapterManager()->getAggregater()->removeAggregateTopic(tp, client);
}
tp = topics->getNextTopic(tp);
}
topics->eraseNormal();
}
client->setSessionStatus(true);
}
if (data.willFlag) /* Send WILLTOPICREQ to the client */
{ _gateway->getClientSendQue()->post(evwr);
/* create & send WILLTOPICREQ message to the client */ }
MQTTSNPacket* reqTopic = new MQTTSNPacket(); else
reqTopic->setWILLTOPICREQ(); {
Event* evwr = new Event(); /* create CONNACK & send it to the client */
evwr->setClientSendEvent(client, reqTopic); MQTTSNPacket* packet = new MQTTSNPacket();
packet->setCONNACK(MQTTSN_RC_ACCEPTED);
/* Send WILLTOPICREQ to the client */ Event* ev = new Event();
_gateway->getClientSendQue()->post(evwr); ev->setClientSendEvent(client, packet);
} _gateway->getClientSendQue()->post(ev);
else client->connackSended(MQTTSN_RC_ACCEPTED);
{ sendStoredPublish(client);
/* create CONNACK & send it to the client */ return;
MQTTSNPacket* packet = new MQTTSNPacket(); }
packet->setCONNACK(MQTTSN_RC_ACCEPTED);
Event* ev = new Event();
ev->setClientSendEvent(client, packet);
_gateway->getClientSendQue()->post(ev);
client->connackSended(MQTTSN_RC_ACCEPTED);
sendStoredPublish(client);
return;
}
} }
/* /*
* WILLMSG * WILLMSG
*/ */
void MQTTSNAggregateConnectionHandler::handleWillmsg(Client* client, MQTTSNPacket* packet) void MQTTSNAggregateConnectionHandler::handleWillmsg(Client* client,
MQTTSNPacket* packet)
{ {
if ( !client->isWaitWillMsg() ) if (!client->isWaitWillMsg())
{ {
DEBUGLOG(" MQTTSNConnectionHandler::handleWillmsg WaitWillMsgFlg is off.\n"); DEBUGLOG(" MQTTSNConnectionHandler::handleWillmsg WaitWillMsgFlg is off.\n");
return; return;
} }
MQTTSNString willmsg = MQTTSNString_initializer; MQTTSNString willmsg = MQTTSNString_initializer;
//Connect* connectData = client->getConnectData(); //Connect* connectData = client->getConnectData();
if( client->isConnectSendable() ) if (client->isConnectSendable())
{ {
/* save WillMsg in the client */ /* save WillMsg in the client */
if ( packet->getWILLMSG(&willmsg) == 0 ) if (packet->getWILLMSG(&willmsg) == 0)
{ {
return; return;
} }
client->setWillMsg(willmsg); client->setWillMsg(willmsg);
/* Send CONNACK to the client */ /* Send CONNACK to the client */
MQTTSNPacket* packet = new MQTTSNPacket(); MQTTSNPacket* packet = new MQTTSNPacket();
packet->setCONNACK(MQTTSN_RC_ACCEPTED); packet->setCONNACK(MQTTSN_RC_ACCEPTED);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientSendEvent(client, packet); ev->setClientSendEvent(client, packet);
_gateway->getClientSendQue()->post(ev); _gateway->getClientSendQue()->post(ev);
sendStoredPublish(client); sendStoredPublish(client);
return; return;
} }
} }
/* /*
* DISCONNECT * DISCONNECT
*/ */
void MQTTSNAggregateConnectionHandler::handleDisconnect(Client* client, MQTTSNPacket* packet) void MQTTSNAggregateConnectionHandler::handleDisconnect(Client* client,
MQTTSNPacket* packet)
{ {
MQTTSNPacket* snMsg = new MQTTSNPacket(); MQTTSNPacket* snMsg = new MQTTSNPacket();
snMsg->setDISCONNECT(0); snMsg->setDISCONNECT(0);
@@ -171,33 +173,35 @@ void MQTTSNAggregateConnectionHandler::handleDisconnect(Client* client, MQTTSNPa
/* /*
* PINGREQ * PINGREQ
*/ */
void MQTTSNAggregateConnectionHandler::handlePingreq(Client* client, MQTTSNPacket* packet) void MQTTSNAggregateConnectionHandler::handlePingreq(Client* client,
MQTTSNPacket* packet)
{ {
if ( ( client->isSleep() || client->isAwake() ) && client->getClientSleepPacket() ) if ((client->isSleep() || client->isAwake())
{ && client->getClientSleepPacket())
sendStoredPublish(client); {
client->holdPingRequest(); sendStoredPublish(client);
} client->holdPingRequest();
}
/* create and send PINGRESP to the PacketHandler */ /* create and send PINGRESP to the PacketHandler */
client->resetPingRequest(); client->resetPingRequest();
MQTTGWPacket* pingresp = new MQTTGWPacket(); MQTTGWPacket* pingresp = new MQTTGWPacket();
pingresp->setHeader(PINGRESP); pingresp->setHeader(PINGRESP);
Event* evt = new Event(); Event* evt = new Event();
evt->setBrokerRecvEvent(client, pingresp); evt->setBrokerRecvEvent(client, pingresp);
_gateway->getPacketEventQue()->post(evt); _gateway->getPacketEventQue()->post(evt);
} }
void MQTTSNAggregateConnectionHandler::sendStoredPublish(Client* client) void MQTTSNAggregateConnectionHandler::sendStoredPublish(Client* client)
{ {
MQTTGWPacket* msg = nullptr; MQTTGWPacket* msg = nullptr;
while ( ( msg = client->getClientSleepPacket() ) != nullptr ) while ((msg = client->getClientSleepPacket()) != nullptr)
{ {
client->deleteFirstClientSleepPacket(); // pop the que to delete element. client->deleteFirstClientSleepPacket(); // pop the que to delete element.
Event* ev = new Event(); Event* ev = new Event();
ev->setBrokerRecvEvent(client, msg); ev->setBrokerRecvEvent(client, msg);

16
MQTTSNGateway/src/MQTTSNAggregateConnectionHandler.h
View File

@@ -28,18 +28,18 @@ class MQTTSNPacket;
class MQTTSNAggregateConnectionHandler class MQTTSNAggregateConnectionHandler
{ {
public: public:
MQTTSNAggregateConnectionHandler(Gateway* gateway); MQTTSNAggregateConnectionHandler(Gateway* gateway);
~MQTTSNAggregateConnectionHandler(void); ~MQTTSNAggregateConnectionHandler(void);
void handleConnect(Client* client, MQTTSNPacket* packet); void handleConnect(Client* client, MQTTSNPacket* packet);
void handleWillmsg(Client* client, MQTTSNPacket* packet); void handleWillmsg(Client* client, MQTTSNPacket* packet);
void handleDisconnect(Client* client, MQTTSNPacket* packet); void handleDisconnect(Client* client, MQTTSNPacket* packet);
void handlePingreq(Client* client, MQTTSNPacket* packet); void handlePingreq(Client* client, MQTTSNPacket* packet);
private: private:
void sendStoredPublish(Client* client); void sendStoredPublish(Client* client);
Gateway* _gateway; Gateway* _gateway;
}; };
} }

257
MQTTSNGateway/src/MQTTSNGWAdapter.cpp
View File

@@ -24,116 +24,115 @@
#include <string.h> #include <string.h>
using namespace MQTTSNGW; using namespace MQTTSNGW;
/*===================================== /*=====================================
Class Adapter Class Adapter
=====================================*/ =====================================*/
Adapter:: Adapter(Gateway* gw) Adapter::Adapter(Gateway* gw)
{ {
_gateway = gw; _gateway = gw;
_proxy = new Proxy(gw); _proxy = new Proxy(gw);
_proxySecure = new Proxy(gw); _proxySecure = new Proxy(gw);
} }
Adapter::~Adapter(void) Adapter::~Adapter(void)
{ {
if ( _proxy ) if (_proxy)
{ {
delete _proxy; delete _proxy;
} }
if ( _proxySecure ) if (_proxySecure)
{ {
delete _proxySecure; delete _proxySecure;
} }
} }
void Adapter::setup(const char* adpterName, AdapterType adapterType) void Adapter::setup(const char* adpterName, AdapterType adapterType)
{ {
_isSecure = false; _isSecure = false;
if ( _gateway->hasSecureConnection() ) if (_gateway->hasSecureConnection())
{ {
_isSecure = true; _isSecure = true;
} }
MQTTSNString id = MQTTSNString_initializer; MQTTSNString id = MQTTSNString_initializer;
MQTTSNString idSecure = MQTTSNString_initializer; MQTTSNString idSecure = MQTTSNString_initializer;
string name = string(adpterName); string name = string(adpterName);
id.cstring = const_cast<char*>(name.c_str()); id.cstring = const_cast<char*>(name.c_str());
string nameSecure = string(adpterName) + "-S"; string nameSecure = string(adpterName) + "-S";
idSecure.cstring = const_cast<char*>(nameSecure.c_str()); idSecure.cstring = const_cast<char*>(nameSecure.c_str());
Client* client = _gateway->getClientList()->createClient(0, &id, true, false, TRANSPEARENT_TYPE); Client* client = _gateway->getClientList()->createClient(0, &id, true,
setClient(client, false); false, TRANSPEARENT_TYPE);
client->setAdapterType(adapterType); setClient(client, false);
client->setAdapterType(adapterType);
client = _gateway->getClientList()->createClient(0, &idSecure, true, true, TRANSPEARENT_TYPE); client = _gateway->getClientList()->createClient(0, &idSecure, true, true,
setClient(client, true); TRANSPEARENT_TYPE);
client->setAdapterType(adapterType); setClient(client, true);
client->setAdapterType(adapterType);
} }
Client* Adapter::getClient(SensorNetAddress* addr) Client* Adapter::getClient(SensorNetAddress* addr)
{ {
Client* client = _gateway->getClientList()->getClient(addr); Client* client = _gateway->getClientList()->getClient(addr);
if ( !client ) if (!client)
{
return nullptr;
}
else if ( client->isQoSm1() )
{
return client;
}
else
{
return nullptr;
}
}
const char* Adapter::getClientId(SensorNetAddress* addr)
{
Client* client = getClient(addr);
if ( !client )
{ {
return nullptr; return nullptr;
} }
else if ( client->isQoSm1() ) else if (client->isQoSm1())
{ {
return client->getClientId(); return client;
} }
else else
{ {
return nullptr; return nullptr;
}
}
const char* Adapter::getClientId(SensorNetAddress* addr)
{
Client* client = getClient(addr);
if (!client)
{
return nullptr;
}
else if (client->isQoSm1())
{
return client->getClientId();
}
else
{
return nullptr;
} }
} }
bool Adapter::isSecure(SensorNetAddress* addr) bool Adapter::isSecure(SensorNetAddress* addr)
{ {
Client* client = getClient(addr); Client* client = getClient(addr);
if ( !client ) if (!client)
{ {
return false; return false;
} }
else if ( client->isSecureNetwork() ) else if (client->isSecureNetwork())
{ {
return true; return true;
} }
else else
{ {
return false; return false;
} }
} }
bool Adapter::isSecure(void) bool Adapter::isSecure(void)
{ {
return _isSecure; return _isSecure;
} }
void Adapter::setClient(Client* client, bool secure) void Adapter::setClient(Client* client, bool secure)
{ {
if ( secure ) if (secure)
{ {
_clientSecure = client; _clientSecure = client;
} }
@@ -157,7 +156,7 @@ void Adapter::checkConnection(void)
{ {
_proxy->checkConnection(_client); _proxy->checkConnection(_client);
if ( _isSecure ) if (_isSecure)
{ {
_proxySecure->checkConnection(_clientSecure); _proxySecure->checkConnection(_clientSecure);
} }
@@ -166,15 +165,17 @@ void Adapter::checkConnection(void)
void Adapter::send(MQTTSNPacket* packet, Client* client) void Adapter::send(MQTTSNPacket* packet, Client* client)
{ {
Proxy* proxy = _proxy; Proxy* proxy = _proxy;
if ( client->isSecureNetwork() && !_isSecure ) if (client->isSecureNetwork() && !_isSecure)
{ {
if ( _isSecure ) if (_isSecure)
{ {
proxy = _proxySecure; proxy = _proxySecure;
} }
else else
{ {
WRITELOG("%s %s No Secure connections %s 's packet is discarded.%s\n", ERRMSG_HEADER, client->getClientId() , ERRMSG_FOOTER); WRITELOG(
"%s %s No Secure connections %s 's packet is discarded.%s\n",
ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER);
return; return;
} }
} }
@@ -185,13 +186,13 @@ void Adapter::send(MQTTSNPacket* packet, Client* client)
void Adapter::resetPingTimer(bool secure) void Adapter::resetPingTimer(bool secure)
{ {
if ( secure ) if (secure)
{ {
_proxySecure->resetPingTimer(); _proxySecure->resetPingTimer();
} }
else else
{ {
_proxy->resetPingTimer(); _proxy->resetPingTimer();
} }
} }
@@ -202,48 +203,48 @@ bool Adapter::isActive(void)
void Adapter::savePacket(Client* client, MQTTSNPacket* packet) void Adapter::savePacket(Client* client, MQTTSNPacket* packet)
{ {
if ( client->isSecureNetwork()) if (client->isSecureNetwork())
{ {
_proxySecure->savePacket(client, packet); _proxySecure->savePacket(client, packet);
} }
else else
{ {
_proxy->savePacket(client, packet); _proxy->savePacket(client, packet);
} }
} }
Client* Adapter::getAdapterClient(Client* client) Client* Adapter::getAdapterClient(Client* client)
{ {
if ( client->isSecureNetwork() ) if (client->isSecureNetwork())
{ {
return _clientSecure; return _clientSecure;
} }
else else
{ {
return _client; return _client;
} }
} }
/*===================================== /*=====================================
Class Proxy Class Proxy
=====================================*/ =====================================*/
Proxy::Proxy(Gateway* gw) Proxy::Proxy(Gateway* gw)
{ {
_gateway = gw; _gateway = gw;
_suspendedPacketEventQue = new EventQue(); _suspendedPacketEventQue = new EventQue();
} }
Proxy::~Proxy(void) Proxy::~Proxy(void)
{ {
if ( _suspendedPacketEventQue ) if (_suspendedPacketEventQue)
{ {
delete _suspendedPacketEventQue; delete _suspendedPacketEventQue;
} }
} }
void Proxy::checkConnection(Client* client) void Proxy::checkConnection(Client* client)
{ {
if ( client->isDisconnect() || ( client->isConnecting() && _responseTimer.isTimeup()) ) if (client->isDisconnect()
|| (client->isConnecting() && _responseTimer.isTimeup()))
{ {
client->connectSended(); client->connectSended();
_responseTimer.start(PROXY_RESPONSE_DURATION * 1000UL); _responseTimer.start(PROXY_RESPONSE_DURATION * 1000UL);
@@ -257,26 +258,26 @@ void Proxy::checkConnection(Client* client)
ev->setClientRecvEvent(client, packet); ev->setClientRecvEvent(client, packet);
_gateway->getPacketEventQue()->post(ev); _gateway->getPacketEventQue()->post(ev);
} }
else if ( (client->isActive() && _keepAliveTimer.isTimeup() ) || (_isWaitingResp && _responseTimer.isTimeup() ) ) else if ((client->isActive() && _keepAliveTimer.isTimeup())
|| (_isWaitingResp && _responseTimer.isTimeup()))
{ {
MQTTSNPacket* packet = new MQTTSNPacket(); MQTTSNPacket* packet = new MQTTSNPacket();
MQTTSNString clientId = MQTTSNString_initializer; MQTTSNString clientId = MQTTSNString_initializer;
packet->setPINGREQ(&clientId); packet->setPINGREQ(&clientId);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientRecvEvent(client, packet); ev->setClientRecvEvent(client, packet);
_gateway->getPacketEventQue()->post(ev); _gateway->getPacketEventQue()->post(ev);
_responseTimer.start(PROXY_RESPONSE_DURATION * 1000UL); _responseTimer.start(PROXY_RESPONSE_DURATION * 1000UL);
_isWaitingResp = true; _isWaitingResp = true;
if ( ++_retryCnt > PROXY_MAX_RETRY_CNT ) if (++_retryCnt > PROXY_MAX_RETRY_CNT)
{ {
client->disconnected(); client->disconnected();
} }
resetPingTimer(); resetPingTimer();
} }
} }
void Proxy::resetPingTimer(void) void Proxy::resetPingTimer(void)
{ {
_keepAliveTimer.start(PROXY_KEEPALIVE_DURATION * 1000UL); _keepAliveTimer.start(PROXY_KEEPALIVE_DURATION * 1000UL);
@@ -284,24 +285,24 @@ void Proxy::resetPingTimer(void)
void Proxy::recv(MQTTSNPacket* packet, Client* client) void Proxy::recv(MQTTSNPacket* packet, Client* client)
{ {
if ( packet->getType() == MQTTSN_CONNACK ) if (packet->getType() == MQTTSN_CONNACK)
{ {
if ( packet->isAccepted() ) if (packet->isAccepted())
{ {
_responseTimer.stop(); _responseTimer.stop();
_retryCnt = 0; _retryCnt = 0;
resetPingTimer(); resetPingTimer();
sendSuspendedPacket(); sendSuspendedPacket();
} }
} }
else if ( packet->getType() == MQTTSN_PINGRESP ) else if (packet->getType() == MQTTSN_PINGRESP)
{ {
_isWaitingResp = false; _isWaitingResp = false;
_responseTimer.stop(); _responseTimer.stop();
_retryCnt = 0; _retryCnt = 0;
resetPingTimer(); resetPingTimer();
} }
else if ( packet->getType() == MQTTSN_DISCONNECT ) else if (packet->getType() == MQTTSN_DISCONNECT)
{ {
// blank // blank
} }
@@ -309,18 +310,18 @@ void Proxy::recv(MQTTSNPacket* packet, Client* client)
void Proxy::savePacket(Client* client, MQTTSNPacket* packet) void Proxy::savePacket(Client* client, MQTTSNPacket* packet)
{ {
MQTTSNPacket* pk = new MQTTSNPacket(*packet); MQTTSNPacket* pk = new MQTTSNPacket(*packet);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientRecvEvent(client, pk); ev->setClientRecvEvent(client, pk);
_suspendedPacketEventQue->post(ev); _suspendedPacketEventQue->post(ev);
} }
void Proxy::sendSuspendedPacket(void) void Proxy::sendSuspendedPacket(void)
{ {
while ( _suspendedPacketEventQue->size() ) while (_suspendedPacketEventQue->size())
{ {
Event* ev = _suspendedPacketEventQue->wait(); Event* ev = _suspendedPacketEventQue->wait();
_gateway->getPacketEventQue()->post(ev); _gateway->getPacketEventQue()->post(ev);
} }
} }

39
MQTTSNGateway/src/MQTTSNGWAdapter.h
View File

@@ -31,17 +31,18 @@ class EventQue;
class Timer; class Timer;
/* When you add a new type, Client::setAdapterType() and Client::isAdapter() functions must be modified. */ /* When you add a new type, Client::setAdapterType() and Client::isAdapter() functions must be modified. */
typedef enum{ typedef enum
Atype_QoSm1Proxy, Atype_Aggregater {
}AdapterType; Atype_QoSm1Proxy, Atype_Aggregater
} AdapterType;
/*===================================== /*=====================================
Class Adapter Class Adapter
=====================================*/ =====================================*/
class Adapter class Adapter
{ {
public: public:
Adapter(Gateway* gw); Adapter(Gateway* gw);
~Adapter(void); ~Adapter(void);
void setup(const char* adpterName, AdapterType adapterType); void setup(const char* adpterName, AdapterType adapterType);
@@ -60,18 +61,17 @@ public:
void savePacket(Client* client, MQTTSNPacket* packet); void savePacket(Client* client, MQTTSNPacket* packet);
private: private:
Gateway* _gateway {nullptr}; Gateway* _gateway { nullptr };
Proxy* _proxy {nullptr}; Proxy* _proxy { nullptr };
Proxy* _proxySecure {nullptr}; Proxy* _proxySecure { nullptr };
Client* _client {nullptr}; Client* _client { nullptr };
Client* _clientSecure {nullptr}; Client* _clientSecure { nullptr };
bool _isActive {false}; bool _isActive { false };
bool _isSecure{false}; bool _isSecure { false };
}; };
/*===================================== /*=====================================
Class Proxy Class Proxy
=====================================*/ =====================================*/
class Proxy class Proxy
{ {
@@ -88,11 +88,12 @@ public:
private: private:
void sendSuspendedPacket(void); void sendSuspendedPacket(void);
Gateway* _gateway; Gateway* _gateway;
EventQue* _suspendedPacketEventQue {nullptr}; EventQue* _suspendedPacketEventQue
Timer _keepAliveTimer; { nullptr };
Timer _responseTimer; Timer _keepAliveTimer;
bool _isWaitingResp {false}; Timer _responseTimer;
int _retryCnt {0}; bool _isWaitingResp { false };
int _retryCnt { 0 };
}; };
} }

205
MQTTSNGateway/src/MQTTSNGWAdapterManager.cpp
View File

@@ -33,42 +33,42 @@ char* currentDateTime(void);
=====================================*/ =====================================*/
AdapterManager::AdapterManager(Gateway* gw) AdapterManager::AdapterManager(Gateway* gw)
{ {
_gateway = gw; _gateway = gw;
_forwarders = new ForwarderList(); _forwarders = new ForwarderList();
_qosm1Proxy = new QoSm1Proxy(gw); _qosm1Proxy = new QoSm1Proxy(gw);
_aggregater = new Aggregater(gw); _aggregater = new Aggregater(gw);
} }
void AdapterManager::initialize(char* gwName, bool aggregate, bool forwarder,
void AdapterManager::initialize(char* gwName, bool aggregate, bool forwarder, bool qosM1) bool qosM1)
{ {
if ( aggregate ) if (aggregate)
{ {
_aggregater->initialize(gwName); _aggregater->initialize(gwName);
} }
if ( qosM1 ) if (qosM1)
{ {
_qosm1Proxy->initialize(gwName); _qosm1Proxy->initialize(gwName);
} }
if ( forwarder ) if (forwarder)
{ {
_forwarders->initialize(_gateway); _forwarders->initialize(_gateway);
} }
} }
AdapterManager::~AdapterManager(void) AdapterManager::~AdapterManager(void)
{ {
if ( _forwarders ) if (_forwarders)
{ {
delete _forwarders; delete _forwarders;
} }
if ( _qosm1Proxy ) if (_qosm1Proxy)
{ {
delete _qosm1Proxy; delete _qosm1Proxy;
} }
if ( _aggregater ) if (_aggregater)
{ {
delete _aggregater; delete _aggregater;
} }
@@ -91,119 +91,124 @@ Aggregater* AdapterManager::getAggregater(void)
bool AdapterManager::isAggregatedClient(Client* client) bool AdapterManager::isAggregatedClient(Client* client)
{ {
if ( !_aggregater->isActive() || client->isQoSm1() || client->isAggregater() || client->isQoSm1Proxy()) if (!_aggregater->isActive() || client->isQoSm1() || client->isAggregater()
{ || client->isQoSm1Proxy())
return false; {
} return false;
else }
{ else
return true; {
} return true;
}
} }
Client* AdapterManager::getClient(Client* client) Client* AdapterManager::getClient(Client* client)
{ {
bool secure = client->isSecureNetwork(); bool secure = client->isSecureNetwork();
Client* newClient = client; Client* newClient = client;
if ( client->isQoSm1() ) if (client->isQoSm1())
{ {
newClient = _qosm1Proxy->getAdapterClient(client); newClient = _qosm1Proxy->getAdapterClient(client);
_qosm1Proxy->resetPingTimer(secure); _qosm1Proxy->resetPingTimer(secure);
} }
else if ( client->isAggregated() ) else if (client->isAggregated())
{ {
newClient = _aggregater->getAdapterClient(client); newClient = _aggregater->getAdapterClient(client);
_aggregater->resetPingTimer(secure); _aggregater->resetPingTimer(secure);
} }
else if ( client->isQoSm1Proxy() ) else if (client->isQoSm1Proxy())
{ {
_qosm1Proxy->resetPingTimer(secure); _qosm1Proxy->resetPingTimer(secure);
} }
else if ( client->isAggregater() ) else if (client->isAggregater())
{ {
_aggregater->resetPingTimer(secure); _aggregater->resetPingTimer(secure);
} }
return newClient; return newClient;
} }
int AdapterManager::unicastToClient(Client* client, MQTTSNPacket* packet, ClientSendTask* task) int AdapterManager::unicastToClient(Client* client, MQTTSNPacket* packet,
ClientSendTask* task)
{ {
char pbuf[SIZE_OF_LOG_PACKET * 3]; char pbuf[SIZE_OF_LOG_PACKET * 3];
Forwarder* fwd = client->getForwarder(); Forwarder* fwd = client->getForwarder();
int rc = 0; int rc = 0;
if ( fwd ) if (fwd)
{ {
MQTTSNGWEncapsulatedPacket encap(packet); MQTTSNGWEncapsulatedPacket encap(packet);
WirelessNodeId* wnId = fwd->getWirelessNodeId(client); WirelessNodeId* wnId = fwd->getWirelessNodeId(client);
encap.setWirelessNodeId(wnId); encap.setWirelessNodeId(wnId);
task->log(client, packet); task->log(client, packet);
WRITELOG(FORMAT_Y_W_G, currentDateTime(), encap.getName(), RIGHTARROW, fwd->getId(), encap.print(pbuf)); WRITELOG(FORMAT_Y_W_G, currentDateTime(), encap.getName(), RIGHTARROW,
rc = encap.unicast(_gateway->getSensorNetwork(),fwd->getSensorNetAddr()); fwd->getId(), encap.print(pbuf));
} rc = encap.unicast(_gateway->getSensorNetwork(),
else fwd->getSensorNetAddr());
{ }
task->log(client, packet); else
if ( client->isQoSm1Proxy() ) {
{ task->log(client, packet);
_qosm1Proxy->send(packet, client); if (client->isQoSm1Proxy())
} {
else if ( client->isAggregater() ) _qosm1Proxy->send(packet, client);
{ }
_aggregater->send(packet, client); else if (client->isAggregater())
} {
else _aggregater->send(packet, client);
{ }
rc = packet->unicast(_gateway->getSensorNetwork(), client->getSensorNetAddress()); else
} {
} rc = packet->unicast(_gateway->getSensorNetwork(),
return rc; client->getSensorNetAddress());
}
}
return rc;
} }
void AdapterManager::checkConnection(void) void AdapterManager::checkConnection(void)
{ {
if ( _aggregater->isActive()) if (_aggregater->isActive())
{ {
_aggregater->checkConnection(); _aggregater->checkConnection();
} }
if ( _qosm1Proxy->isActive()) if (_qosm1Proxy->isActive())
{ {
_qosm1Proxy->checkConnection(); _qosm1Proxy->checkConnection();
} }
} }
Client* AdapterManager::convertClient(uint16_t msgId, uint16_t* clientMsgId) Client* AdapterManager::convertClient(uint16_t msgId, uint16_t* clientMsgId)
{ {
return _aggregater->convertClient(msgId, clientMsgId); return _aggregater->convertClient(msgId, clientMsgId);
} }
bool AdapterManager::isAggregaterActive(void) bool AdapterManager::isAggregaterActive(void)
{ {
return _aggregater->isActive(); return _aggregater->isActive();
} }
/* /*
AggregateTopicElement* AdapterManager::findTopic(Topic* topic) AggregateTopicElement* AdapterManager::findTopic(Topic* topic)
{ {
return _aggregater->findTopic(topic); return _aggregater->findTopic(topic);
} }
AggregateTopicElement* AdapterManager::addAggregateTopic(Topic* topic, Client* client) AggregateTopicElement* AdapterManager::addAggregateTopic(Topic* topic, Client* client)
{ {
return _aggregater->addAggregateTopic(topic, client); return _aggregater->addAggregateTopic(topic, client);
} }
void AdapterManager::removeAggregateTopic(Topic* topic, Client* client) void AdapterManager::removeAggregateTopic(Topic* topic, Client* client)
{ {
//_aggregater->removeAggregateTopic(topic, client); //_aggregater->removeAggregateTopic(topic, client);
} }
void AdapterManager::removeAggregateTopicList(Topics* topics, Client* client) void AdapterManager::removeAggregateTopicList(Topics* topics, Client* client)
{ {
} }
*/ */

18
MQTTSNGateway/src/MQTTSNGWAdapterManager.h
View File

@@ -33,12 +33,12 @@ class ClientRecvTask;
class ClientSendTask; class ClientSendTask;
/*===================================== /*=====================================
Class AdapterManager Class AdapterManager
=====================================*/ =====================================*/
class AdapterManager class AdapterManager
{ {
public: public:
AdapterManager(Gateway* gw); AdapterManager(Gateway* gw);
~AdapterManager(void); ~AdapterManager(void);
void initialize(char* gwName, bool aggregater, bool fowarder, bool qosM1); void initialize(char* gwName, bool aggregater, bool fowarder, bool qosM1);
ForwarderList* getForwarderList(void); ForwarderList* getForwarderList(void);
@@ -49,18 +49,16 @@ public:
bool isAggregatedClient(Client* client); bool isAggregatedClient(Client* client);
Client* getClient(Client* client); Client* getClient(Client* client);
Client* convertClient(uint16_t msgId, uint16_t* clientMsgId); Client* convertClient(uint16_t msgId, uint16_t* clientMsgId);
int unicastToClient(Client* client, MQTTSNPacket* packet, ClientSendTask* task); int unicastToClient(Client* client, MQTTSNPacket* packet,
ClientSendTask* task);
bool isAggregaterActive(void); bool isAggregaterActive(void);
private: private:
Gateway* _gateway {nullptr}; Gateway* _gateway { nullptr };
ForwarderList* _forwarders {nullptr}; ForwarderList* _forwarders { nullptr };
QoSm1Proxy* _qosm1Proxy {nullptr}; QoSm1Proxy* _qosm1Proxy { nullptr };
Aggregater* _aggregater {nullptr}; Aggregater* _aggregater { nullptr };
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWADAPTERMANAGER_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWADAPTERMANAGER_H_ */

406
MQTTSNGateway/src/MQTTSNGWAggregateTopicTable.cpp
View File

@@ -21,7 +21,7 @@
=====================================*/ =====================================*/
ClientTopicElement::ClientTopicElement(Client* client) ClientTopicElement::ClientTopicElement(Client* client)
{ {
_client = client; _client = client;
} }
ClientTopicElement::~ClientTopicElement() ClientTopicElement::~ClientTopicElement()
@@ -31,12 +31,12 @@ ClientTopicElement::~ClientTopicElement()
Client* ClientTopicElement::getClient(void) Client* ClientTopicElement::getClient(void)
{ {
return _client; return _client;
} }
ClientTopicElement* ClientTopicElement::getNextClientElement(void) ClientTopicElement* ClientTopicElement::getNextClientElement(void)
{ {
return _next; return _next;
} }
/*===================================== /*=====================================
@@ -49,122 +49,123 @@ AggregateTopicElement::AggregateTopicElement(void)
AggregateTopicElement::AggregateTopicElement(Topic* topic, Client* client) AggregateTopicElement::AggregateTopicElement(Topic* topic, Client* client)
{ {
_topic = topic; _topic = topic;
ClientTopicElement* elm = new ClientTopicElement(client); ClientTopicElement* elm = new ClientTopicElement(client);
if ( elm != nullptr ) if (elm != nullptr)
{ {
_head = elm; _head = elm;
_tail = elm; _tail = elm;
} }
} }
AggregateTopicElement::~AggregateTopicElement(void) AggregateTopicElement::~AggregateTopicElement(void)
{ {
_mutex.lock(); _mutex.lock();
if ( _head != nullptr ) if (_head != nullptr)
{ {
ClientTopicElement* p = _tail; ClientTopicElement* p = _tail;
while ( p ) while (p)
{ {
ClientTopicElement* pPrev = p; ClientTopicElement* pPrev = p;
delete p; delete p;
p = pPrev->_prev; p = pPrev->_prev;
} }
_head = _tail = nullptr; _head = _tail = nullptr;
} }
_mutex.unlock(); _mutex.unlock();
} }
ClientTopicElement* AggregateTopicElement::add(Client* client) ClientTopicElement* AggregateTopicElement::add(Client* client)
{ {
ClientTopicElement* elm = new ClientTopicElement(client); ClientTopicElement* elm = new ClientTopicElement(client);
if ( elm == nullptr ) if (elm == nullptr)
{ {
return nullptr; return nullptr;
} }
_mutex.lock(); _mutex.lock();
if ( _head == nullptr ) if (_head == nullptr)
{ {
_head = elm; _head = elm;
_tail = elm; _tail = elm;
} }
else else
{ {
ClientTopicElement* p = find(client); ClientTopicElement* p = find(client);
if ( p == nullptr ) if (p == nullptr)
{ {
p = _tail; p = _tail;
_tail = elm; _tail = elm;
elm->_prev = p; elm->_prev = p;
p->_next = elm; p->_next = elm;
} }
else else
{ {
delete elm; delete elm;
elm = p; elm = p;
} }
} }
_mutex.unlock(); _mutex.unlock();
return elm; return elm;
} }
ClientTopicElement* AggregateTopicElement::find(Client* client) ClientTopicElement* AggregateTopicElement::find(Client* client)
{ {
ClientTopicElement* p = _head; ClientTopicElement* p = _head;
while ( p != nullptr ) while (p != nullptr)
{ {
if ( p->_client == client) if (p->_client == client)
{ {
break; break;
} }
p = p->_next; p = p->_next;
} }
return p; return p;
} }
ClientTopicElement* AggregateTopicElement::getFirstClientTopicElement(void) ClientTopicElement* AggregateTopicElement::getFirstClientTopicElement(void)
{ {
return _head; return _head;
} }
ClientTopicElement* AggregateTopicElement::getNextClientTopicElement(ClientTopicElement* elmClient) ClientTopicElement* AggregateTopicElement::getNextClientTopicElement(
ClientTopicElement* elmClient)
{ {
return elmClient->_next; return elmClient->_next;
} }
void AggregateTopicElement::eraseClient(Client* client) void AggregateTopicElement::eraseClient(Client* client)
{ {
_mutex.lock(); _mutex.lock();
ClientTopicElement* p = find(client); ClientTopicElement* p = find(client);
if ( p != nullptr ) if (p != nullptr)
{ {
if ( p->_prev == nullptr ) // head element if (p->_prev == nullptr) // head element
{ {
_head = p->_next; _head = p->_next;
if ( p->_next == nullptr ) // head & only one if (p->_next == nullptr) // head & only one
{ {
_tail = nullptr; _tail = nullptr;
} }
else else
{ {
p->_next->_prev = nullptr; // head & midle p->_next->_prev = nullptr; // head & midle
} }
} }
else if ( p->_next != nullptr ) // middle else if (p->_next != nullptr) // middle
{ {
p->_prev->_next = p->_next; p->_prev->_next = p->_next;
} }
else // tail else // tail
{ {
p->_prev->_next = nullptr; p->_prev->_next = nullptr;
_tail = p->_prev; _tail = p->_prev;
} }
delete p; delete p;
} }
_mutex.unlock(); _mutex.unlock();
} }
/*===================================== /*=====================================
@@ -183,138 +184,139 @@ AggregateTopicTable::~AggregateTopicTable()
AggregateTopicElement* AggregateTopicTable::add(Topic* topic, Client* client) AggregateTopicElement* AggregateTopicTable::add(Topic* topic, Client* client)
{ {
AggregateTopicElement* elm = nullptr; AggregateTopicElement* elm = nullptr;
_mutex.lock(); _mutex.lock();
elm = getAggregateTopicElement(topic); elm = getAggregateTopicElement(topic);
if ( elm != nullptr ) if (elm != nullptr)
{ {
if ( elm->find(client) == nullptr ) if (elm->find(client) == nullptr)
{ {
elm->add(client); elm->add(client);
} }
} }
else else
{ {
Topic* newTopic = topic->duplicate(); Topic* newTopic = topic->duplicate();
elm = new AggregateTopicElement(newTopic, client); elm = new AggregateTopicElement(newTopic, client);
if ( _head == nullptr ) if (_head == nullptr)
{ {
_head = elm; _head = elm;
_tail = elm; _tail = elm;
} }
else else
{ {
elm->_prev = _tail; elm->_prev = _tail;
_tail->_next = elm; _tail->_next = elm;
_tail = elm; _tail = elm;
} }
} }
_mutex.unlock(); _mutex.unlock();
return elm; return elm;
} }
void AggregateTopicTable::erase(Topic* topic, Client* client) void AggregateTopicTable::erase(Topic* topic, Client* client)
{ {
AggregateTopicElement* elm = nullptr; AggregateTopicElement* elm = nullptr;
_mutex.lock(); _mutex.lock();
elm = getAggregateTopicElement(topic); elm = getAggregateTopicElement(topic);
if ( elm != nullptr ) if (elm != nullptr)
{ {
elm->eraseClient(client); elm->eraseClient(client);
} }
if ( elm->_head == nullptr ) if (elm->_head == nullptr)
{ {
erase(elm); erase(elm);
} }
_mutex.unlock(); _mutex.unlock();
return; return;
} }
void AggregateTopicTable::erase(AggregateTopicElement* elmTopic) void AggregateTopicTable::erase(AggregateTopicElement* elmTopic)
{ {
if ( elmTopic != nullptr ) if (elmTopic != nullptr)
{ {
if ( elmTopic->_prev == nullptr ) // head element if (elmTopic->_prev == nullptr) // head element
{ {
_head = elmTopic->_next; _head = elmTopic->_next;
if ( elmTopic->_next == nullptr ) // head & only one if (elmTopic->_next == nullptr) // head & only one
{ {
_tail = nullptr; _tail = nullptr;
} }
else else
{ {
elmTopic->_next->_prev = nullptr; // head & midle elmTopic->_next->_prev = nullptr; // head & midle
} }
} }
else if ( elmTopic->_next != nullptr ) // middle else if (elmTopic->_next != nullptr) // middle
{ {
elmTopic->_prev->_next = elmTopic->_next; elmTopic->_prev->_next = elmTopic->_next;
} }
else // tail else // tail
{ {
elmTopic->_prev->_next = nullptr; elmTopic->_prev->_next = nullptr;
_tail = elmTopic->_prev; _tail = elmTopic->_prev;
} }
delete elmTopic; delete elmTopic;
} }
} }
AggregateTopicElement* AggregateTopicTable::getAggregateTopicElement(Topic* topic) AggregateTopicElement* AggregateTopicTable::getAggregateTopicElement(
Topic* topic)
{ {
AggregateTopicElement* elm = _head; AggregateTopicElement* elm = _head;
while( elm != nullptr ) while (elm != nullptr)
{ {
if ( elm->_topic->isMatch(topic->_topicName) ) if (elm->_topic->isMatch(topic->_topicName))
{ {
break; break;
} }
elm = elm->_next; elm = elm->_next;
} }
return elm; return elm;
} }
ClientTopicElement* AggregateTopicTable::getClientElement(Topic* topic) ClientTopicElement* AggregateTopicTable::getClientElement(Topic* topic)
{ {
AggregateTopicElement* elm = getAggregateTopicElement(topic); AggregateTopicElement* elm = getAggregateTopicElement(topic);
if ( elm != nullptr ) if (elm != nullptr)
{ {
return elm->_head; return elm->_head;
} }
else else
{ {
return nullptr; return nullptr;
} }
} }
void AggregateTopicTable::print(void) void AggregateTopicTable::print(void)
{ {
AggregateTopicElement* elm = _head; AggregateTopicElement* elm = _head;
printf("Beginning of AggregateTopicTable\n"); printf("Beginning of AggregateTopicTable\n");
while( elm != nullptr ) while (elm != nullptr)
{ {
printf("%s\n", elm->_topic->getTopicName()->c_str()); printf("%s\n", elm->_topic->getTopicName()->c_str());
ClientTopicElement* clElm = elm->getFirstClientTopicElement(); ClientTopicElement* clElm = elm->getFirstClientTopicElement();
Client* client = clElm->getClient(); Client* client = clElm->getClient();
while ( client != nullptr ) while (client != nullptr)
{ {
printf(" %s\n", client->getClientId()); printf(" %s\n", client->getClientId());
clElm = clElm->getNextClientElement(); clElm = clElm->getNextClientElement();
if ( clElm != nullptr ) if (clElm != nullptr)
{ {
client = clElm->getClient(); client = clElm->getClient();
} }
else else
{ {
client = nullptr; client = nullptr;
} }
} }
elm = elm->_next; elm = elm->_next;
} }
printf("End of AggregateTopicTable\n"); printf("End of AggregateTopicTable\n");
} }

49
MQTTSNGateway/src/MQTTSNGWAggregateTopicTable.h
View File

@@ -35,24 +35,24 @@ class Mutex;
class AggregateTopicTable class AggregateTopicTable
{ {
public: public:
AggregateTopicTable(); AggregateTopicTable();
~AggregateTopicTable(); ~AggregateTopicTable();
AggregateTopicElement* add(Topic* topic, Client* client); AggregateTopicElement* add(Topic* topic, Client* client);
AggregateTopicElement* getAggregateTopicElement(Topic* topic); AggregateTopicElement* getAggregateTopicElement(Topic* topic);
ClientTopicElement* getClientElement(Topic* topic); ClientTopicElement* getClientElement(Topic* topic);
void erase(Topic* topic, Client* client); void erase(Topic* topic, Client* client);
void clear(void); void clear(void);
void print(void); void print(void);
private: private:
void erase(AggregateTopicElement* elmTopic); void erase(AggregateTopicElement* elmTopic);
Mutex _mutex; Mutex _mutex;
AggregateTopicElement* _head {nullptr}; AggregateTopicElement* _head { nullptr };
AggregateTopicElement* _tail {nullptr}; AggregateTopicElement* _tail { nullptr };
int _cnt {0}; int _cnt { 0 };
int _maxSize {MAX_MESSAGEID_TABLE_SIZE}; int _maxSize { MAX_MESSAGEID_TABLE_SIZE };
}; };
/*===================================== /*=====================================
@@ -68,17 +68,18 @@ public:
ClientTopicElement* add(Client* client); ClientTopicElement* add(Client* client);
ClientTopicElement* getFirstClientTopicElement(void); ClientTopicElement* getFirstClientTopicElement(void);
ClientTopicElement* getNextClientTopicElement(ClientTopicElement* elmClient); ClientTopicElement* getNextClientTopicElement(
ClientTopicElement* elmClient);
void eraseClient(Client* client); void eraseClient(Client* client);
ClientTopicElement* find(Client* client); ClientTopicElement* find(Client* client);
private: private:
Mutex _mutex; Mutex _mutex;
Topic* _topic {nullptr}; Topic* _topic { nullptr };
AggregateTopicElement* _next {nullptr}; AggregateTopicElement* _next { nullptr };
AggregateTopicElement* _prev {nullptr}; AggregateTopicElement* _prev { nullptr };
ClientTopicElement* _head {nullptr}; ClientTopicElement* _head { nullptr };
ClientTopicElement* _tail {nullptr}; ClientTopicElement* _tail { nullptr };
}; };
/*===================================== /*=====================================
@@ -96,13 +97,11 @@ public:
Client* getClient(void); Client* getClient(void);
private: private:
Client* _client {nullptr}; Client* _client { nullptr };
ClientTopicElement* _next {nullptr}; ClientTopicElement* _next { nullptr };
ClientTopicElement* _prev {nullptr}; ClientTopicElement* _prev { nullptr };
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWAGGREGATETOPICTABLE_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWAGGREGATETOPICTABLE_H_ */

118
MQTTSNGateway/src/MQTTSNGWAggregater.cpp
View File

@@ -26,9 +26,10 @@
using namespace MQTTSNGW; using namespace MQTTSNGW;
Aggregater::Aggregater(Gateway* gw) : Adapter(gw) Aggregater::Aggregater(Gateway* gw) :
Adapter(gw)
{ {
_gateway = gw; _gateway = gw;
} }
Aggregater::~Aggregater(void) Aggregater::~Aggregater(void)
@@ -38,10 +39,10 @@ Aggregater::~Aggregater(void)
void Aggregater::initialize(char* gwName) void Aggregater::initialize(char* gwName)
{ {
/* Create Aggregater Client */ /* Create Aggregater Client */
string name = string(gwName) + string("_Aggregater"); string name = string(gwName) + string("_Aggregater");
setup(name.c_str(), Atype_Aggregater); setup(name.c_str(), Atype_Aggregater);
_isActive = true; _isActive = true;
//testMessageIdTable(); //testMessageIdTable();
@@ -49,100 +50,99 @@ void Aggregater::initialize(char* gwName)
bool Aggregater::isActive(void) bool Aggregater::isActive(void)
{ {
return _isActive; return _isActive;
} }
uint16_t Aggregater::msgId(void) uint16_t Aggregater::msgId(void)
{ {
// Only SecureClient generates msgId to avoid duplication of msgId. Client does not generate it. // Only SecureClient generates msgId to avoid duplication of msgId. Client does not generate it.
return Adapter::getSecureClient()->getNextPacketId(); return Adapter::getSecureClient()->getNextPacketId();
} }
Client* Aggregater::convertClient(uint16_t msgId, uint16_t* clientMsgId) Client* Aggregater::convertClient(uint16_t msgId, uint16_t* clientMsgId)
{ {
return _msgIdTable.getClientMsgId(msgId, clientMsgId); return _msgIdTable.getClientMsgId(msgId, clientMsgId);
} }
uint16_t Aggregater::addMessageIdTable(Client* client, uint16_t msgId) uint16_t Aggregater::addMessageIdTable(Client* client, uint16_t msgId)
{ {
/* set Non secure client`s nextMsgId. otherwise Id is duplicated.*/ /* set Non secure client`s nextMsgId. otherwise Id is duplicated.*/
MessageIdElement* elm = _msgIdTable.add(this, client, msgId); MessageIdElement* elm = _msgIdTable.add(this, client, msgId);
if ( elm == nullptr ) if (elm == nullptr)
{ {
return 0; return 0;
} }
else else
{ {
return elm->_msgId; return elm->_msgId;
} }
} }
uint16_t Aggregater::getMsgId(Client* client, uint16_t clientMsgId) uint16_t Aggregater::getMsgId(Client* client, uint16_t clientMsgId)
{ {
return _msgIdTable.getMsgId(client, clientMsgId); return _msgIdTable.getMsgId(client, clientMsgId);
} }
AggregateTopicElement* Aggregater::addAggregateTopic(Topic* topic, Client* client) AggregateTopicElement* Aggregater::addAggregateTopic(Topic* topic,
Client* client)
{ {
return _topicTable.add(topic, client); return _topicTable.add(topic, client);
} }
void Aggregater::removeAggregateTopic(Topic* topic, Client* client) void Aggregater::removeAggregateTopic(Topic* topic, Client* client)
{ {
_topicTable.erase(topic, client); _topicTable.erase(topic, client);
} }
AggregateTopicElement* Aggregater::findTopic(Topic* topic) AggregateTopicElement* Aggregater::findTopic(Topic* topic)
{ {
return _topicTable.getAggregateTopicElement(topic); return _topicTable.getAggregateTopicElement(topic);
} }
ClientTopicElement* Aggregater::getClientElement(Topic* topic) ClientTopicElement* Aggregater::getClientElement(Topic* topic)
{ {
AggregateTopicElement* elm = findTopic(topic); AggregateTopicElement* elm = findTopic(topic);
if ( elm != nullptr ) if (elm != nullptr)
{ {
return elm->getFirstClientTopicElement(); return elm->getFirstClientTopicElement();
} }
else else
{ {
return nullptr; return nullptr;
} }
} }
void Aggregater::printAggregateTopicTable(void) void Aggregater::printAggregateTopicTable(void)
{ {
_topicTable.print(); _topicTable.print();
} }
bool Aggregater::testMessageIdTable(void) bool Aggregater::testMessageIdTable(void)
{ {
Client* client = new Client(); Client* client = new Client();
uint16_t msgId = 0; uint16_t msgId = 0;
printf("msgId=%d\n", addMessageIdTable(client,1)); printf("msgId=%d\n", addMessageIdTable(client, 1));
printf("msgId=%d\n", addMessageIdTable(client,2)); printf("msgId=%d\n", addMessageIdTable(client, 2));
printf("msgId=%d\n", addMessageIdTable(client,3)); printf("msgId=%d\n", addMessageIdTable(client, 3));
printf("msgId=%d\n", addMessageIdTable(client,1)); printf("msgId=%d\n", addMessageIdTable(client, 1));
printf("msgId=%d\n", addMessageIdTable(client,2)); printf("msgId=%d\n", addMessageIdTable(client, 2));
printf("msgId=%d\n", addMessageIdTable(client,3)); printf("msgId=%d\n", addMessageIdTable(client, 3));
printf("msgId=%d\n", addMessageIdTable(client,4)); printf("msgId=%d\n", addMessageIdTable(client, 4));
printf("msgId=%d\n", addMessageIdTable(client,4)); printf("msgId=%d\n", addMessageIdTable(client, 4));
printf("msgId=%d\n", addMessageIdTable(client,4)); printf("msgId=%d\n", addMessageIdTable(client, 4));
convertClient(1,&msgId); convertClient(1, &msgId);
printf("msgId=%d\n",msgId); printf("msgId=%d\n", msgId);
convertClient(2,&msgId); convertClient(2, &msgId);
printf("msgId=%d\n",msgId); printf("msgId=%d\n", msgId);
convertClient(5,&msgId); convertClient(5, &msgId);
printf("msgId=%d\n",msgId); printf("msgId=%d\n", msgId);
convertClient(4,&msgId); convertClient(4, &msgId);
printf("msgId=%d\n",msgId); printf("msgId=%d\n", msgId);
convertClient(3,&msgId); convertClient(3, &msgId);
printf("msgId=%d\n",msgId); printf("msgId=%d\n", msgId);
return true; return true;
} }

46
MQTTSNGateway/src/MQTTSNGWAggregater.h
View File

@@ -32,11 +32,11 @@ class AggregateTopicTable;
class Topics; class Topics;
/*===================================== /*=====================================
Class Aggregater Class Aggregater
=====================================*/ =====================================*/
class Aggregater : public Adapter class Aggregater: public Adapter
{ {
friend class MessageIdTable; friend class MessageIdTable;
public: public:
Aggregater(Gateway* gw); Aggregater(Gateway* gw);
~Aggregater(void); ~Aggregater(void);
@@ -44,39 +44,35 @@ public:
void initialize(char* gwName); void initialize(char* gwName);
const char* getClientId(SensorNetAddress* addr); const char* getClientId(SensorNetAddress* addr);
Client* getClient(SensorNetAddress* addr); Client* getClient(SensorNetAddress* addr);
Client* convertClient(uint16_t msgId, uint16_t* clientMsgId); Client* convertClient(uint16_t msgId, uint16_t* clientMsgId);
uint16_t addMessageIdTable(Client* client, uint16_t msgId); uint16_t addMessageIdTable(Client* client, uint16_t msgId);
uint16_t getMsgId(Client* client, uint16_t clientMsgId); uint16_t getMsgId(Client* client, uint16_t clientMsgId);
ClientTopicElement* getClientElement(Topic* topic); ClientTopicElement* getClientElement(Topic* topic);
ClientTopicElement* getNextClientElement(ClientTopicElement* clientElement); ClientTopicElement* getNextClientElement(ClientTopicElement* clientElement);
Client* getClient(ClientTopicElement* clientElement); Client* getClient(ClientTopicElement* clientElement);
AggregateTopicElement* findTopic(Topic* topic); AggregateTopicElement* findTopic(Topic* topic);
AggregateTopicElement* addAggregateTopic(Topic* topic, Client* client); AggregateTopicElement* addAggregateTopic(Topic* topic, Client* client);
void removeAggregateTopic(Topic* topic, Client* client); void removeAggregateTopic(Topic* topic, Client* client);
void removeAggregateAllTopic(Client* client); void removeAggregateAllTopic(Client* client);
bool isActive(void); bool isActive(void);
void printAggregateTopicTable(void); void printAggregateTopicTable(void);
bool testMessageIdTable(void); bool testMessageIdTable(void);
private: private:
uint16_t msgId(void); uint16_t msgId(void);
Gateway* _gateway {nullptr}; Gateway* _gateway { nullptr };
MessageIdTable _msgIdTable; MessageIdTable _msgIdTable;
AggregateTopicTable _topicTable; AggregateTopicTable _topicTable;
bool _isActive {false}; bool _isActive { false };
bool _isSecure {false}; bool _isSecure { false };
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWAGGREGATER_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWAGGREGATER_H_ */

324
MQTTSNGateway/src/MQTTSNGWBrokerRecvTask.cpp
View File

@@ -29,9 +29,9 @@ char* currentDateTime(void);
=====================================*/ =====================================*/
BrokerRecvTask::BrokerRecvTask(Gateway* gateway) BrokerRecvTask::BrokerRecvTask(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
_gateway->attach((Thread*)this); _gateway->attach((Thread*) this);
_light = nullptr; _light = nullptr;
} }
BrokerRecvTask::~BrokerRecvTask() BrokerRecvTask::~BrokerRecvTask()
@@ -44,7 +44,7 @@ BrokerRecvTask::~BrokerRecvTask()
*/ */
void BrokerRecvTask::initialize(int argc, char** argv) void BrokerRecvTask::initialize(int argc, char** argv)
{ {
_light = _gateway->getLightIndicator(); _light = _gateway->getLightIndicator();
} }
/** /**
@@ -52,133 +52,147 @@ void BrokerRecvTask::initialize(int argc, char** argv)
*/ */
void BrokerRecvTask::run(void) void BrokerRecvTask::run(void)
{ {
struct timeval timeout; struct timeval timeout;
MQTTGWPacket* packet = nullptr; MQTTGWPacket* packet = nullptr;
int rc; int rc;
Event* ev = nullptr; Event* ev = nullptr;
fd_set rset; fd_set rset;
fd_set wset; fd_set wset;
while (true) while (true)
{ {
_light->blueLight(false); _light->blueLight(false);
if (CHK_SIGINT) if (CHK_SIGINT)
{ {
WRITELOG("\n%s BrokerRecvTask stopped.", currentDateTime()); WRITELOG("\n%s BrokerRecvTask stopped.", currentDateTime());
return; return;
} }
timeout.tv_sec = 0; timeout.tv_sec = 0;
timeout.tv_usec = 500000; // 500 msec timeout.tv_usec = 500000; // 500 msec
FD_ZERO(&rset); FD_ZERO(&rset);
FD_ZERO(&wset); FD_ZERO(&wset);
int maxSock = 0; int maxSock = 0;
int sockfd = 0; int sockfd = 0;
/* Prepare sockets list to read */ /* Prepare sockets list to read */
Client* client = _gateway->getClientList()->getClient(0); Client* client = _gateway->getClientList()->getClient(0);
while ( client ) while (client)
{ {
if (client->getNetwork()->isValid()) if (client->getNetwork()->isValid())
{ {
sockfd = client->getNetwork()->getSock(); sockfd = client->getNetwork()->getSock();
FD_SET(sockfd, &rset); FD_SET(sockfd, &rset);
FD_SET(sockfd, &wset); FD_SET(sockfd, &wset);
if (sockfd > maxSock) if (sockfd > maxSock)
{ {
maxSock = sockfd; maxSock = sockfd;
} }
} }
client = client->getNextClient(); client = client->getNextClient();
} }
if (maxSock == 0) if (maxSock == 0)
{ {
usleep(500 * 1000); usleep(500 * 1000);
} }
else else
{ {
/* Check sockets is ready to read */ /* Check sockets is ready to read */
int activity = select(maxSock + 1, &rset, 0, 0, &timeout); int activity = select(maxSock + 1, &rset, 0, 0, &timeout);
if (activity > 0) if (activity > 0)
{ {
client = _gateway->getClientList()->getClient(0); client = _gateway->getClientList()->getClient(0);
while ( client ) while (client)
{ {
_light->blueLight(false); _light->blueLight(false);
if (client->getNetwork()->isValid()) if (client->getNetwork()->isValid())
{ {
int sockfd = client->getNetwork()->getSock(); int sockfd = client->getNetwork()->getSock();
if (FD_ISSET(sockfd, &rset)) if (FD_ISSET(sockfd, &rset))
{ {
packet = new MQTTGWPacket(); packet = new MQTTGWPacket();
rc = 0; rc = 0;
/* read sockets */ /* read sockets */
_light->blueLight(true); _light->blueLight(true);
rc = packet->recv(client->getNetwork()); rc = packet->recv(client->getNetwork());
if ( rc > 0 ) if (rc > 0)
{ {
if ( log(client, packet) == -1 ) if (log(client, packet) == -1)
{ {
delete packet; delete packet;
goto nextClient; goto nextClient;
} }
/* post a BrokerRecvEvent */ /* post a BrokerRecvEvent */
ev = new Event(); ev = new Event();
ev->setBrokerRecvEvent(client, packet); ev->setBrokerRecvEvent(client, packet);
_gateway->getPacketEventQue()->post(ev); _gateway->getPacketEventQue()->post(ev);
} }
else else
{ {
if ( rc == 0 ) // Disconnected if (rc == 0) // Disconnected
{ {
client->getNetwork()->close(); client->getNetwork()->close();
delete packet; delete packet;
/* delete client when the client is not authorized & session is clean */ /* delete client when the client is not authorized & session is clean */
_gateway->getClientList()->erase(client); _gateway->getClientList()->erase(client);
if ( client ) if (client)
{ {
client = client->getNextClient(); client = client->getNextClient();
} }
continue; continue;
} }
else if (rc == -1) else if (rc == -1)
{ {
WRITELOG("%s BrokerRecvTask can't receive a packet from the broker errno=%d %s%s\n", ERRMSG_HEADER, errno, client->getClientId(), ERRMSG_FOOTER); WRITELOG(
} "%s BrokerRecvTask can't receive a packet from the broker errno=%d %s%s\n",
else if ( rc == -2 ) ERRMSG_HEADER, errno,
{ client->getClientId(),
WRITELOG("%s BrokerRecvTask receive invalid length of packet from the broker. DISCONNECT %s %s\n", ERRMSG_HEADER, client->getClientId(),ERRMSG_FOOTER); ERRMSG_FOOTER);
} }
else if ( rc == -3 ) else if (rc == -2)
{ {
WRITELOG("%s BrokerRecvTask can't get memories for the packet %s%s\n", ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER); WRITELOG(
} "%s BrokerRecvTask receive invalid length of packet from the broker. DISCONNECT %s %s\n",
ERRMSG_HEADER,
client->getClientId(),
ERRMSG_FOOTER);
}
else if (rc == -3)
{
WRITELOG(
"%s BrokerRecvTask can't get memories for the packet %s%s\n",
ERRMSG_HEADER,
client->getClientId(),
ERRMSG_FOOTER);
}
delete packet; delete packet;
if ( (rc == -1 || rc == -2) && ( client->isActive() || client->isSleep() || client->isAwake() )) if ((rc == -1 || rc == -2)
{ && (client->isActive()
/* disconnect the client */ || client->isSleep()
packet = new MQTTGWPacket(); || client->isAwake()))
packet->setHeader(DISCONNECT); {
ev = new Event(); /* disconnect the client */
ev->setBrokerRecvEvent(client, packet); packet = new MQTTGWPacket();
_gateway->getPacketEventQue()->post(ev); packet->setHeader(DISCONNECT);
} ev = new Event();
} ev->setBrokerRecvEvent(client, packet);
} _gateway->getPacketEventQue()->post(ev);
} }
nextClient: }
client = client->getNextClient(); }
} }
} nextClient: client = client->getNextClient();
} }
} }
}
}
} }
/** /**
@@ -186,35 +200,43 @@ void BrokerRecvTask::run(void)
*/ */
int BrokerRecvTask::log(Client* client, MQTTGWPacket* packet) int BrokerRecvTask::log(Client* client, MQTTGWPacket* packet)
{ {
char pbuf[(SIZE_OF_LOG_PACKET + 5 )* 3]; char pbuf[(SIZE_OF_LOG_PACKET + 5) * 3];
char msgId[6]; char msgId[6];
int rc = 0; int rc = 0;
switch (packet->getType()) switch (packet->getType())
{ {
case CONNACK: case CONNACK:
WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), LEFTARROWB, client->getClientId(), packet->print(pbuf)); WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), LEFTARROWB,
break; client->getClientId(), packet->print(pbuf));
case PUBLISH: break;
WRITELOG(FORMAT_W_MSGID_Y_W_NL, currentDateTime(), packet->getName(), packet->getMsgId(msgId), LEFTARROWB, client->getClientId(), packet->print(pbuf)); case PUBLISH:
break; WRITELOG(FORMAT_W_MSGID_Y_W_NL, currentDateTime(), packet->getName(),
case PUBACK: packet->getMsgId(msgId), LEFTARROWB, client->getClientId(),
case PUBREC: packet->print(pbuf));
case PUBREL: break;
case PUBCOMP: case PUBACK:
WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(), packet->getMsgId(msgId), LEFTARROWB, client->getClientId(), packet->print(pbuf)); case PUBREC:
break; case PUBREL:
case SUBACK: case PUBCOMP:
case UNSUBACK: WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(),
WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(), packet->getMsgId(msgId), LEFTARROWB, client->getClientId(), packet->print(pbuf)); packet->getMsgId(msgId), LEFTARROWB, client->getClientId(),
break; packet->print(pbuf));
case PINGRESP: break;
WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), LEFTARROWB, client->getClientId(), packet->print(pbuf)); case SUBACK:
break; case UNSUBACK:
default: WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(),
WRITELOG("Type=%x\n", packet->getType()); packet->getMsgId(msgId), LEFTARROWB, client->getClientId(),
rc = -1; packet->print(pbuf));
break; break;
} case PINGRESP:
return rc; WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), LEFTARROWB,
client->getClientId(), packet->print(pbuf));
break;
default:
WRITELOG("Type=%x\n", packet->getType());
rc = -1;
break;
}
return rc;
} }

17
MQTTSNGateway/src/MQTTSNGWBrokerRecvTask.h
View File

@@ -28,21 +28,20 @@ namespace MQTTSNGW
class BrokerRecvTask: public Thread class BrokerRecvTask: public Thread
{ {
MAGIC_WORD_FOR_THREAD; MAGIC_WORD_FOR_THREAD;
;
public: public:
BrokerRecvTask(Gateway* gateway); BrokerRecvTask(Gateway* gateway);
~BrokerRecvTask(); ~BrokerRecvTask();
void initialize(int argc, char** argv); void initialize(int argc, char** argv);
void run(void); void run(void);
private: private:
int log(Client*, MQTTGWPacket*); int log(Client*, MQTTGWPacket*);
Gateway* _gateway; Gateway* _gateway;
LightIndicator* _light; LightIndicator* _light;
}; };
} }
#endif /* MQTTSNGWBROKERRECVTASK_H_ */ #endif /* MQTTSNGWBROKERRECVTASK_H_ */

245
MQTTSNGateway/src/MQTTSNGWBrokerSendTask.cpp
View File

@@ -33,10 +33,10 @@ char* currentDateTime();
=====================================*/ =====================================*/
BrokerSendTask::BrokerSendTask(Gateway* gateway) BrokerSendTask::BrokerSendTask(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
_gateway->attach((Thread*)this); _gateway->attach((Thread*) this);
_gwparams = nullptr; _gwparams = nullptr;
_light = nullptr; _light = nullptr;
} }
BrokerSendTask::~BrokerSendTask() BrokerSendTask::~BrokerSendTask()
@@ -49,8 +49,8 @@ BrokerSendTask::~BrokerSendTask()
*/ */
void BrokerSendTask::initialize(int argc, char** argv) void BrokerSendTask::initialize(int argc, char** argv)
{ {
_gwparams = _gateway->getGWParams(); _gwparams = _gateway->getGWParams();
_light = _gateway->getLightIndicator(); _light = _gateway->getLightIndicator();
} }
/** /**
@@ -58,132 +58,149 @@ void BrokerSendTask::initialize(int argc, char** argv)
*/ */
void BrokerSendTask::run() void BrokerSendTask::run()
{ {
Event* ev = nullptr; Event* ev = nullptr;
MQTTGWPacket* packet = nullptr; MQTTGWPacket* packet = nullptr;
Client* client = nullptr; Client* client = nullptr;
AdapterManager* adpMgr = _gateway->getAdapterManager(); AdapterManager* adpMgr = _gateway->getAdapterManager();
int rc = 0; int rc = 0;
while (true) while (true)
{ {
ev = _gateway->getBrokerSendQue()->wait(); ev = _gateway->getBrokerSendQue()->wait();
if ( ev->getEventType() == EtStop ) if (ev->getEventType() == EtStop)
{ {
WRITELOG("\n%s BrokerSendTask stopped.", currentDateTime()); WRITELOG("\n%s BrokerSendTask stopped.", currentDateTime());
delete ev; delete ev;
return; return;
} }
if ( ev->getEventType() == EtBrokerSend) if (ev->getEventType() == EtBrokerSend)
{ {
client = ev->getClient(); client = ev->getClient();
packet = ev->getMQTTGWPacket(); packet = ev->getMQTTGWPacket();
/* Check Client is managed by Adapters */ /* Check Client is managed by Adapters */
client = adpMgr->getClient(client); client = adpMgr->getClient(client);
if ( packet->getType() == CONNECT && client->getNetwork()->isValid() ) if (packet->getType() == CONNECT && client->getNetwork()->isValid())
{ {
client->getNetwork()->close(); client->getNetwork()->close();
} }
if ( !client->getNetwork()->isValid() ) if (!client->getNetwork()->isValid())
{ {
/* connect to the broker and send a packet */ /* connect to the broker and send a packet */
if (client->isSecureNetwork()) if (client->isSecureNetwork())
{ {
rc = client->getNetwork()->connect((const char*)_gwparams->brokerName, (const char*)_gwparams->portSecure, (const char*)_gwparams->rootCApath, rc = client->getNetwork()->connect(
(const char*)_gwparams->rootCAfile, (const char*)_gwparams->certKey, (const char*)_gwparams->privateKey); (const char*) _gwparams->brokerName,
} (const char*) _gwparams->portSecure,
else (const char*) _gwparams->rootCApath,
{ (const char*) _gwparams->rootCAfile,
rc = client->getNetwork()->connect((const char*)_gwparams->brokerName, (const char*)_gwparams->port); (const char*) _gwparams->certKey,
} (const char*) _gwparams->privateKey);
}
else
{
rc = client->getNetwork()->connect(
(const char*) _gwparams->brokerName,
(const char*) _gwparams->port);
}
if ( !rc ) if (!rc)
{ {
/* disconnect the broker and the client */ /* disconnect the broker and the client */
WRITELOG("%s BrokerSendTask: %s can't connect to the broker. errno=%d %s %s\n", WRITELOG(
ERRMSG_HEADER, client->getClientId(), errno, strerror(errno), ERRMSG_FOOTER); "%s BrokerSendTask: %s can't connect to the broker. errno=%d %s %s\n",
delete ev; ERRMSG_HEADER, client->getClientId(), errno,
client->getNetwork()->close(); strerror(errno), ERRMSG_FOOTER);
continue; delete ev;
} client->getNetwork()->close();
} continue;
}
}
/* send a packet */ /* send a packet */
_light->blueLight(true); _light->blueLight(true);
if ( (rc = packet->send(client->getNetwork())) > 0 ) if ((rc = packet->send(client->getNetwork())) > 0)
{ {
if ( packet->getType() == CONNECT ) if (packet->getType() == CONNECT)
{ {
client->connectSended(); client->connectSended();
} }
else if ( packet->getType() == DISCONNECT ) else if (packet->getType() == DISCONNECT)
{ {
client->getNetwork()->close(); client->getNetwork()->close();
client->disconnected(); client->disconnected();
} }
log(client, packet); log(client, packet);
} }
else else
{ {
WRITELOG("%s BrokerSendTask: %s can't send a packet to the broker. errno=%d %s %s\n", WRITELOG(
ERRMSG_HEADER, client->getClientId(), rc == -1 ? errno : 0, strerror(errno), ERRMSG_FOOTER); "%s BrokerSendTask: %s can't send a packet to the broker. errno=%d %s %s\n",
if ( errno != EBADF ) ERRMSG_HEADER, client->getClientId(),
{ rc == -1 ? errno : 0, strerror(errno), ERRMSG_FOOTER);
client->getNetwork()->close(); if ( errno != EBADF)
} {
client->getNetwork()->close();
}
/* Disconnect the client */ /* Disconnect the client */
packet = new MQTTGWPacket(); packet = new MQTTGWPacket();
packet->setHeader(DISCONNECT); packet->setHeader(DISCONNECT);
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setBrokerRecvEvent(client, packet); ev1->setBrokerRecvEvent(client, packet);
_gateway->getPacketEventQue()->post(ev1); _gateway->getPacketEventQue()->post(ev1);
} }
_light->blueLight(false); _light->blueLight(false);
} }
delete ev; delete ev;
} }
} }
/** /**
* write message content into stdout or Ringbuffer * write message content into stdout or Ringbuffer
*/ */
void BrokerSendTask::log(Client* client, MQTTGWPacket* packet) void BrokerSendTask::log(Client* client, MQTTGWPacket* packet)
{ {
char pbuf[(SIZE_OF_LOG_PACKET + 5 )* 3]; char pbuf[(SIZE_OF_LOG_PACKET + 5) * 3];
char msgId[6]; char msgId[6];
switch (packet->getType()) switch (packet->getType())
{ {
case CONNECT: case CONNECT:
WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), RIGHTARROWB, client->getClientId(), packet->print(pbuf)); WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(),
break; RIGHTARROWB, client->getClientId(), packet->print(pbuf));
case PUBLISH: break;
WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(), packet->getMsgId(msgId), RIGHTARROWB, client->getClientId(), packet->print(pbuf)); case PUBLISH:
break; WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(),
case SUBSCRIBE: packet->getMsgId(msgId), RIGHTARROWB, client->getClientId(),
case UNSUBSCRIBE: packet->print(pbuf));
case PUBACK: break;
case PUBREC: case SUBSCRIBE:
case PUBREL: case UNSUBSCRIBE:
case PUBCOMP: case PUBACK:
WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(), packet->getMsgId(msgId), RIGHTARROWB, client->getClientId(), packet->print(pbuf)); case PUBREC:
break; case PUBREL:
case PINGREQ: case PUBCOMP:
WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), RIGHTARROWB, client->getClientId(), packet->print(pbuf)); WRITELOG(FORMAT_W_MSGID_Y_W, currentDateTime(), packet->getName(),
break; packet->getMsgId(msgId), RIGHTARROWB, client->getClientId(),
case DISCONNECT: packet->print(pbuf));
WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(), RIGHTARROWB, client->getClientId(), packet->print(pbuf)); break;
break; case PINGREQ:
default: WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(),
break; RIGHTARROWB, client->getClientId(), packet->print(pbuf));
} break;
case DISCONNECT:
WRITELOG(FORMAT_Y_Y_W, currentDateTime(), packet->getName(),
RIGHTARROWB, client->getClientId(), packet->print(pbuf));
break;
default:
break;
}
} }

24
MQTTSNGateway/src/MQTTSNGWBrokerSendTask.h
View File

@@ -25,22 +25,22 @@ namespace MQTTSNGW
class Adapter; class Adapter;
/*===================================== /*=====================================
Class BrokerSendTask Class BrokerSendTask
=====================================*/ =====================================*/
class BrokerSendTask : public Thread class BrokerSendTask: public Thread
{ {
MAGIC_WORD_FOR_THREAD; MAGIC_WORD_FOR_THREAD;
friend AdapterManager; friend AdapterManager;
public: public:
BrokerSendTask(Gateway* gateway); BrokerSendTask(Gateway* gateway);
~BrokerSendTask(); ~BrokerSendTask();
void initialize(int argc, char** argv); void initialize(int argc, char** argv);
void run(); void run();
private: private:
void log(Client*, MQTTGWPacket*); void log(Client*, MQTTGWPacket*);
Gateway* _gateway; Gateway* _gateway;
GatewayParams* _gwparams; GatewayParams* _gwparams;
LightIndicator* _light; LightIndicator* _light;
}; };
} }

618
MQTTSNGateway/src/MQTTSNGWClient.cpp
View File

@@ -28,104 +28,107 @@
using namespace MQTTSNGW; using namespace MQTTSNGW;
char* currentDateTime(void); char* currentDateTime(void);
/*===================================== /*=====================================
Class Client Class Client
=====================================*/ =====================================*/
static const char* theClientStatus[] = { "Disconnected", "TryConnecting", "Connecting", "Active", "Asleep", "Awake", "Lost" }; static const char* theClientStatus[] =
{ "Disconnected", "TryConnecting", "Connecting", "Active", "Asleep", "Awake",
"Lost" };
Client::Client(bool secure) Client::Client(bool secure)
{ {
_packetId = 0; _packetId = 0;
_snMsgId = 0; _snMsgId = 0;
_status = Cstat_Disconnected; _status = Cstat_Disconnected;
_keepAliveMsec = 0; _keepAliveMsec = 0;
_topics = new Topics(); _topics = new Topics();
_clientId = nullptr; _clientId = nullptr;
_willTopic = nullptr; _willTopic = nullptr;
_willMsg = nullptr; _willMsg = nullptr;
_connectData = MQTTPacket_Connect_Initializer; _connectData = MQTTPacket_Connect_Initializer;
_network = new Network(secure); _network = new Network(secure);
_secureNetwork = secure; _secureNetwork = secure;
_sensorNetype = true; _sensorNetype = true;
_connAck = nullptr; _connAck = nullptr;
_waitWillMsgFlg = false; _waitWillMsgFlg = false;
_sessionStatus = false; _sessionStatus = false;
_prevClient = nullptr; _prevClient = nullptr;
_nextClient = nullptr; _nextClient = nullptr;
_clientSleepPacketQue.setMaxSize(MAX_SAVED_PUBLISH); _clientSleepPacketQue.setMaxSize(MAX_SAVED_PUBLISH);
_proxyPacketQue.setMaxSize(MAX_SAVED_PUBLISH); _proxyPacketQue.setMaxSize(MAX_SAVED_PUBLISH);
_hasPredefTopic = false; _hasPredefTopic = false;
_holdPingRequest = false; _holdPingRequest = false;
_forwarder = nullptr; _forwarder = nullptr;
_clientType = Ctype_Regular; _clientType = Ctype_Regular;
} }
Client::~Client() Client::~Client()
{ {
if ( _topics ) if (_topics)
{ {
delete _topics; delete _topics;
} }
if ( _clientId ) if (_clientId)
{ {
free(_clientId); free(_clientId);
} }
if ( _willTopic ) if (_willTopic)
{ {
free(_willTopic); free(_willTopic);
} }
if ( _willMsg ) if (_willMsg)
{ {
free(_willMsg); free(_willMsg);
} }
if (_connAck) if (_connAck)
{ {
delete _connAck; delete _connAck;
} }
if (_network) if (_network)
{ {
delete _network; delete _network;
} }
} }
TopicIdMapElement* Client::getWaitedPubTopicId(uint16_t msgId) TopicIdMapElement* Client::getWaitedPubTopicId(uint16_t msgId)
{ {
return _waitedPubTopicIdMap.getElement(msgId); return _waitedPubTopicIdMap.getElement(msgId);
} }
TopicIdMapElement* Client::getWaitedSubTopicId(uint16_t msgId) TopicIdMapElement* Client::getWaitedSubTopicId(uint16_t msgId)
{ {
return _waitedSubTopicIdMap.getElement(msgId); return _waitedSubTopicIdMap.getElement(msgId);
} }
MQTTGWPacket* Client::getClientSleepPacket() MQTTGWPacket* Client::getClientSleepPacket()
{ {
return _clientSleepPacketQue.getPacket(); return _clientSleepPacketQue.getPacket();
} }
void Client::deleteFirstClientSleepPacket() void Client::deleteFirstClientSleepPacket()
{ {
_clientSleepPacketQue.pop(); _clientSleepPacketQue.pop();
} }
int Client::setClientSleepPacket(MQTTGWPacket* packet) int Client::setClientSleepPacket(MQTTGWPacket* packet)
{ {
int rc = _clientSleepPacketQue.post(packet); int rc = _clientSleepPacketQue.post(packet);
if ( rc ) if (rc)
{ {
WRITELOG("%s %s is sleeping. the packet was saved.\n", currentDateTime(), _clientId); WRITELOG("%s %s is sleeping. the packet was saved.\n",
} currentDateTime(), _clientId);
else }
{ else
WRITELOG("%s %s is sleeping　but discard the packet.\n", currentDateTime(), _clientId); {
} WRITELOG("%s %s is sleeping　but discard the packet.\n",
return rc; currentDateTime(), _clientId);
}
return rc;
} }
MQTTSNPacket* Client::getProxyPacket(void) MQTTSNPacket* Client::getProxyPacket(void)
@@ -141,64 +144,68 @@ void Client::deleteFirstProxyPacket()
int Client::setProxyPacket(MQTTSNPacket* packet) int Client::setProxyPacket(MQTTSNPacket* packet)
{ {
int rc = _proxyPacketQue.post(packet); int rc = _proxyPacketQue.post(packet);
if ( rc ) if (rc)
{ {
WRITELOG("%s %s is Disconnected. the packet was saved.\n", currentDateTime(), _clientId); WRITELOG("%s %s is Disconnected. the packet was saved.\n",
currentDateTime(), _clientId);
} }
else else
{ {
WRITELOG("%s %s is Disconnected and discard the packet.\n", currentDateTime(), _clientId); WRITELOG("%s %s is Disconnected and discard the packet.\n",
currentDateTime(), _clientId);
} }
return rc; return rc;
} }
Connect* Client::getConnectData(void) Connect* Client::getConnectData(void)
{ {
return &_connectData; return &_connectData;
} }
void Client::eraseWaitedPubTopicId(uint16_t msgId) void Client::eraseWaitedPubTopicId(uint16_t msgId)
{ {
_waitedPubTopicIdMap.erase(msgId); _waitedPubTopicIdMap.erase(msgId);
} }
void Client::eraseWaitedSubTopicId(uint16_t msgId) void Client::eraseWaitedSubTopicId(uint16_t msgId)
{ {
_waitedSubTopicIdMap.erase(msgId); _waitedSubTopicIdMap.erase(msgId);
} }
void Client::clearWaitedPubTopicId(void) void Client::clearWaitedPubTopicId(void)
{ {
_waitedPubTopicIdMap.clear(); _waitedPubTopicIdMap.clear();
} }
void Client::clearWaitedSubTopicId(void) void Client::clearWaitedSubTopicId(void)
{ {
_waitedSubTopicIdMap.clear(); _waitedSubTopicIdMap.clear();
} }
void Client::setWaitedPubTopicId(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type) void Client::setWaitedPubTopicId(uint16_t msgId, uint16_t topicId,
MQTTSN_topicTypes type)
{ {
_waitedPubTopicIdMap.add(msgId, topicId, type); _waitedPubTopicIdMap.add(msgId, topicId, type);
} }
void Client::setWaitedSubTopicId(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type) void Client::setWaitedSubTopicId(uint16_t msgId, uint16_t topicId,
MQTTSN_topicTypes type)
{ {
_waitedSubTopicIdMap.add(msgId, topicId, type); _waitedSubTopicIdMap.add(msgId, topicId, type);
} }
bool Client::checkTimeover(void) bool Client::checkTimeover(void)
{ {
return (_status == Cstat_Active && _keepAliveTimer.isTimeup()); return (_status == Cstat_Active && _keepAliveTimer.isTimeup());
} }
void Client::setKeepAlive(MQTTSNPacket* packet) void Client::setKeepAlive(MQTTSNPacket* packet)
{ {
MQTTSNPacket_connectData param; MQTTSNPacket_connectData param;
if (packet->getCONNECT(&param)) if (packet->getCONNECT(&param))
{ {
_keepAliveMsec = param.duration * 1000UL; _keepAliveMsec = param.duration * 1000UL;
_keepAliveTimer.start(_keepAliveMsec * 1.5); _keepAliveTimer.start(_keepAliveMsec * 1.5);
} }
} }
void Client::setForwarder(Forwarder* forwarder) void Client::setForwarder(Forwarder* forwarder)
@@ -214,102 +221,102 @@ Forwarder* Client::getForwarder(void)
void Client::setSessionStatus(bool status) void Client::setSessionStatus(bool status)
{ {
_sessionStatus = status; _sessionStatus = status;
} }
bool Client::erasable(void) bool Client::erasable(void)
{ {
return _sessionStatus && !_hasPredefTopic && _forwarder == nullptr; return _sessionStatus && !_hasPredefTopic && _forwarder == nullptr;
} }
void Client::updateStatus(MQTTSNPacket* packet) void Client::updateStatus(MQTTSNPacket* packet)
{ {
if (((_status == Cstat_Disconnected) || (_status == Cstat_Lost)) && packet->getType() == MQTTSN_CONNECT) if (((_status == Cstat_Disconnected) || (_status == Cstat_Lost))
{ && packet->getType() == MQTTSN_CONNECT)
setKeepAlive(packet); {
} setKeepAlive(packet);
else if (_status == Cstat_Active) }
{ else if (_status == Cstat_Active)
switch (packet->getType()) {
{ switch (packet->getType())
case MQTTSN_PINGREQ: {
case MQTTSN_PUBLISH: case MQTTSN_PINGREQ:
case MQTTSN_SUBSCRIBE: case MQTTSN_PUBLISH:
case MQTTSN_UNSUBSCRIBE: case MQTTSN_SUBSCRIBE:
case MQTTSN_PUBACK: case MQTTSN_UNSUBSCRIBE:
case MQTTSN_PUBCOMP: case MQTTSN_PUBACK:
case MQTTSN_PUBREL: case MQTTSN_PUBCOMP:
case MQTTSN_PUBREC: case MQTTSN_PUBREL:
if ( _clientType != Ctype_Proxy ) case MQTTSN_PUBREC:
{ if (_clientType != Ctype_Proxy)
_keepAliveTimer.start(_keepAliveMsec * 1.5); {
} _keepAliveTimer.start(_keepAliveMsec * 1.5);
break; }
case MQTTSN_DISCONNECT: break;
uint16_t duration; case MQTTSN_DISCONNECT:
packet->getDISCONNECT(&duration); uint16_t duration;
if (duration) packet->getDISCONNECT(&duration);
{ if (duration)
_status = Cstat_Asleep; {
} _status = Cstat_Asleep;
else }
{ else
disconnected(); {
} disconnected();
break; }
default: break;
break; default:
} break;
} }
else if (_status == Cstat_Awake || _status == Cstat_Asleep) }
{ else if (_status == Cstat_Awake || _status == Cstat_Asleep)
switch (packet->getType()) {
{ switch (packet->getType())
case MQTTSN_CONNECT: {
_status = Cstat_Active; case MQTTSN_CONNECT:
break; _status = Cstat_Active;
case MQTTSN_DISCONNECT: break;
disconnected(); case MQTTSN_DISCONNECT:
break; disconnected();
case MQTTSN_PINGREQ: break;
_status = Cstat_Awake; case MQTTSN_PINGREQ:
break; _status = Cstat_Awake;
case MQTTSN_PINGRESP: break;
_status = Cstat_Asleep; case MQTTSN_PINGRESP:
break; _status = Cstat_Asleep;
default: break;
break; default:
} break;
} }
DEBUGLOG("Client Status = %s\n", theClientStatus[_status]); } DEBUGLOG("Client Status = %s\n", theClientStatus[_status]);
} }
void Client::updateStatus(ClientStatus stat) void Client::updateStatus(ClientStatus stat)
{ {
_status = stat; _status = stat;
} }
void Client::connectSended() void Client::connectSended()
{ {
_status = Cstat_Connecting; _status = Cstat_Connecting;
} }
void Client::connackSended(int rc) void Client::connackSended(int rc)
{ {
if (rc == MQTTSN_RC_ACCEPTED) if (rc == MQTTSN_RC_ACCEPTED)
{ {
_status = Cstat_Active; _status = Cstat_Active;
} }
else else
{ {
disconnected(); disconnected();
} }
} }
void Client::disconnected(void) void Client::disconnected(void)
{ {
_status = Cstat_Disconnected; _status = Cstat_Disconnected;
_waitWillMsgFlg = false; _waitWillMsgFlg = false;
} }
void Client::tryConnect(void) void Client::tryConnect(void)
@@ -319,64 +326,64 @@ void Client::tryConnect(void)
bool Client::isConnectSendable(void) bool Client::isConnectSendable(void)
{ {
if ( _status == Cstat_Lost || _status == Cstat_TryConnecting ) if (_status == Cstat_Lost || _status == Cstat_TryConnecting)
{ {
return false; return false;
} }
else else
{ {
return true; return true;
} }
} }
uint16_t Client::getNextPacketId(void) uint16_t Client::getNextPacketId(void)
{ {
_packetId++; _packetId++;
if ( _packetId == 0xffff ) if (_packetId == 0xffff)
{ {
_packetId = 1; _packetId = 1;
} }
return _packetId; return _packetId;
} }
uint8_t Client::getNextSnMsgId(void) uint8_t Client::getNextSnMsgId(void)
{ {
_snMsgId++; _snMsgId++;
if (_snMsgId == 0) if (_snMsgId == 0)
{ {
_snMsgId++; _snMsgId++;
} }
return _snMsgId; return _snMsgId;
} }
Topics* Client::getTopics(void) Topics* Client::getTopics(void)
{ {
return _topics; return _topics;
} }
Network* Client::getNetwork(void) Network* Client::getNetwork(void)
{ {
return _network; return _network;
} }
void Client::setClientAddress(SensorNetAddress* sensorNetAddr) void Client::setClientAddress(SensorNetAddress* sensorNetAddr)
{ {
_sensorNetAddr = *sensorNetAddr; _sensorNetAddr = *sensorNetAddr;
} }
SensorNetAddress* Client::getSensorNetAddress(void) SensorNetAddress* Client::getSensorNetAddress(void)
{ {
return &_sensorNetAddr; return &_sensorNetAddr;
} }
void Client::setSensorNetType(bool stable) void Client::setSensorNetType(bool stable)
{ {
_sensorNetype = stable; _sensorNetype = stable;
} }
void Client::setTopics(Topics* topics) void Client::setTopics(Topics* topics)
{ {
_topics = topics; _topics = topics;
} }
ClientStatus Client::getClientStatus(void) ClientStatus Client::getClientStatus(void)
@@ -386,32 +393,32 @@ ClientStatus Client::getClientStatus(void)
void Client::setWaitWillMsgFlg(bool flg) void Client::setWaitWillMsgFlg(bool flg)
{ {
_waitWillMsgFlg = flg; _waitWillMsgFlg = flg;
} }
bool Client::isWaitWillMsg(void) bool Client::isWaitWillMsg(void)
{ {
return _waitWillMsgFlg; return _waitWillMsgFlg;
} }
bool Client::isDisconnect(void) bool Client::isDisconnect(void)
{ {
return (_status == Cstat_Disconnected); return (_status == Cstat_Disconnected);
} }
bool Client::isActive(void) bool Client::isActive(void)
{ {
return (_status == Cstat_Active); return (_status == Cstat_Active);
} }
bool Client::isSleep(void) bool Client::isSleep(void)
{ {
return (_status == Cstat_Asleep); return (_status == Cstat_Asleep);
} }
bool Client::isAwake(void) bool Client::isAwake(void)
{ {
return (_status == Cstat_Awake); return (_status == Cstat_Awake);
} }
bool Client::isConnecting(void) bool Client::isConnecting(void)
@@ -421,94 +428,94 @@ bool Client::isConnecting(void)
bool Client::isSecureNetwork(void) bool Client::isSecureNetwork(void)
{ {
return _secureNetwork; return _secureNetwork;
} }
bool Client::isSensorNetStable(void) bool Client::isSensorNetStable(void)
{ {
return _sensorNetype; return _sensorNetype;
} }
WaitREGACKPacketList* Client::getWaitREGACKPacketList() WaitREGACKPacketList* Client::getWaitREGACKPacketList()
{ {
return &_waitREGACKList; return &_waitREGACKList;
} }
Client* Client::getNextClient(void) Client* Client::getNextClient(void)
{ {
return _nextClient; return _nextClient;
} }
void Client::setClientId(MQTTSNString id) void Client::setClientId(MQTTSNString id)
{ {
if ( _clientId ) if (_clientId)
{ {
free(_clientId); free(_clientId);
} }
if ( id.cstring ) if (id.cstring)
{ {
_clientId = (char*)calloc(strlen(id.cstring) + 1, 1); _clientId = (char*) calloc(strlen(id.cstring) + 1, 1);
memcpy(_clientId, id.cstring, strlen(id.cstring)); memcpy(_clientId, id.cstring, strlen(id.cstring));
} }
else else
{ {
/* save clientId into (char*)_clientId NULL terminated */ /* save clientId into (char*)_clientId NULL terminated */
_clientId = (char*)calloc(MQTTSNstrlen(id) + 1, 1); _clientId = (char*) calloc(MQTTSNstrlen(id) + 1, 1);
unsigned char* ptr = (unsigned char*)_clientId; unsigned char* ptr = (unsigned char*) _clientId;
writeMQTTSNString((unsigned char**)&ptr, id); writeMQTTSNString((unsigned char**) &ptr, id);
} }
} }
void Client::setWillTopic(MQTTSNString willTopic) void Client::setWillTopic(MQTTSNString willTopic)
{ {
if ( _willTopic ) if (_willTopic)
{ {
free(_willTopic); free(_willTopic);
} }
_willTopic = (char*)calloc(MQTTSNstrlen(willTopic) + 1, 1); _willTopic = (char*) calloc(MQTTSNstrlen(willTopic) + 1, 1);
/* save willTopic into (char*)_willTopic with NULL termination */ /* save willTopic into (char*)_willTopic with NULL termination */
unsigned char* ptr = (unsigned char*)_willTopic; unsigned char* ptr = (unsigned char*) _willTopic;
writeMQTTSNString((unsigned char**)&ptr, willTopic); writeMQTTSNString((unsigned char**) &ptr, willTopic);
} }
void Client::setWillMsg(MQTTSNString willMsg) void Client::setWillMsg(MQTTSNString willMsg)
{ {
if ( _willMsg) if (_willMsg)
{ {
free(_willMsg); free(_willMsg);
} }
_willMsg = (char*)calloc(MQTTSNstrlen(willMsg) + 1, 1); _willMsg = (char*) calloc(MQTTSNstrlen(willMsg) + 1, 1);
/* save willMsg into (char*)_willMsg with NULL termination */ /* save willMsg into (char*)_willMsg with NULL termination */
unsigned char* ptr = (unsigned char*)_willMsg; unsigned char* ptr = (unsigned char*) _willMsg;
writeMQTTSNString((unsigned char**)&ptr, willMsg); writeMQTTSNString((unsigned char**) &ptr, willMsg);
} }
char* Client::getClientId(void) char* Client::getClientId(void)
{ {
return _clientId; return _clientId;
} }
char* Client::getWillTopic(void) char* Client::getWillTopic(void)
{ {
return _willTopic; return _willTopic;
} }
char* Client::getWillMsg(void) char* Client::getWillMsg(void)
{ {
return _willMsg; return _willMsg;
} }
const char* Client::getStatus(void) const char* Client::getStatus(void)
{ {
return theClientStatus[_status]; return theClientStatus[_status];
} }
bool Client::isQoSm1Proxy(void) bool Client::isQoSm1Proxy(void)
{ {
return _clientType == Ctype_Proxy; return _clientType == Ctype_Proxy;
} }
bool Client::isForwarded(void) bool Client::isForwarded(void)
@@ -528,23 +535,23 @@ bool Client::isAggregater(void)
void Client::setAdapterType(AdapterType type) void Client::setAdapterType(AdapterType type)
{ {
switch ( type ) switch (type)
{ {
case Atype_QoSm1Proxy: case Atype_QoSm1Proxy:
_clientType = Ctype_Proxy; _clientType = Ctype_Proxy;
break; break;
case Atype_Aggregater: case Atype_Aggregater:
_clientType = Ctype_Aggregater; _clientType = Ctype_Aggregater;
break; break;
default: default:
throw Exception("Client::setAdapterType(): Invalid Type."); throw Exception("Client::setAdapterType(): Invalid Type.");
break; break;
} }
} }
bool Client::isAdapter(void) bool Client::isAdapter(void)
{ {
return _clientType == Ctype_Proxy || _clientType == Ctype_Aggregater; return _clientType == Ctype_Proxy || _clientType == Ctype_Aggregater;
} }
bool Client::isQoSm1(void) bool Client::isQoSm1(void)
@@ -554,12 +561,12 @@ bool Client::isQoSm1(void)
void Client::setQoSm1(void) void Client::setQoSm1(void)
{ {
_clientType = Ctype_QoS_1; _clientType = Ctype_QoS_1;
} }
void Client::setAggregated(void) void Client::setAggregated(void)
{ {
_clientType = Ctype_Aggregated; _clientType = Ctype_Aggregated;
} }
void Client::holdPingRequest(void) void Client::holdPingRequest(void)
@@ -577,22 +584,20 @@ bool Client::isHoldPingReqest(void)
return _holdPingRequest; return _holdPingRequest;
} }
/*===================================== /*=====================================
Class WaitREGACKPacket Class WaitREGACKPacket
=====================================*/ =====================================*/
waitREGACKPacket::waitREGACKPacket(MQTTSNPacket* packet, uint16_t REGACKMsgId) waitREGACKPacket::waitREGACKPacket(MQTTSNPacket* packet, uint16_t REGACKMsgId)
{ {
_packet = packet; _packet = packet;
_msgId = REGACKMsgId; _msgId = REGACKMsgId;
_next = nullptr; _next = nullptr;
_prev = nullptr; _prev = nullptr;
} }
waitREGACKPacket::~waitREGACKPacket() waitREGACKPacket::~waitREGACKPacket()
{ {
delete _packet; delete _packet;
} }
/*===================================== /*=====================================
@@ -601,89 +606,89 @@ waitREGACKPacket::~waitREGACKPacket()
WaitREGACKPacketList::WaitREGACKPacketList() WaitREGACKPacketList::WaitREGACKPacketList()
{ {
_first = nullptr; _first = nullptr;
_end = nullptr; _end = nullptr;
_cnt = 0; _cnt = 0;
} }
WaitREGACKPacketList::~WaitREGACKPacketList() WaitREGACKPacketList::~WaitREGACKPacketList()
{ {
waitREGACKPacket* p = _first; waitREGACKPacket* p = _first;
while (p) while (p)
{ {
waitREGACKPacket* q = p->_next; waitREGACKPacket* q = p->_next;
delete p; delete p;
p = q; p = q;
} }
} }
int WaitREGACKPacketList::setPacket(MQTTSNPacket* packet, uint16_t REGACKMsgId) int WaitREGACKPacketList::setPacket(MQTTSNPacket* packet, uint16_t REGACKMsgId)
{ {
waitREGACKPacket* elm = new waitREGACKPacket(packet, REGACKMsgId); waitREGACKPacket* elm = new waitREGACKPacket(packet, REGACKMsgId);
if (elm == nullptr) if (elm == nullptr)
{ {
return 0; return 0;
} }
if (_first == nullptr) if (_first == nullptr)
{ {
_first = elm; _first = elm;
_end = elm; _end = elm;
} }
else else
{ {
_end->_next = elm; _end->_next = elm;
elm->_prev = _end; elm->_prev = _end;
_end = elm; _end = elm;
} }
_cnt++; _cnt++;
return 1; return 1;
} }
MQTTSNPacket* WaitREGACKPacketList::getPacket(uint16_t REGACKMsgId) MQTTSNPacket* WaitREGACKPacketList::getPacket(uint16_t REGACKMsgId)
{ {
waitREGACKPacket* p = _first; waitREGACKPacket* p = _first;
while (p) while (p)
{ {
if (p->_msgId == REGACKMsgId) if (p->_msgId == REGACKMsgId)
{ {
return p->_packet; return p->_packet;
} }
p = p->_next; p = p->_next;
} }
return nullptr; return nullptr;
} }
void WaitREGACKPacketList::erase(uint16_t REGACKMsgId) void WaitREGACKPacketList::erase(uint16_t REGACKMsgId)
{ {
waitREGACKPacket* p = _first; waitREGACKPacket* p = _first;
while (p) while (p)
{ {
if (p->_msgId == REGACKMsgId) if (p->_msgId == REGACKMsgId)
{ {
if (p->_prev == nullptr) if (p->_prev == nullptr)
{ {
_first = p->_next; _first = p->_next;
} }
else else
{ {
p->_prev->_next = p->_next; p->_prev->_next = p->_next;
} }
if (p->_next == nullptr) if (p->_next == nullptr)
{ {
_end = p->_prev; _end = p->_prev;
} }
else else
{ {
p->_next->_prev = p->_prev; p->_next->_prev = p->_prev;
} }
_cnt--; _cnt--;
break; break;
// Do not delete element. Element is deleted after sending to Client. // Do not delete element. Element is deleted after sending to Client.
} }
p = p->_next; p = p->_next;
} }
} }
uint8_t WaitREGACKPacketList::getCount(void) uint8_t WaitREGACKPacketList::getCount(void)
@@ -691,4 +696,3 @@ uint8_t WaitREGACKPacketList::getCount(void)
return _cnt; return _cnt;
} }

39
MQTTSNGateway/src/MQTTSNGWClient.h
View File

@@ -49,7 +49,6 @@ public:
_que = new Que<T>; _que = new Que<T>;
} }
~PacketQue() ~PacketQue()
{ {
clear(); clear();
@@ -72,8 +71,7 @@ public:
} }
} }
int int post(T* packet)
post(T* packet)
{ {
int rc; int rc;
_mutex.lock(); _mutex.lock();
@@ -113,8 +111,6 @@ private:
Mutex _mutex; Mutex _mutex;
}; };
/*===================================== /*=====================================
Class WaitREGACKPacket Class WaitREGACKPacket
=====================================*/ =====================================*/
@@ -151,20 +147,29 @@ private:
waitREGACKPacket* _end; waitREGACKPacket* _end;
}; };
/*===================================== /*=====================================
Class Client Class Client
=====================================*/ =====================================*/
typedef enum typedef enum
{ {
Cstat_Disconnected = 0, Cstat_TryConnecting, Cstat_Connecting, Cstat_Active, Cstat_Asleep, Cstat_Awake, Cstat_Lost Cstat_Disconnected = 0,
Cstat_TryConnecting,
Cstat_Connecting,
Cstat_Active,
Cstat_Asleep,
Cstat_Awake,
Cstat_Lost
} ClientStatus; } ClientStatus;
typedef enum typedef enum
{ {
Ctype_Regular = 0, Ctype_Forwarded, Ctype_QoS_1, Ctype_Aggregated, Ctype_Proxy, Ctype_Aggregater Ctype_Regular = 0,
}ClientType; Ctype_Forwarded,
Ctype_QoS_1,
Ctype_Aggregated,
Ctype_Proxy,
Ctype_Aggregater
} ClientType;
class Forwarder; class Forwarder;
@@ -191,10 +196,12 @@ public:
void clearWaitedPubTopicId(void); void clearWaitedPubTopicId(void);
void clearWaitedSubTopicId(void); void clearWaitedSubTopicId(void);
int setClientSleepPacket(MQTTGWPacket*); int setClientSleepPacket(MQTTGWPacket*);
int setProxyPacket(MQTTSNPacket* packet); int setProxyPacket(MQTTSNPacket* packet);
void setWaitedPubTopicId(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type); void setWaitedPubTopicId(uint16_t msgId, uint16_t topicId,
void setWaitedSubTopicId(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type); MQTTSN_topicTypes type);
void setWaitedSubTopicId(uint16_t msgId, uint16_t topicId,
MQTTSN_topicTypes type);
bool checkTimeover(void); bool checkTimeover(void);
void updateStatus(MQTTSNPacket*); void updateStatus(MQTTSNPacket*);
@@ -260,7 +267,7 @@ private:
PacketQue<MQTTGWPacket> _clientSleepPacketQue; PacketQue<MQTTGWPacket> _clientSleepPacketQue;
PacketQue<MQTTSNPacket> _proxyPacketQue; PacketQue<MQTTSNPacket> _proxyPacketQue;
WaitREGACKPacketList _waitREGACKList; WaitREGACKPacketList _waitREGACKList;
Topics* _topics; Topics* _topics;
TopicIdMap _waitedPubTopicIdMap; TopicIdMap _waitedPubTopicIdMap;
@@ -285,7 +292,7 @@ private:
uint8_t _snMsgId; uint8_t _snMsgId;
Network* _network; // Broker Network* _network; // Broker
bool _secureNetwork; // SSL bool _secureNetwork; // SSL
bool _sensorNetype; // false: unstable network like a G3 bool _sensorNetype; // false: unstable network like a G3
SensorNetAddress _sensorNetAddr; SensorNetAddress _sensorNetAddr;
@@ -299,7 +306,5 @@ private:
Client* _prevClient; Client* _prevClient;
}; };
} }
#endif /* MQTTSNGWCLIENT_H_ */ #endif /* MQTTSNGWCLIENT_H_ */

246
MQTTSNGateway/src/MQTTSNGWClientList.cpp
View File

@@ -51,38 +51,41 @@ ClientList::~ClientList()
void ClientList::initialize(bool aggregate) void ClientList::initialize(bool aggregate)
{ {
if (theGateway->getGWParams()->clientAuthentication ) if (theGateway->getGWParams()->clientAuthentication)
{ {
int type = TRANSPEARENT_TYPE; int type = TRANSPEARENT_TYPE;
if ( aggregate ) if (aggregate)
{ {
type = AGGREGATER_TYPE; type = AGGREGATER_TYPE;
} }
setClientList(type); setClientList(type);
_authorize = true; _authorize = true;
} }
if ( theGateway->getGWParams()->predefinedTopic ) if (theGateway->getGWParams()->predefinedTopic)
{ {
setPredefinedTopics(aggregate); setPredefinedTopics(aggregate);
} }
} }
void ClientList::setClientList(int type) void ClientList::setClientList(int type)
{ {
if (!createList(theGateway->getGWParams()->clientListName, type)) if (!createList(theGateway->getGWParams()->clientListName, type))
{ {
throw Exception("ClientList::setClientList No client list defined by config file."); throw Exception(
} "ClientList::setClientList No client list defined by config file.");
}
} }
void ClientList::setPredefinedTopics(bool aggrecate) void ClientList::setPredefinedTopics(bool aggrecate)
{ {
if ( !readPredefinedList(theGateway->getGWParams()->predefinedTopicFileName, aggrecate) ) if (!readPredefinedList(theGateway->getGWParams()->predefinedTopicFileName,
{ aggrecate))
throw Exception("ClientList::setPredefinedTopics No predefindTopi list defined by config file."); {
throw Exception(
"ClientList::setPredefinedTopics No predefindTopi list defined by config file.");
} }
} }
/** /**
@@ -148,17 +151,19 @@ bool ClientList::createList(const char* fileName, int type)
forwarder = (data.find("forwarder") != string::npos); forwarder = (data.find("forwarder") != string::npos);
secure = (data.find("secureConnection") != string::npos); secure = (data.find("secureConnection") != string::npos);
stable = !(data.find("unstableLine") != string::npos); stable = !(data.find("unstableLine") != string::npos);
if ( (qos_1 && type == QOSM1PROXY_TYPE) || (!qos_1 && type == AGGREGATER_TYPE) ) if ((qos_1 && type == QOSM1PROXY_TYPE)
|| (!qos_1 && type == AGGREGATER_TYPE))
{ {
createClient(&netAddr, &clientId, stable, secure, type); createClient(&netAddr, &clientId, stable, secure, type);
} }
else if ( forwarder && type == FORWARDER_TYPE) else if (forwarder && type == FORWARDER_TYPE)
{ {
theGateway->getAdapterManager()->getForwarderList()->addForwarder(&netAddr, &clientId); theGateway->getAdapterManager()->getForwarderList()->addForwarder(
&netAddr, &clientId);
} }
else if (type == TRANSPEARENT_TYPE ) else if (type == TRANSPEARENT_TYPE)
{ {
createClient(&netAddr, &clientId, stable, secure, type); createClient(&netAddr, &clientId, stable, secure, type);
} }
} }
else else
@@ -179,7 +184,8 @@ bool ClientList::readPredefinedList(const char* fileName, bool aggregate)
FILE* fp; FILE* fp;
char buf[MAX_CLIENTID_LENGTH + 256]; char buf[MAX_CLIENTID_LENGTH + 256];
size_t pos0, pos1; size_t pos0, pos1;
MQTTSNString clientId = MQTTSNString_initializer;; MQTTSNString clientId = MQTTSNString_initializer;
;
bool rc = false; bool rc = false;
if ((fp = fopen(fileName, "r")) != 0) if ((fp = fopen(fileName, "r")) != 0)
@@ -201,12 +207,12 @@ bool ClientList::readPredefinedList(const char* fileName, bool aggregate)
} }
pos0 = data.find_first_of(","); pos0 = data.find_first_of(",");
pos1 = data.find(",", pos0 + 1) ; pos1 = data.find(",", pos0 + 1);
string id = data.substr(0, pos0); string id = data.substr(0, pos0);
clientId.cstring = strdup(id.c_str()); clientId.cstring = strdup(id.c_str());
string topicName = data.substr(pos0 + 1, pos1 - pos0 -1); string topicName = data.substr(pos0 + 1, pos1 - pos0 - 1);
uint16_t topicID = stoul(data.substr(pos1 + 1)); uint16_t topicID = stoul(data.substr(pos1 + 1));
createPredefinedTopic( &clientId, topicName, topicID, aggregate); createPredefinedTopic(&clientId, topicName, topicID, aggregate);
free(clientId.cstring); free(clientId.cstring);
} }
fclose(fp); fclose(fp);
@@ -214,7 +220,8 @@ bool ClientList::readPredefinedList(const char* fileName, bool aggregate)
} }
else else
{ {
WRITELOG("ClientList can not open the Predefined Topic List. %s\n", fileName); WRITELOG("ClientList can not open the Predefined Topic List. %s\n",
fileName);
return false; return false;
} }
return rc; return rc;
@@ -222,7 +229,7 @@ bool ClientList::readPredefinedList(const char* fileName, bool aggregate)
void ClientList::erase(Client*& client) void ClientList::erase(Client*& client)
{ {
if ( !_authorize && client->erasable()) if (!_authorize && client->erasable())
{ {
_mutex.lock(); _mutex.lock();
Client* prev = client->_prevClient; Client* prev = client->_prevClient;
@@ -247,7 +254,7 @@ void ClientList::erase(Client*& client)
} }
_clientCnt--; _clientCnt--;
Forwarder* fwd = client->getForwarder(); Forwarder* fwd = client->getForwarder();
if ( fwd ) if (fwd)
{ {
fwd->eraseClient(client); fwd->eraseClient(client);
} }
@@ -259,14 +266,14 @@ void ClientList::erase(Client*& client)
Client* ClientList::getClient(SensorNetAddress* addr) Client* ClientList::getClient(SensorNetAddress* addr)
{ {
if ( addr ) if (addr)
{ {
_mutex.lock(); _mutex.lock();
Client* client = _firstClient; Client* client = _firstClient;
while (client != nullptr) while (client != nullptr)
{ {
if (client->getSensorNetAddress()->isMatch(addr) ) if (client->getSensorNetAddress()->isMatch(addr))
{ {
_mutex.unlock(); _mutex.unlock();
return client; return client;
@@ -280,38 +287,38 @@ Client* ClientList::getClient(SensorNetAddress* addr)
Client* ClientList::getClient(int index) Client* ClientList::getClient(int index)
{ {
Client* client = _firstClient; Client* client = _firstClient;
int p = 0; int p = 0;
while ( client != nullptr ) while (client != nullptr)
{ {
if ( p == index ) if (p == index)
{ {
return client; return client;
} }
else else
{ {
client = client->_nextClient; client = client->_nextClient;
p++; p++;
} }
} }
return nullptr; return nullptr;
} }
Client* ClientList::getClient(MQTTSNString* clientId) Client* ClientList::getClient(MQTTSNString* clientId)
{ {
_mutex.lock(); _mutex.lock();
Client* client = _firstClient; Client* client = _firstClient;
const char* clID =clientId->cstring; const char* clID = clientId->cstring;
if (clID == nullptr ) if (clID == nullptr)
{ {
clID = clientId->lenstring.data; clID = clientId->lenstring.data;
} }
while (client != nullptr) while (client != nullptr)
{ {
if (strncmp((const char*)client->getClientId(), clID, MQTTSNstrlen(*clientId)) == 0 ) if (strncmp((const char*) client->getClientId(), clID,
MQTTSNstrlen(*clientId)) == 0)
{ {
_mutex.unlock(); _mutex.unlock();
return client; return client;
@@ -322,51 +329,53 @@ Client* ClientList::getClient(MQTTSNString* clientId)
return 0; return 0;
} }
Client* ClientList::createClient(SensorNetAddress* addr, MQTTSNString* clientId, int type) Client* ClientList::createClient(SensorNetAddress* addr, MQTTSNString* clientId,
int type)
{ {
return createClient(addr, clientId, false, false, type); return createClient(addr, clientId, false, false, type);
} }
Client* ClientList::createClient(SensorNetAddress* addr, MQTTSNString* clientId, bool unstableLine, bool secure, int type) Client* ClientList::createClient(SensorNetAddress* addr, MQTTSNString* clientId,
bool unstableLine, bool secure, int type)
{ {
Client* client = nullptr; Client* client = nullptr;
/* anonimous clients */ /* anonimous clients */
if ( _clientCnt > MAX_CLIENTS ) if (_clientCnt > MAX_CLIENTS)
{ {
return 0; // full of clients return 0; // full of clients
} }
client = getClient(addr); client = getClient(addr);
if ( client ) if (client)
{ {
return client; return client;
} }
/* creat a new client */ /* creat a new client */
client = new Client(secure); client = new Client(secure);
if ( addr ) if (addr)
{ {
client->setClientAddress(addr); client->setClientAddress(addr);
} }
client->setSensorNetType(unstableLine); client->setSensorNetType(unstableLine);
if ( MQTTSNstrlen(*clientId) ) if (MQTTSNstrlen(*clientId))
{ {
client->setClientId(*clientId); client->setClientId(*clientId);
} }
else else
{ {
MQTTSNString dummyId MQTTSNString_initializer; MQTTSNString dummyId MQTTSNString_initializer;
dummyId.cstring = strdup(""); dummyId.cstring = strdup("");
client->setClientId(dummyId); client->setClientId(dummyId);
free(dummyId.cstring); free(dummyId.cstring);
} }
if ( type == AGGREGATER_TYPE ) if (type == AGGREGATER_TYPE)
{ {
client->setAggregated(); client->setAggregated();
} }
else if ( type == QOSM1PROXY_TYPE ) else if (type == QOSM1PROXY_TYPE)
{ {
client->setQoSm1(); client->setQoSm1();
} }
@@ -374,7 +383,7 @@ Client* ClientList::createClient(SensorNetAddress* addr, MQTTSNString* clientId,
_mutex.lock(); _mutex.lock();
/* add the list */ /* add the list */
if ( _firstClient == nullptr ) if (_firstClient == nullptr)
{ {
_firstClient = client; _firstClient = client;
_endClient = client; _endClient = client;
@@ -390,66 +399,68 @@ Client* ClientList::createClient(SensorNetAddress* addr, MQTTSNString* clientId,
return client; return client;
} }
Client* ClientList::createPredefinedTopic( MQTTSNString* clientId, string topicName, uint16_t topicId, bool aggregate) Client* ClientList::createPredefinedTopic(MQTTSNString* clientId,
string topicName, uint16_t topicId, bool aggregate)
{ {
if ( topicId == 0 ) if (topicId == 0)
{ {
WRITELOG("Invalid TopicId. Predefined Topic %s, TopicId is 0. \n", topicName.c_str()); WRITELOG("Invalid TopicId. Predefined Topic %s, TopicId is 0. \n",
return nullptr; topicName.c_str());
} return nullptr;
}
if ( strcmp(clientId->cstring, common_topic) == 0 ) if (strcmp(clientId->cstring, common_topic) == 0)
{ {
theGateway->getTopics()->add((const char*)topicName.c_str(), topicId); theGateway->getTopics()->add((const char*) topicName.c_str(), topicId);
return nullptr; return nullptr;
} }
else else
{ {
Client* client = getClient(clientId); Client* client = getClient(clientId);
if ( _authorize && client == nullptr ) if (_authorize && client == nullptr)
{ {
return nullptr; return nullptr;
} }
/* anonimous clients */ /* anonimous clients */
if ( _clientCnt > MAX_CLIENTS ) if (_clientCnt > MAX_CLIENTS)
{ {
return nullptr; // full of clients return nullptr; // full of clients
} }
if ( client == nullptr ) if (client == nullptr)
{ {
/* creat a new client */ /* creat a new client */
client = new Client(); client = new Client();
client->setClientId(*clientId); client->setClientId(*clientId);
if ( aggregate ) if (aggregate)
{ {
client->setAggregated(); client->setAggregated();
} }
_mutex.lock(); _mutex.lock();
/* add the list */ /* add the list */
if ( _firstClient == nullptr ) if (_firstClient == nullptr)
{ {
_firstClient = client; _firstClient = client;
_endClient = client; _endClient = client;
} }
else else
{ {
_endClient->_nextClient = client; _endClient->_nextClient = client;
client->_prevClient = _endClient; client->_prevClient = _endClient;
_endClient = client; _endClient = client;
} }
_clientCnt++; _clientCnt++;
_mutex.unlock(); _mutex.unlock();
} }
// create Topic & Add it // create Topic & Add it
client->getTopics()->add((const char*)topicName.c_str(), topicId); client->getTopics()->add((const char*) topicName.c_str(), topicId);
client->_hasPredefTopic = true; client->_hasPredefTopic = true;
return client; return client;
} }
} }
uint16_t ClientList::getClientCount() uint16_t ClientList::getClientCount()
@@ -462,4 +473,3 @@ bool ClientList::isAuthorized()
return _authorize; return _authorize;
} }

16
MQTTSNGateway/src/MQTTSNGWClientList.h
View File

@@ -43,8 +43,10 @@ public:
void setClientList(int type); void setClientList(int type);
void setPredefinedTopics(bool aggregate); void setPredefinedTopics(bool aggregate);
void erase(Client*&); void erase(Client*&);
Client* createClient(SensorNetAddress* addr, MQTTSNString* clientId,int type); Client* createClient(SensorNetAddress* addr, MQTTSNString* clientId,
Client* createClient(SensorNetAddress* addr, MQTTSNString* clientId, bool unstableLine, bool secure, int type); int type);
Client* createClient(SensorNetAddress* addr, MQTTSNString* clientId,
bool unstableLine, bool secure, int type);
bool createList(const char* fileName, int type); bool createList(const char* fileName, int type);
Client* getClient(SensorNetAddress* addr); Client* getClient(SensorNetAddress* addr);
Client* getClient(MQTTSNString* clientId); Client* getClient(MQTTSNString* clientId);
@@ -55,18 +57,16 @@ public:
private: private:
bool readPredefinedList(const char* fileName, bool _aggregate); bool readPredefinedList(const char* fileName, bool _aggregate);
Gateway* _gateway {nullptr}; Gateway* _gateway { nullptr };
Client* createPredefinedTopic( MQTTSNString* clientId, string topicName, uint16_t toipcId, bool _aggregate); Client* createPredefinedTopic(MQTTSNString* clientId, string topicName,
uint16_t toipcId, bool _aggregate);
Client* _firstClient; Client* _firstClient;
Client* _endClient; Client* _endClient;
Mutex _mutex; Mutex _mutex;
uint16_t _clientCnt; uint16_t _clientCnt;
bool _authorize {false}; bool _authorize { false };
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWCLIENTLIST_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWCLIENTLIST_H_ */

406
MQTTSNGateway/src/MQTTSNGWClientRecvTask.cpp
View File

@@ -29,9 +29,9 @@ char* currentDateTime(void);
=====================================*/ =====================================*/
ClientRecvTask::ClientRecvTask(Gateway* gateway) ClientRecvTask::ClientRecvTask(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
_gateway->attach((Thread*)this); _gateway->attach((Thread*) this);
_sensorNetwork = _gateway->getSensorNetwork(); _sensorNetwork = _gateway->getSensorNetwork();
} }
ClientRecvTask::~ClientRecvTask() ClientRecvTask::~ClientRecvTask()
@@ -44,10 +44,10 @@ ClientRecvTask::~ClientRecvTask()
*/ */
void ClientRecvTask::initialize(int argc, char** argv) void ClientRecvTask::initialize(int argc, char** argv)
{ {
if ( _sensorNetwork->initialize() < 0 ) if (_sensorNetwork->initialize() < 0)
{ {
throw Exception(" Can't open the sensor network.\n"); throw Exception(" Can't open the sensor network.\n");
} }
} }
/* /*
@@ -57,214 +57,237 @@ void ClientRecvTask::initialize(int argc, char** argv)
*/ */
void ClientRecvTask::run() void ClientRecvTask::run()
{ {
Event* ev = nullptr; Event* ev = nullptr;
AdapterManager* adpMgr = _gateway->getAdapterManager(); AdapterManager* adpMgr = _gateway->getAdapterManager();
QoSm1Proxy* qosm1Proxy = adpMgr->getQoSm1Proxy(); QoSm1Proxy* qosm1Proxy = adpMgr->getQoSm1Proxy();
int clientType = adpMgr->isAggregaterActive() ? AGGREGATER_TYPE : TRANSPEARENT_TYPE; int clientType =
ClientList* clientList = _gateway->getClientList(); adpMgr->isAggregaterActive() ? AGGREGATER_TYPE : TRANSPEARENT_TYPE;
EventQue* packetEventQue = _gateway->getPacketEventQue(); ClientList* clientList = _gateway->getClientList();
EventQue* packetEventQue = _gateway->getPacketEventQue();
char buf[128]; char buf[128];
while (true) while (true)
{ {
Client* client = nullptr; Client* client = nullptr;
Forwarder* fwd = nullptr; Forwarder* fwd = nullptr;
WirelessNodeId nodeId; WirelessNodeId nodeId;
MQTTSNPacket* packet = new MQTTSNPacket(); MQTTSNPacket* packet = new MQTTSNPacket();
int packetLen = packet->recv(_sensorNetwork); int packetLen = packet->recv(_sensorNetwork);
if (CHK_SIGINT) if (CHK_SIGINT)
{ {
WRITELOG("\n%s ClientRecvTask stopped.", currentDateTime()); WRITELOG("\n%s ClientRecvTask stopped.", currentDateTime());
delete packet; delete packet;
return; return;
} }
if (packetLen < 2 ) if (packetLen < 2)
{ {
delete packet; delete packet;
continue; continue;
} }
if ( packet->getType() <= MQTTSN_ADVERTISE || packet->getType() == MQTTSN_GWINFO ) if (packet->getType() <= MQTTSN_ADVERTISE
{ || packet->getType() == MQTTSN_GWINFO)
delete packet; {
continue; delete packet;
} continue;
}
if ( packet->getType() == MQTTSN_SEARCHGW ) if (packet->getType() == MQTTSN_SEARCHGW)
{ {
/* write log and post Event */ /* write log and post Event */
log(0, packet, 0); log(0, packet, 0);
ev = new Event(); ev = new Event();
ev->setBrodcastEvent(packet); ev->setBrodcastEvent(packet);
packetEventQue->post(ev); packetEventQue->post(ev);
continue; continue;
} }
SensorNetAddress* senderAddr =
_gateway->getSensorNetwork()->getSenderAddress();
SensorNetAddress* senderAddr = _gateway->getSensorNetwork()->getSenderAddress(); if (packet->getType() == MQTTSN_ENCAPSULATED)
{
fwd =
_gateway->getAdapterManager()->getForwarderList()->getForwarder(
senderAddr);
if ( packet->getType() == MQTTSN_ENCAPSULATED ) if (fwd != nullptr)
{ {
fwd = _gateway->getAdapterManager()->getForwarderList()->getForwarder(senderAddr); MQTTSNString fwdName = MQTTSNString_initializer;
fwdName.cstring = const_cast<char *>(fwd->getName());
log(0, packet, &fwdName);
if ( fwd != nullptr ) /* get the packet from the encapsulation message */
{ MQTTSNGWEncapsulatedPacket encap;
MQTTSNString fwdName = MQTTSNString_initializer; encap.desirialize(packet->getPacketData(),
fwdName.cstring = const_cast<char *>( fwd->getName() ); packet->getPacketLength());
log(0, packet, &fwdName); nodeId.setId(encap.getWirelessNodeId());
client = fwd->getClient(&nodeId);
packet = encap.getMQTTSNPacket();
}
}
else
{
/* Check the client belonging to QoS-1Proxy ? */
/* get the packet from the encapsulation message */ if (qosm1Proxy->isActive())
MQTTSNGWEncapsulatedPacket encap; {
encap.desirialize(packet->getPacketData(), packet->getPacketLength()); const char* clientName = qosm1Proxy->getClientId(senderAddr);
nodeId.setId( encap.getWirelessNodeId() );
client = fwd->getClient(&nodeId);
packet = encap.getMQTTSNPacket();
}
}
else
{
/* Check the client belonging to QoS-1Proxy ? */
if ( qosm1Proxy->isActive() ) if (clientName != nullptr)
{ {
const char* clientName = qosm1Proxy->getClientId(senderAddr); client = qosm1Proxy->getClient();
if ( clientName != nullptr ) if (!packet->isQoSMinusPUBLISH())
{ {
client = qosm1Proxy->getClient(); log(clientName, packet);
WRITELOG(
"%s %s %s can send only PUBLISH with QoS-1.%s\n",
ERRMSG_HEADER, clientName,
senderAddr->sprint(buf), ERRMSG_FOOTER);
delete packet;
continue;
}
}
}
if ( !packet->isQoSMinusPUBLISH() ) if (client == nullptr)
{ {
log(clientName, packet); client = _gateway->getClientList()->getClient(senderAddr);
WRITELOG("%s %s %s can send only PUBLISH with QoS-1.%s\n", ERRMSG_HEADER, clientName, senderAddr->sprint(buf), ERRMSG_FOOTER); }
delete packet; }
continue;
}
}
}
if ( client == nullptr ) if (client != nullptr)
{ {
client = _gateway->getClientList()->getClient(senderAddr); /* write log and post Event */
} log(client, packet, 0);
} ev = new Event();
ev->setClientRecvEvent(client, packet);
packetEventQue->post(ev);
}
else
{
/* new client */
if (packet->getType() == MQTTSN_CONNECT)
{
MQTTSNPacket_connectData data;
memset(&data, 0, sizeof(MQTTSNPacket_connectData));
if (!packet->getCONNECT(&data))
{
log(0, packet, &data.clientID);
WRITELOG("%s CONNECT message form %s is incorrect.%s\n",
ERRMSG_HEADER, senderAddr->sprint(buf),
ERRMSG_FOOTER);
delete packet;
continue;
}
if ( client != nullptr ) client = clientList->getClient(&data.clientID);
{
/* write log and post Event */
log(client, packet, 0);
ev = new Event();
ev->setClientRecvEvent(client,packet);
packetEventQue->post(ev);
}
else
{
/* new client */
if (packet->getType() == MQTTSN_CONNECT)
{
MQTTSNPacket_connectData data;
memset(&data, 0, sizeof(MQTTSNPacket_connectData));
if ( !packet->getCONNECT(&data) )
{
log(0, packet, &data.clientID);
WRITELOG("%s CONNECT message form %s is incorrect.%s\n", ERRMSG_HEADER, senderAddr->sprint(buf), ERRMSG_FOOTER);
delete packet;
continue;
}
client = clientList->getClient(&data.clientID); if (fwd != nullptr)
{
if ( fwd != nullptr ) if (client == nullptr)
{ {
if ( client == nullptr ) /* create a new client */
{ client = clientList->createClient(0, &data.clientID,
/* create a new client */ clientType);
client = clientList->createClient(0, &data.clientID, clientType); }
} /* Add to a forwarded client list of forwarder. */
/* Add to a forwarded client list of forwarder. */
fwd->addClient(client, &nodeId); fwd->addClient(client, &nodeId);
} }
else else
{ {
if ( client ) if (client)
{ {
/* Authentication is not required */ /* Authentication is not required */
if ( _gateway->getGWParams()->clientAuthentication == false) if (_gateway->getGWParams()->clientAuthentication
{ == false)
client->setClientAddress(senderAddr); {
} client->setClientAddress(senderAddr);
}
} }
else else
{ {
/* create a new client */ /* create a new client */
client = clientList->createClient(senderAddr, &data.clientID, clientType); client = clientList->createClient(senderAddr,
&data.clientID, clientType);
} }
} }
log(client, packet, &data.clientID); log(client, packet, &data.clientID);
if ( client == nullptr ) if (client == nullptr)
{ {
WRITELOG("%s Client(%s) was rejected. CONNECT message has been discarded.%s\n", ERRMSG_HEADER, senderAddr->sprint(buf), ERRMSG_FOOTER); WRITELOG(
delete packet; "%s Client(%s) was rejected. CONNECT message has been discarded.%s\n",
continue; ERRMSG_HEADER, senderAddr->sprint(buf),
} ERRMSG_FOOTER);
delete packet;
continue;
}
/* post Client RecvEvent */ /* post Client RecvEvent */
ev = new Event(); ev = new Event();
ev->setClientRecvEvent(client, packet); ev->setClientRecvEvent(client, packet);
packetEventQue->post(ev); packetEventQue->post(ev);
} }
else else
{ {
log(client, packet, 0); log(client, packet, 0);
if ( packet->getType() == MQTTSN_ENCAPSULATED ) if (packet->getType() == MQTTSN_ENCAPSULATED)
{ {
WRITELOG("%s MQTTSNGWClientRecvTask Forwarder(%s) is not declared by ClientList file. message has been discarded.%s\n", ERRMSG_HEADER, _sensorNetwork->getSenderAddress()->sprint(buf), ERRMSG_FOOTER); WRITELOG(
} "%s MQTTSNGWClientRecvTask Forwarder(%s) is not declared by ClientList file. message has been discarded.%s\n",
else ERRMSG_HEADER,
{ _sensorNetwork->getSenderAddress()->sprint(buf),
WRITELOG("%s MQTTSNGWClientRecvTask Client(%s) is not connecting. message has been discarded.%s\n", ERRMSG_HEADER, senderAddr->sprint(buf), ERRMSG_FOOTER); ERRMSG_FOOTER);
} }
delete packet; else
} {
} WRITELOG(
} "%s MQTTSNGWClientRecvTask Client(%s) is not connecting. message has been discarded.%s\n",
ERRMSG_HEADER, senderAddr->sprint(buf),
ERRMSG_FOOTER);
}
delete packet;
}
}
}
} }
void ClientRecvTask::log(Client* client, MQTTSNPacket* packet, MQTTSNString* id) void ClientRecvTask::log(Client* client, MQTTSNPacket* packet, MQTTSNString* id)
{ {
const char* clientId; const char* clientId;
char cstr[MAX_CLIENTID_LENGTH + 1]; char cstr[MAX_CLIENTID_LENGTH + 1];
if ( id ) if (id)
{ {
if ( id->cstring ) if (id->cstring)
{ {
strncpy(cstr, id->cstring, strlen(id->cstring) ); strncpy(cstr, id->cstring, strlen(id->cstring));
clientId = cstr;
}
else
{
memset((void*)cstr, 0, id->lenstring.len + 1);
strncpy(cstr, id->lenstring.data, id->lenstring.len );
clientId = cstr; clientId = cstr;
} }
} else
else if ( client ) {
{ memset((void*) cstr, 0, id->lenstring.len + 1);
clientId = client->getClientId(); strncpy(cstr, id->lenstring.data, id->lenstring.len);
} clientId = cstr;
else }
{ }
clientId = UNKNOWNCL; else if (client)
} {
clientId = client->getClientId();
}
else
{
clientId = UNKNOWNCL;
}
log(clientId, packet); log(clientId, packet);
} }
void ClientRecvTask::log(const char* clientId, MQTTSNPacket* packet) void ClientRecvTask::log(const char* clientId, MQTTSNPacket* packet)
@@ -275,37 +298,46 @@ void ClientRecvTask::log(const char* clientId, MQTTSNPacket* packet)
switch (packet->getType()) switch (packet->getType())
{ {
case MQTTSN_SEARCHGW: case MQTTSN_SEARCHGW:
WRITELOG(FORMAT_Y_G_G_NL, currentDateTime(), packet->getName(), LEFTARROW, CLIENT, packet->print(pbuf)); WRITELOG(FORMAT_Y_G_G_NL, currentDateTime(), packet->getName(),
LEFTARROW, CLIENT, packet->print(pbuf));
break; break;
case MQTTSN_CONNECT: case MQTTSN_CONNECT:
case MQTTSN_PINGREQ: case MQTTSN_PINGREQ:
WRITELOG(FORMAT_Y_G_G_NL, currentDateTime(), packet->getName(), LEFTARROW, clientId, packet->print(pbuf)); WRITELOG(FORMAT_Y_G_G_NL, currentDateTime(), packet->getName(),
LEFTARROW, clientId, packet->print(pbuf));
break; break;
case MQTTSN_DISCONNECT: case MQTTSN_DISCONNECT:
case MQTTSN_WILLTOPICUPD: case MQTTSN_WILLTOPICUPD:
case MQTTSN_WILLMSGUPD: case MQTTSN_WILLMSGUPD:
case MQTTSN_WILLTOPIC: case MQTTSN_WILLTOPIC:
case MQTTSN_WILLMSG: case MQTTSN_WILLMSG:
WRITELOG(FORMAT_Y_G_G, currentDateTime(), packet->getName(), LEFTARROW, clientId, packet->print(pbuf)); WRITELOG(FORMAT_Y_G_G, currentDateTime(), packet->getName(), LEFTARROW,
clientId, packet->print(pbuf));
break; break;
case MQTTSN_PUBLISH: case MQTTSN_PUBLISH:
case MQTTSN_REGISTER: case MQTTSN_REGISTER:
case MQTTSN_SUBSCRIBE: case MQTTSN_SUBSCRIBE:
case MQTTSN_UNSUBSCRIBE: case MQTTSN_UNSUBSCRIBE:
WRITELOG(FORMAT_G_MSGID_G_G_NL, currentDateTime(), packet->getName(), packet->getMsgId(msgId), LEFTARROW, clientId, packet->print(pbuf)); WRITELOG(FORMAT_G_MSGID_G_G_NL, currentDateTime(), packet->getName(),
packet->getMsgId(msgId), LEFTARROW, clientId,
packet->print(pbuf));
break; break;
case MQTTSN_REGACK: case MQTTSN_REGACK:
case MQTTSN_PUBACK: case MQTTSN_PUBACK:
case MQTTSN_PUBREC: case MQTTSN_PUBREC:
case MQTTSN_PUBREL: case MQTTSN_PUBREL:
case MQTTSN_PUBCOMP: case MQTTSN_PUBCOMP:
WRITELOG(FORMAT_G_MSGID_G_G, currentDateTime(), packet->getName(), packet->getMsgId(msgId), LEFTARROW, clientId, packet->print(pbuf)); WRITELOG(FORMAT_G_MSGID_G_G, currentDateTime(), packet->getName(),
packet->getMsgId(msgId), LEFTARROW, clientId,
packet->print(pbuf));
break; break;
case MQTTSN_ENCAPSULATED: case MQTTSN_ENCAPSULATED:
WRITELOG(FORMAT_Y_G_G, currentDateTime(), packet->getName(), LEFTARROW, clientId, packet->print(pbuf)); WRITELOG(FORMAT_Y_G_G, currentDateTime(), packet->getName(), LEFTARROW,
break; clientId, packet->print(pbuf));
break;
default: default:
WRITELOG(FORMAT_W_NL, currentDateTime(), packet->getName(), LEFTARROW, clientId, packet->print(pbuf)); WRITELOG(FORMAT_W_NL, currentDateTime(), packet->getName(), LEFTARROW,
clientId, packet->print(pbuf));
break; break;
} }
} }

24
MQTTSNGateway/src/MQTTSNGWClientRecvTask.h
View File

@@ -24,24 +24,24 @@ namespace MQTTSNGW
class AdapterManager; class AdapterManager;
/*===================================== /*=====================================
Class ClientRecvTask Class ClientRecvTask
=====================================*/ =====================================*/
class ClientRecvTask:public Thread class ClientRecvTask: public Thread
{ {
MAGIC_WORD_FOR_THREAD; MAGIC_WORD_FOR_THREAD;
friend AdapterManager; friend AdapterManager;
public: public:
ClientRecvTask(Gateway*); ClientRecvTask(Gateway*);
~ClientRecvTask(void); ~ClientRecvTask(void);
virtual void initialize(int argc, char** argv); virtual void initialize(int argc, char** argv);
void run(void); void run(void);
private: private:
void log(Client*, MQTTSNPacket*, MQTTSNString* id); void log(Client*, MQTTSNPacket*, MQTTSNString* id);
void log(const char* clientId, MQTTSNPacket* packet); void log(const char* clientId, MQTTSNPacket* packet);
Gateway* _gateway; Gateway* _gateway;
SensorNetwork* _sensorNetwork; SensorNetwork* _sensorNetwork;
}; };
} }

176
MQTTSNGateway/src/MQTTSNGWClientSendTask.cpp
View File

@@ -28,9 +28,9 @@ char* currentDateTime(void);
=====================================*/ =====================================*/
ClientSendTask::ClientSendTask(Gateway* gateway) ClientSendTask::ClientSendTask(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
_gateway->attach((Thread*)this); _gateway->attach((Thread*) this);
_sensorNetwork = _gateway->getSensorNetwork(); _sensorNetwork = _gateway->getSensorNetwork();
} }
ClientSendTask::~ClientSendTask() ClientSendTask::~ClientSendTask()
@@ -40,94 +40,106 @@ ClientSendTask::~ClientSendTask()
void ClientSendTask::run() void ClientSendTask::run()
{ {
Client* client = nullptr; Client* client = nullptr;
MQTTSNPacket* packet = nullptr; MQTTSNPacket* packet = nullptr;
AdapterManager* adpMgr = _gateway->getAdapterManager(); AdapterManager* adpMgr = _gateway->getAdapterManager();
int rc = 0; int rc = 0;
while (true) while (true)
{ {
Event* ev = _gateway->getClientSendQue()->wait(); Event* ev = _gateway->getClientSendQue()->wait();
if (ev->getEventType() == EtStop || _gateway->IsStopping() ) if (ev->getEventType() == EtStop || _gateway->IsStopping())
{ {
WRITELOG("\n%s ClientSendTask stopped.", currentDateTime()); WRITELOG("\n%s ClientSendTask stopped.", currentDateTime());
delete ev; delete ev;
break; break;
} }
if (ev->getEventType() == EtBroadcast) if (ev->getEventType() == EtBroadcast)
{ {
packet = ev->getMQTTSNPacket(); packet = ev->getMQTTSNPacket();
log(client, packet); log(client, packet);
if ( packet->broadcast(_sensorNetwork) < 0 ) if (packet->broadcast(_sensorNetwork) < 0)
{ {
WRITELOG("%s ClientSendTask can't multicast a packet Error=%d%s\n", WRITELOG(
ERRMSG_HEADER, errno, ERRMSG_FOOTER); "%s ClientSendTask can't multicast a packet Error=%d%s\n",
} ERRMSG_HEADER, errno, ERRMSG_FOOTER);
} }
else }
{ else
if (ev->getEventType() == EtClientSend) {
{ if (ev->getEventType() == EtClientSend)
client = ev->getClient(); {
packet = ev->getMQTTSNPacket(); client = ev->getClient();
rc = adpMgr->unicastToClient(client, packet, this); packet = ev->getMQTTSNPacket();
} rc = adpMgr->unicastToClient(client, packet, this);
else if (ev->getEventType() == EtSensornetSend) }
{ else if (ev->getEventType() == EtSensornetSend)
packet = ev->getMQTTSNPacket(); {
log(client, packet); packet = ev->getMQTTSNPacket();
rc = packet->unicast(_sensorNetwork, ev->getSensorNetAddress()); log(client, packet);
} rc = packet->unicast(_sensorNetwork, ev->getSensorNetAddress());
}
if ( rc < 0 ) if (rc < 0)
{ {
WRITELOG("%s ClientSendTask can't send a packet to the client %s. Error=%d%s\n", WRITELOG(
ERRMSG_HEADER, (client ? (const char*)client->getClientId() : UNKNOWNCL ), errno, ERRMSG_FOOTER); "%s ClientSendTask can't send a packet to the client %s. Error=%d%s\n",
} ERRMSG_HEADER,
} (client ?
delete ev; (const char*) client->getClientId() : UNKNOWNCL),
} errno, ERRMSG_FOOTER);
}
}
delete ev;
}
} }
void ClientSendTask::log(Client* client, MQTTSNPacket* packet) void ClientSendTask::log(Client* client, MQTTSNPacket* packet)
{ {
char pbuf[SIZE_OF_LOG_PACKET * 3 + 1]; char pbuf[SIZE_OF_LOG_PACKET * 3 + 1];
char msgId[6]; char msgId[6];
const char* clientId = client ? (const char*)client->getClientId() : UNKNOWNCL ; const char* clientId =
client ? (const char*) client->getClientId() : UNKNOWNCL;
switch (packet->getType()) switch (packet->getType())
{ {
case MQTTSN_ADVERTISE: case MQTTSN_ADVERTISE:
case MQTTSN_GWINFO: case MQTTSN_GWINFO:
WRITELOG(FORMAT_Y_W_G, currentDateTime(), packet->getName(), RIGHTARROW, CLIENTS, packet->print(pbuf)); WRITELOG(FORMAT_Y_W_G, currentDateTime(), packet->getName(), RIGHTARROW,
break; CLIENTS, packet->print(pbuf));
case MQTTSN_CONNACK: break;
case MQTTSN_DISCONNECT: case MQTTSN_CONNACK:
case MQTTSN_WILLTOPICREQ: case MQTTSN_DISCONNECT:
case MQTTSN_WILLMSGREQ: case MQTTSN_WILLTOPICREQ:
case MQTTSN_WILLTOPICRESP: case MQTTSN_WILLMSGREQ:
case MQTTSN_WILLMSGRESP: case MQTTSN_WILLTOPICRESP:
case MQTTSN_PINGRESP: case MQTTSN_WILLMSGRESP:
WRITELOG(FORMAT_Y_W_G, currentDateTime(), packet->getName(), RIGHTARROW, clientId, packet->print(pbuf)); case MQTTSN_PINGRESP:
break; WRITELOG(FORMAT_Y_W_G, currentDateTime(), packet->getName(), RIGHTARROW,
case MQTTSN_REGISTER: clientId, packet->print(pbuf));
case MQTTSN_PUBLISH: break;
WRITELOG(FORMAT_W_MSGID_W_G, currentDateTime(), packet->getName(), packet->getMsgId(msgId), RIGHTARROW, clientId, packet->print(pbuf)); case MQTTSN_REGISTER:
break; case MQTTSN_PUBLISH:
case MQTTSN_REGACK: WRITELOG(FORMAT_W_MSGID_W_G, currentDateTime(), packet->getName(),
case MQTTSN_PUBACK: packet->getMsgId(msgId), RIGHTARROW, clientId,
case MQTTSN_PUBREC: packet->print(pbuf));
case MQTTSN_PUBREL: break;
case MQTTSN_PUBCOMP: case MQTTSN_REGACK:
case MQTTSN_SUBACK: case MQTTSN_PUBACK:
case MQTTSN_UNSUBACK: case MQTTSN_PUBREC:
WRITELOG(FORMAT_W_MSGID_W_G, currentDateTime(), packet->getName(), packet->getMsgId(msgId), RIGHTARROW, clientId, packet->print(pbuf)); case MQTTSN_PUBREL:
break; case MQTTSN_PUBCOMP:
default: case MQTTSN_SUBACK:
break; case MQTTSN_UNSUBACK:
} WRITELOG(FORMAT_W_MSGID_W_G, currentDateTime(), packet->getName(),
packet->getMsgId(msgId), RIGHTARROW, clientId,
packet->print(pbuf));
break;
default:
break;
}
} }

16
MQTTSNGateway/src/MQTTSNGWClientSendTask.h
View File

@@ -28,18 +28,18 @@ class AdapterManager;
=====================================*/ =====================================*/
class ClientSendTask: public Thread class ClientSendTask: public Thread
{ {
MAGIC_WORD_FOR_THREAD; MAGIC_WORD_FOR_THREAD;
friend AdapterManager; friend AdapterManager;
public: public:
ClientSendTask(Gateway* gateway); ClientSendTask(Gateway* gateway);
~ClientSendTask(void); ~ClientSendTask(void);
void run(void); void run(void);
private: private:
void log(Client* client, MQTTSNPacket* packet); void log(Client* client, MQTTSNPacket* packet);
Gateway* _gateway; Gateway* _gateway;
SensorNetwork* _sensorNetwork; SensorNetwork* _sensorNetwork;
}; };
} }

340
MQTTSNGateway/src/MQTTSNGWConnectionHandler.cpp
View File

@@ -28,7 +28,7 @@ using namespace MQTTSNGW;
=====================================*/ =====================================*/
MQTTSNConnectionHandler::MQTTSNConnectionHandler(Gateway* gateway) MQTTSNConnectionHandler::MQTTSNConnectionHandler(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTSNConnectionHandler::~MQTTSNConnectionHandler() MQTTSNConnectionHandler::~MQTTSNConnectionHandler()
@@ -41,11 +41,12 @@ MQTTSNConnectionHandler::~MQTTSNConnectionHandler()
*/ */
void MQTTSNConnectionHandler::sendADVERTISE() void MQTTSNConnectionHandler::sendADVERTISE()
{ {
MQTTSNPacket* adv = new MQTTSNPacket(); MQTTSNPacket* adv = new MQTTSNPacket();
adv->setADVERTISE(_gateway->getGWParams()->gatewayId, _gateway->getGWParams()->keepAlive); adv->setADVERTISE(_gateway->getGWParams()->gatewayId,
Event* ev1 = new Event(); _gateway->getGWParams()->keepAlive);
ev1->setBrodcastEvent(adv); //broadcast Event* ev1 = new Event();
_gateway->getClientSendQue()->post(ev1); ev1->setBrodcastEvent(adv); //broadcast
_gateway->getClientSendQue()->post(ev1);
} }
/* /*
@@ -53,182 +54,191 @@ void MQTTSNConnectionHandler::sendADVERTISE()
*/ */
void MQTTSNConnectionHandler::handleSearchgw(MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleSearchgw(MQTTSNPacket* packet)
{ {
if (packet->getType() == MQTTSN_SEARCHGW) if (packet->getType() == MQTTSN_SEARCHGW)
{ {
MQTTSNPacket* gwinfo = new MQTTSNPacket(); MQTTSNPacket* gwinfo = new MQTTSNPacket();
gwinfo->setGWINFO(_gateway->getGWParams()->gatewayId); gwinfo->setGWINFO(_gateway->getGWParams()->gatewayId);
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setBrodcastEvent(gwinfo); ev1->setBrodcastEvent(gwinfo);
_gateway->getClientSendQue()->post(ev1); _gateway->getClientSendQue()->post(ev1);
} }
} }
/* /*
* CONNECT * CONNECT
*/ */
void MQTTSNConnectionHandler::handleConnect(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleConnect(Client* client,
MQTTSNPacket* packet)
{ {
MQTTSNPacket_connectData data; MQTTSNPacket_connectData data;
if ( packet->getCONNECT(&data) == 0 ) if (packet->getCONNECT(&data) == 0)
{ {
return; return;
} }
/* return CONNACK when the client is sleeping */ /* return CONNACK when the client is sleeping */
if ( client->isSleep() || client->isAwake() ) if (client->isSleep() || client->isAwake())
{ {
MQTTSNPacket* packet = new MQTTSNPacket(); MQTTSNPacket* packet = new MQTTSNPacket();
packet->setCONNACK(MQTTSN_RC_ACCEPTED); packet->setCONNACK(MQTTSN_RC_ACCEPTED);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientSendEvent(client, packet); ev->setClientSendEvent(client, packet);
_gateway->getClientSendQue()->post(ev); _gateway->getClientSendQue()->post(ev);
sendStoredPublish(client); sendStoredPublish(client);
return; return;
} }
//* clear ConnectData of Client */ //* clear ConnectData of Client */
Connect* connectData = client->getConnectData(); Connect* connectData = client->getConnectData();
memset(connectData, 0, sizeof(Connect)); memset(connectData, 0, sizeof(Connect));
if ( !client->isAdapter() ) if (!client->isAdapter())
{ {
client->disconnected(); client->disconnected();
} }
Topics* topics = client->getTopics(); Topics* topics = client->getTopics();
/* CONNECT was not sent yet. prepare Connect data */ /* CONNECT was not sent yet. prepare Connect data */
connectData->header.bits.type = CONNECT; connectData->header.bits.type = CONNECT;
connectData->clientID = client->getClientId(); connectData->clientID = client->getClientId();
connectData->version = _gateway->getGWParams()->mqttVersion; connectData->version = _gateway->getGWParams()->mqttVersion;
connectData->keepAliveTimer = data.duration; connectData->keepAliveTimer = data.duration;
connectData->flags.bits.will = data.willFlag; connectData->flags.bits.will = data.willFlag;
if ((const char*) _gateway->getGWParams()->loginId != nullptr) if ((const char*) _gateway->getGWParams()->loginId != nullptr)
{ {
connectData->flags.bits.username = 1; connectData->flags.bits.username = 1;
} }
if ((const char*) _gateway->getGWParams()->password != 0) if ((const char*) _gateway->getGWParams()->password != 0)
{ {
connectData->flags.bits.password = 1; connectData->flags.bits.password = 1;
} }
client->setSessionStatus(false); client->setSessionStatus(false);
if (data.cleansession) if (data.cleansession)
{ {
connectData->flags.bits.cleanstart = 1; connectData->flags.bits.cleanstart = 1;
/* reset the table of msgNo and TopicId pare */ /* reset the table of msgNo and TopicId pare */
client->clearWaitedPubTopicId(); client->clearWaitedPubTopicId();
client->clearWaitedSubTopicId(); client->clearWaitedSubTopicId();
/* renew the TopicList */ /* renew the TopicList */
if (topics) if (topics)
{ {
topics->eraseNormal();; topics->eraseNormal();
} ;
client->setSessionStatus(true); }
} client->setSessionStatus(true);
}
if (data.willFlag) if (data.willFlag)
{ {
/* create & send WILLTOPICREQ message to the client */ /* create & send WILLTOPICREQ message to the client */
MQTTSNPacket* reqTopic = new MQTTSNPacket(); MQTTSNPacket* reqTopic = new MQTTSNPacket();
reqTopic->setWILLTOPICREQ(); reqTopic->setWILLTOPICREQ();
Event* evwr = new Event(); Event* evwr = new Event();
evwr->setClientSendEvent(client, reqTopic); evwr->setClientSendEvent(client, reqTopic);
/* Send WILLTOPICREQ to the client */ /* Send WILLTOPICREQ to the client */
_gateway->getClientSendQue()->post(evwr); _gateway->getClientSendQue()->post(evwr);
} }
else else
{ {
/* CONNECT message was not qued in. /* CONNECT message was not qued in.
* create CONNECT message & send it to the broker */ * create CONNECT message & send it to the broker */
MQTTGWPacket* mqMsg = new MQTTGWPacket(); MQTTGWPacket* mqMsg = new MQTTGWPacket();
mqMsg->setCONNECT(client->getConnectData(), (unsigned char*)_gateway->getGWParams()->loginId, (unsigned char*)_gateway->getGWParams()->password); mqMsg->setCONNECT(client->getConnectData(),
Event* ev1 = new Event(); (unsigned char*) _gateway->getGWParams()->loginId,
ev1->setBrokerSendEvent(client, mqMsg); (unsigned char*) _gateway->getGWParams()->password);
_gateway->getBrokerSendQue()->post(ev1); Event* ev1 = new Event();
} ev1->setBrokerSendEvent(client, mqMsg);
_gateway->getBrokerSendQue()->post(ev1);
}
} }
/* /*
* WILLTOPIC * WILLTOPIC
*/ */
void MQTTSNConnectionHandler::handleWilltopic(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleWilltopic(Client* client,
MQTTSNPacket* packet)
{ {
int willQos; int willQos;
uint8_t willRetain; uint8_t willRetain;
MQTTSNString willTopic = MQTTSNString_initializer; MQTTSNString willTopic = MQTTSNString_initializer;
if ( packet->getWILLTOPIC(&willQos, &willRetain, &willTopic) == 0 ) if (packet->getWILLTOPIC(&willQos, &willRetain, &willTopic) == 0)
{ {
return; return;
} }
client->setWillTopic(willTopic); client->setWillTopic(willTopic);
Connect* connectData = client->getConnectData(); Connect* connectData = client->getConnectData();
/* add the connectData for MQTT CONNECT message */ /* add the connectData for MQTT CONNECT message */
connectData->willTopic = client->getWillTopic(); connectData->willTopic = client->getWillTopic();
connectData->flags.bits.willQoS = willQos; connectData->flags.bits.willQoS = willQos;
connectData->flags.bits.willRetain = willRetain; connectData->flags.bits.willRetain = willRetain;
/* Send WILLMSGREQ to the client */ /* Send WILLMSGREQ to the client */
client->setWaitWillMsgFlg(true); client->setWaitWillMsgFlg(true);
MQTTSNPacket* reqMsg = new MQTTSNPacket(); MQTTSNPacket* reqMsg = new MQTTSNPacket();
reqMsg->setWILLMSGREQ(); reqMsg->setWILLMSGREQ();
Event* evt = new Event(); Event* evt = new Event();
evt->setClientSendEvent(client, reqMsg); evt->setClientSendEvent(client, reqMsg);
_gateway->getClientSendQue()->post(evt); _gateway->getClientSendQue()->post(evt);
} }
/* /*
* WILLMSG * WILLMSG
*/ */
void MQTTSNConnectionHandler::handleWillmsg(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleWillmsg(Client* client,
MQTTSNPacket* packet)
{ {
if ( !client->isWaitWillMsg() ) if (!client->isWaitWillMsg())
{ {
DEBUGLOG(" MQTTSNConnectionHandler::handleWillmsg WaitWillMsgFlg is off.\n"); DEBUGLOG(" MQTTSNConnectionHandler::handleWillmsg WaitWillMsgFlg is off.\n");
return; return;
} }
MQTTSNString willmsg = MQTTSNString_initializer; MQTTSNString willmsg = MQTTSNString_initializer;
Connect* connectData = client->getConnectData(); Connect* connectData = client->getConnectData();
if( client->isConnectSendable() ) if (client->isConnectSendable())
{ {
/* save WillMsg in the client */ /* save WillMsg in the client */
if ( packet->getWILLMSG(&willmsg) == 0 ) if (packet->getWILLMSG(&willmsg) == 0)
{ {
return; return;
} }
client->setWillMsg(willmsg); client->setWillMsg(willmsg);
/* create CONNECT message */ /* create CONNECT message */
MQTTGWPacket* mqttPacket = new MQTTGWPacket(); MQTTGWPacket* mqttPacket = new MQTTGWPacket();
connectData->willMsg = client->getWillMsg(); connectData->willMsg = client->getWillMsg();
mqttPacket->setCONNECT(connectData, (unsigned char*)_gateway->getGWParams()->loginId, (unsigned char*)_gateway->getGWParams()->password); mqttPacket->setCONNECT(connectData,
(unsigned char*) _gateway->getGWParams()->loginId,
(unsigned char*) _gateway->getGWParams()->password);
/* Send CONNECT to the broker */ /* Send CONNECT to the broker */
Event* evt = new Event(); Event* evt = new Event();
evt->setBrokerSendEvent(client, mqttPacket); evt->setBrokerSendEvent(client, mqttPacket);
client->setWaitWillMsgFlg(false); client->setWaitWillMsgFlg(false);
_gateway->getBrokerSendQue()->post(evt); _gateway->getBrokerSendQue()->post(evt);
} }
} }
/* /*
* DISCONNECT * DISCONNECT
*/ */
void MQTTSNConnectionHandler::handleDisconnect(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleDisconnect(Client* client,
MQTTSNPacket* packet)
{ {
uint16_t duration = 0; uint16_t duration = 0;
if ( packet->getDISCONNECT(&duration) != 0 ) if (packet->getDISCONNECT(&duration) != 0)
{ {
if ( duration == 0 ) if (duration == 0)
{ {
MQTTGWPacket* mqMsg = new MQTTGWPacket(); MQTTGWPacket* mqMsg = new MQTTGWPacket();
mqMsg->setHeader(DISCONNECT); mqMsg->setHeader(DISCONNECT);
@@ -248,59 +258,63 @@ void MQTTSNConnectionHandler::handleDisconnect(Client* client, MQTTSNPacket* pac
/* /*
* WILLTOPICUPD * WILLTOPICUPD
*/ */
void MQTTSNConnectionHandler::handleWilltopicupd(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleWilltopicupd(Client* client,
MQTTSNPacket* packet)
{ {
/* send NOT_SUPPORTED responce to the client */ /* send NOT_SUPPORTED responce to the client */
MQTTSNPacket* respMsg = new MQTTSNPacket(); MQTTSNPacket* respMsg = new MQTTSNPacket();
respMsg->setWILLTOPICRESP(MQTTSN_RC_NOT_SUPPORTED); respMsg->setWILLTOPICRESP(MQTTSN_RC_NOT_SUPPORTED);
Event* evt = new Event(); Event* evt = new Event();
evt->setClientSendEvent(client, respMsg); evt->setClientSendEvent(client, respMsg);
_gateway->getClientSendQue()->post(evt); _gateway->getClientSendQue()->post(evt);
} }
/* /*
* WILLMSGUPD * WILLMSGUPD
*/ */
void MQTTSNConnectionHandler::handleWillmsgupd(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handleWillmsgupd(Client* client,
MQTTSNPacket* packet)
{ {
/* send NOT_SUPPORTED responce to the client */ /* send NOT_SUPPORTED responce to the client */
MQTTSNPacket* respMsg = new MQTTSNPacket(); MQTTSNPacket* respMsg = new MQTTSNPacket();
respMsg->setWILLMSGRESP(MQTTSN_RC_NOT_SUPPORTED); respMsg->setWILLMSGRESP(MQTTSN_RC_NOT_SUPPORTED);
Event* evt = new Event(); Event* evt = new Event();
evt->setClientSendEvent(client, respMsg); evt->setClientSendEvent(client, respMsg);
_gateway->getClientSendQue()->post(evt); _gateway->getClientSendQue()->post(evt);
} }
/* /*
* PINGREQ * PINGREQ
*/ */
void MQTTSNConnectionHandler::handlePingreq(Client* client, MQTTSNPacket* packet) void MQTTSNConnectionHandler::handlePingreq(Client* client,
MQTTSNPacket* packet)
{ {
if ( ( client->isSleep() || client->isAwake() ) && client->getClientSleepPacket() ) if ((client->isSleep() || client->isAwake())
{ && client->getClientSleepPacket())
sendStoredPublish(client); {
client->holdPingRequest(); sendStoredPublish(client);
} client->holdPingRequest();
else }
{ else
{
/* send PINGREQ to the broker */ /* send PINGREQ to the broker */
client->resetPingRequest(); client->resetPingRequest();
MQTTGWPacket* pingreq = new MQTTGWPacket(); MQTTGWPacket* pingreq = new MQTTGWPacket();
pingreq->setHeader(PINGREQ); pingreq->setHeader(PINGREQ);
Event* evt = new Event(); Event* evt = new Event();
evt->setBrokerSendEvent(client, pingreq); evt->setBrokerSendEvent(client, pingreq);
_gateway->getBrokerSendQue()->post(evt); _gateway->getBrokerSendQue()->post(evt);
} }
} }
void MQTTSNConnectionHandler::sendStoredPublish(Client* client) void MQTTSNConnectionHandler::sendStoredPublish(Client* client)
{ {
MQTTGWPacket* msg = nullptr; MQTTGWPacket* msg = nullptr;
while ( ( msg = client->getClientSleepPacket() ) != nullptr ) while ((msg = client->getClientSleepPacket()) != nullptr)
{ {
// ToDo: This version can't re-send PUBLISH when PUBACK is not returned. // ToDo: This version can't re-send PUBLISH when PUBACK is not returned.
client->deleteFirstClientSleepPacket(); // pop the que to delete element. client->deleteFirstClientSleepPacket(); // pop the que to delete element.
Event* ev = new Event(); Event* ev = new Event();
ev->setBrokerRecvEvent(client, msg); ev->setBrokerRecvEvent(client, msg);

26
MQTTSNGateway/src/MQTTSNGWConnectionHandler.h
View File

@@ -25,21 +25,21 @@ namespace MQTTSNGW
class MQTTSNConnectionHandler class MQTTSNConnectionHandler
{ {
public: public:
MQTTSNConnectionHandler(Gateway* gateway); MQTTSNConnectionHandler(Gateway* gateway);
~MQTTSNConnectionHandler(); ~MQTTSNConnectionHandler();
void sendADVERTISE(void); void sendADVERTISE(void);
void handleSearchgw(MQTTSNPacket* packet); void handleSearchgw(MQTTSNPacket* packet);
void handleConnect(Client* client, MQTTSNPacket* packet); void handleConnect(Client* client, MQTTSNPacket* packet);
void handleWilltopic(Client* client, MQTTSNPacket* packet); void handleWilltopic(Client* client, MQTTSNPacket* packet);
void handleWillmsg(Client* client, MQTTSNPacket* packet); void handleWillmsg(Client* client, MQTTSNPacket* packet);
void handleDisconnect(Client* client, MQTTSNPacket* packet); void handleDisconnect(Client* client, MQTTSNPacket* packet);
void handleWilltopicupd(Client* client, MQTTSNPacket* packet); void handleWilltopicupd(Client* client, MQTTSNPacket* packet);
void handleWillmsgupd(Client* client, MQTTSNPacket* packet); void handleWillmsgupd(Client* client, MQTTSNPacket* packet);
void handlePingreq(Client* client, MQTTSNPacket* packet); void handlePingreq(Client* client, MQTTSNPacket* packet);
private: private:
void sendStoredPublish(Client* client); void sendStoredPublish(Client* client);
Gateway* _gateway; Gateway* _gateway;
}; };
} }

5
MQTTSNGateway/src/MQTTSNGWDefines.h
View File

@@ -53,16 +53,15 @@ namespace MQTTSNGW
/*================================= /*=================================
* Data Type * Data Type
==================================*/ ==================================*/
typedef unsigned char uint8_t; typedef unsigned char uint8_t;
typedef unsigned short uint16_t; typedef unsigned short uint16_t;
typedef unsigned int uint32_t; typedef unsigned int uint32_t;
/*================================= /*=================================
* Log controls * Log controls
==================================*/ ==================================*/
//#define DEBUG // print out log for debug //#define DEBUG // print out log for debug
//#define DEBUG_NWSTACK // print out SensorNetwork log //#define DEBUG_NWSTACK // print out SensorNetwork log
#ifdef DEBUG #ifdef DEBUG
#define DEBUGLOG(...) printf(__VA_ARGS__) #define DEBUGLOG(...) printf(__VA_ARGS__)
#else #else

52
MQTTSNGateway/src/MQTTSNGWEncapsulatedPacket.cpp
View File

@@ -21,17 +21,17 @@
using namespace MQTTSNGW; using namespace MQTTSNGW;
using namespace std; using namespace std;
WirelessNodeId::WirelessNodeId() WirelessNodeId::WirelessNodeId() :
: _len
_len{0}, { 0 }, _nodeId
_nodeId{0} { 0 }
{ {
} }
WirelessNodeId::~WirelessNodeId() WirelessNodeId::~WirelessNodeId()
{ {
if ( _nodeId ) if (_nodeId)
{ {
free(_nodeId); free(_nodeId);
} }
@@ -39,12 +39,12 @@ WirelessNodeId::~WirelessNodeId()
void WirelessNodeId::setId(uint8_t* id, uint8_t len) void WirelessNodeId::setId(uint8_t* id, uint8_t len)
{ {
if ( _nodeId ) if (_nodeId)
{ {
free(_nodeId); free(_nodeId);
} }
uint8_t* buf = (uint8_t*)malloc(len); uint8_t* buf = (uint8_t*) malloc(len);
if ( buf ) if (buf)
{ {
memcpy(buf, id, len); memcpy(buf, id, len);
_len = len; _len = len;
@@ -64,7 +64,7 @@ void WirelessNodeId::setId(WirelessNodeId* id)
bool WirelessNodeId::operator ==(WirelessNodeId& id) bool WirelessNodeId::operator ==(WirelessNodeId& id)
{ {
if ( _len == id._len ) if (_len == id._len)
{ {
return memcmp(_nodeId, id._nodeId, _len) == 0; return memcmp(_nodeId, id._nodeId, _len) == 0;
} }
@@ -77,16 +77,18 @@ bool WirelessNodeId::operator ==(WirelessNodeId& id)
/* /*
* Class MQTTSNGWEncapsulatedPacket * Class MQTTSNGWEncapsulatedPacket
*/ */
MQTTSNGWEncapsulatedPacket::MQTTSNGWEncapsulatedPacket() MQTTSNGWEncapsulatedPacket::MQTTSNGWEncapsulatedPacket() :
: _mqttsn{0}, _mqttsn
_ctrl{0} { 0 }, _ctrl
{ 0 }
{ {
} }
MQTTSNGWEncapsulatedPacket::MQTTSNGWEncapsulatedPacket(MQTTSNPacket* packet) MQTTSNGWEncapsulatedPacket::MQTTSNGWEncapsulatedPacket(MQTTSNPacket* packet) :
: _mqttsn{packet}, _mqttsn
_ctrl{0} { packet }, _ctrl
{ 0 }
{ {
} }
@@ -96,7 +98,8 @@ MQTTSNGWEncapsulatedPacket::~MQTTSNGWEncapsulatedPacket()
/* Do not delete the MQTTSNPacket. MQTTSNPacket is deleted by delete Event */ /* Do not delete the MQTTSNPacket. MQTTSNPacket is deleted by delete Event */
} }
int MQTTSNGWEncapsulatedPacket::unicast(SensorNetwork* network, SensorNetAddress* sendTo) int MQTTSNGWEncapsulatedPacket::unicast(SensorNetwork* network,
SensorNetAddress* sendTo)
{ {
uint8_t buf[MQTTSNGW_MAX_PACKET_SIZE]; uint8_t buf[MQTTSNGW_MAX_PACKET_SIZE];
int len = serialize(buf); int len = serialize(buf);
@@ -109,18 +112,19 @@ int MQTTSNGWEncapsulatedPacket::serialize(uint8_t* buf)
buf[0] = _id._len + 3; buf[0] = _id._len + 3;
buf[1] = MQTTSN_ENCAPSULATED; buf[1] = MQTTSN_ENCAPSULATED;
buf[2] = _ctrl; buf[2] = _ctrl;
memcpy( buf + 3, _id._nodeId, _id._len); memcpy(buf + 3, _id._nodeId, _id._len);
if ( _mqttsn ) if (_mqttsn)
{ {
len = _mqttsn->getPacketLength(); len = _mqttsn->getPacketLength();
memcpy(buf + buf[0], _mqttsn->getPacketData(), len); memcpy(buf + buf[0], _mqttsn->getPacketData(), len);
} }
return buf[0] + len; return buf[0] + len;
} }
int MQTTSNGWEncapsulatedPacket::desirialize(unsigned char* buf, unsigned short len) int MQTTSNGWEncapsulatedPacket::desirialize(unsigned char* buf,
unsigned short len)
{ {
if ( _mqttsn ) if (_mqttsn)
{ {
delete _mqttsn; delete _mqttsn;
_mqttsn = nullptr; _mqttsn = nullptr;

2
MQTTSNGateway/src/MQTTSNGWEncapsulatedPacket.h
View File

@@ -60,6 +60,4 @@ private:
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWENCAPSULATEDPACKET_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWENCAPSULATEDPACKET_H_ */

66
MQTTSNGateway/src/MQTTSNGWForwarder.cpp
View File

@@ -22,7 +22,7 @@ using namespace MQTTSNGW;
using namespace std; using namespace std;
/*===================================== /*=====================================
Class ForwarderList Class ForwarderList
=====================================*/ =====================================*/
ForwarderList::ForwarderList() ForwarderList::ForwarderList()
@@ -32,10 +32,10 @@ ForwarderList::ForwarderList()
ForwarderList::~ForwarderList() ForwarderList::~ForwarderList()
{ {
if ( _head ) if (_head)
{ {
Forwarder* p = _head; Forwarder* p = _head;
while ( p ) while (p)
{ {
Forwarder* next = p->_next; Forwarder* next = p->_next;
delete p; delete p;
@@ -44,20 +44,18 @@ ForwarderList::~ForwarderList()
} }
} }
void ForwarderList::initialize(Gateway* gw) void ForwarderList::initialize(Gateway* gw)
{ {
/* Create Fowarders from clients.conf */ /* Create Fowarders from clients.conf */
gw->getClientList()->setClientList(FORWARDER_TYPE); gw->getClientList()->setClientList(FORWARDER_TYPE);
} }
Forwarder* ForwarderList::getForwarder(SensorNetAddress* addr) Forwarder* ForwarderList::getForwarder(SensorNetAddress* addr)
{ {
Forwarder* p = _head; Forwarder* p = _head;
while ( p ) while (p)
{ {
if ( p->_sensorNetAddr.isMatch(addr) ) if (p->_sensorNetAddr.isMatch(addr))
{ {
break; break;
} }
@@ -66,19 +64,20 @@ Forwarder* ForwarderList::getForwarder(SensorNetAddress* addr)
return p; return p;
} }
Forwarder* ForwarderList::addForwarder(SensorNetAddress* addr, MQTTSNString* forwarderId) Forwarder* ForwarderList::addForwarder(SensorNetAddress* addr,
MQTTSNString* forwarderId)
{ {
Forwarder* fdr = new Forwarder(addr, forwarderId); Forwarder* fdr = new Forwarder(addr, forwarderId);
if ( _head == nullptr ) if (_head == nullptr)
{ {
_head = fdr; _head = fdr;
} }
else else
{ {
Forwarder* p = _head; Forwarder* p = _head;
while ( p ) while (p)
{ {
if ( p->_next == nullptr ) if (p->_next == nullptr)
{ {
p->_next = fdr; p->_next = fdr;
break; break;
@@ -99,10 +98,10 @@ Forwarder::Forwarder()
} }
/*===================================== /*=====================================
Class ForwarderList Class ForwarderList
=====================================*/ =====================================*/
Forwarder::Forwarder(SensorNetAddress* addr, MQTTSNString* forwarderId) Forwarder::Forwarder(SensorNetAddress* addr, MQTTSNString* forwarderId)
{ {
_forwarderName = string(forwarderId->cstring); _forwarderName = string(forwarderId->cstring);
_sensorNetAddr = *addr; _sensorNetAddr = *addr;
@@ -112,10 +111,10 @@ Forwarder::Forwarder(SensorNetAddress* addr, MQTTSNString* forwarderId)
Forwarder::~Forwarder(void) Forwarder::~Forwarder(void)
{ {
if ( _headClient ) if (_headClient)
{ {
ForwarderElement* p = _headClient; ForwarderElement* p = _headClient;
while ( p ) while (p)
{ {
ForwarderElement* next = p->_next; ForwarderElement* next = p->_next;
delete p; delete p;
@@ -136,11 +135,11 @@ void Forwarder::addClient(Client* client, WirelessNodeId* id)
client->setForwarder(this); client->setForwarder(this);
if ( p != nullptr ) if (p != nullptr)
{ {
while ( p ) while (p)
{ {
if ( p->_client == client ) if (p->_client == client)
{ {
client->setForwarder(this); client->setForwarder(this);
p->setWirelessNodeId(id); p->setWirelessNodeId(id);
@@ -156,7 +155,7 @@ void Forwarder::addClient(Client* client, WirelessNodeId* id)
fclient->setClient(client); fclient->setClient(client);
fclient->setWirelessNodeId(id); fclient->setWirelessNodeId(id);
if ( prev ) if (prev)
{ {
prev->_next = fclient; prev->_next = fclient;
} }
@@ -171,9 +170,9 @@ Client* Forwarder::getClient(WirelessNodeId* id)
Client* cl = nullptr; Client* cl = nullptr;
_mutex.lock(); _mutex.lock();
ForwarderElement* p = _headClient; ForwarderElement* p = _headClient;
while ( p ) while (p)
{ {
if ( *(p->_wirelessNodeId) == *id ) if (*(p->_wirelessNodeId) == *id)
{ {
cl = p->_client; cl = p->_client;
break; break;
@@ -197,9 +196,9 @@ WirelessNodeId* Forwarder::getWirelessNodeId(Client* client)
WirelessNodeId* nodeId = nullptr; WirelessNodeId* nodeId = nullptr;
_mutex.lock(); _mutex.lock();
ForwarderElement* p = _headClient; ForwarderElement* p = _headClient;
while ( p ) while (p)
{ {
if ( p->_client == client ) if (p->_client == client)
{ {
nodeId = p->_wirelessNodeId; nodeId = p->_wirelessNodeId;
break; break;
@@ -219,11 +218,11 @@ void Forwarder::eraseClient(Client* client)
_mutex.lock(); _mutex.lock();
ForwarderElement* p = _headClient; ForwarderElement* p = _headClient;
while ( p ) while (p)
{ {
if ( p->_client == client ) if (p->_client == client)
{ {
if ( prev ) if (prev)
{ {
prev->_next = p->_next; prev->_next = p->_next;
} }
@@ -251,10 +250,11 @@ SensorNetAddress* Forwarder::getSensorNetAddr(void)
* Class ForwardedClient * Class ForwardedClient
*/ */
ForwarderElement::ForwarderElement() ForwarderElement::ForwarderElement() :
: _client{0} _client
, _wirelessNodeId{0} { 0 }, _wirelessNodeId
, _next{0} { 0 }, _next
{ 0 }
{ {
} }
@@ -273,7 +273,7 @@ void ForwarderElement::setClient(Client* client)
void ForwarderElement::setWirelessNodeId(WirelessNodeId* id) void ForwarderElement::setWirelessNodeId(WirelessNodeId* id)
{ {
if ( _wirelessNodeId == nullptr ) if (_wirelessNodeId == nullptr)
{ {
_wirelessNodeId = new WirelessNodeId(); _wirelessNodeId = new WirelessNodeId();
} }

17
MQTTSNGateway/src/MQTTSNGWForwarder.h
View File

@@ -22,7 +22,6 @@
#include "MQTTSNGWEncapsulatedPacket.h" #include "MQTTSNGWEncapsulatedPacket.h"
#include "SensorNetwork.h" #include "SensorNetwork.h"
namespace MQTTSNGW namespace MQTTSNGW
{ {
class Gateway; class Gateway;
@@ -30,7 +29,7 @@ class Client;
class WirelessNodeId; class WirelessNodeId;
/*===================================== /*=====================================
Class ForwarderElement Class ForwarderElement
=====================================*/ =====================================*/
class ForwarderElement class ForwarderElement
{ {
@@ -48,14 +47,14 @@ private:
}; };
/*===================================== /*=====================================
Class Forwarder Class Forwarder
=====================================*/ =====================================*/
class Forwarder class Forwarder
{ {
friend class ForwarderList; friend class ForwarderList;
public: public:
Forwarder(void); Forwarder(void);
Forwarder(SensorNetAddress* addr, MQTTSNString* forwarderId); Forwarder(SensorNetAddress* addr, MQTTSNString* forwarderId);
~Forwarder(); ~Forwarder();
void initialize(void); void initialize(void);
@@ -70,13 +69,13 @@ public:
private: private:
string _forwarderName; string _forwarderName;
SensorNetAddress _sensorNetAddr; SensorNetAddress _sensorNetAddr;
ForwarderElement* _headClient{nullptr}; ForwarderElement* _headClient { nullptr };
Forwarder* _next {nullptr}; Forwarder* _next { nullptr };
Mutex _mutex; Mutex _mutex;
}; };
/*===================================== /*=====================================
Class ForwarderList Class ForwarderList
=====================================*/ =====================================*/
class ForwarderList class ForwarderList
{ {
@@ -86,7 +85,7 @@ public:
void initialize(Gateway* gw); void initialize(Gateway* gw);
Forwarder* getForwarder(SensorNetAddress* addr); Forwarder* getForwarder(SensorNetAddress* addr);
Forwarder* addForwarder(SensorNetAddress* addr, MQTTSNString* forwarderId); Forwarder* addForwarder(SensorNetAddress* addr, MQTTSNString* forwarderId);
private: private:
Forwarder* _head; Forwarder* _head;
@@ -94,6 +93,4 @@ private:
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWFORWARDER_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWFORWARDER_H_ */

26
MQTTSNGateway/src/MQTTSNGWLogmonitor.cpp
View File

@@ -22,7 +22,7 @@ using namespace MQTTSNGW;
Logmonitor::Logmonitor() Logmonitor::Logmonitor()
{ {
theProcess = this; theProcess = this;
} }
Logmonitor::~Logmonitor() Logmonitor::~Logmonitor()
@@ -32,17 +32,17 @@ Logmonitor::~Logmonitor()
void Logmonitor::run() void Logmonitor::run()
{ {
while (true) while (true)
{ {
const char* data = getLog(); const char* data = getLog();
if ( *data == 0 ) if (*data == 0)
{ {
break; break;
} }
else else
{ {
printf("%s", data); printf("%s", data);
} }
} }
} }

6
MQTTSNGateway/src/MQTTSNGWLogmonitor.h
View File

@@ -23,9 +23,9 @@ namespace MQTTSNGW
class Logmonitor: public Process class Logmonitor: public Process
{ {
public: public:
Logmonitor(); Logmonitor();
~Logmonitor(); ~Logmonitor();
void run(); void run();
}; };
} }

285
MQTTSNGateway/src/MQTTSNGWMessageIdTable.cpp
View File

@@ -29,187 +29,188 @@ MessageIdTable::MessageIdTable()
MessageIdTable::~MessageIdTable() MessageIdTable::~MessageIdTable()
{ {
_mutex.lock(); _mutex.lock();
if ( _head != nullptr ) if (_head != nullptr)
{ {
MessageIdElement* p = _tail; MessageIdElement* p = _tail;
while ( p ) while (p)
{ {
MessageIdElement* pPrev = p; MessageIdElement* pPrev = p;
delete p; delete p;
_cnt--; _cnt--;
p = pPrev->_prev; p = pPrev->_prev;
} }
_head = _tail = nullptr; _head = _tail = nullptr;
} }
_mutex.unlock(); _mutex.unlock();
} }
MessageIdElement* MessageIdTable::add(Aggregater* aggregater, Client* client, uint16_t clientMsgId) MessageIdElement* MessageIdTable::add(Aggregater* aggregater, Client* client,
uint16_t clientMsgId)
{ {
if ( _cnt > _maxSize ) if (_cnt > _maxSize)
{ {
return nullptr; return nullptr;
} }
MessageIdElement* elm = new MessageIdElement(0, client, clientMsgId); MessageIdElement* elm = new MessageIdElement(0, client, clientMsgId);
if ( elm == nullptr ) if (elm == nullptr)
{ {
return nullptr; return nullptr;
} }
_mutex.lock(); _mutex.lock();
if ( _head == nullptr ) if (_head == nullptr)
{ {
elm->_msgId = aggregater->msgId(); elm->_msgId = aggregater->msgId();
_head = elm; _head = elm;
_tail = elm; _tail = elm;
_cnt++; _cnt++;
} }
else else
{ {
MessageIdElement* p = find(client, clientMsgId); MessageIdElement* p = find(client, clientMsgId);
if ( p == nullptr ) if (p == nullptr)
{ {
elm->_msgId = aggregater->msgId(); elm->_msgId = aggregater->msgId();
p = _tail; p = _tail;
_tail = elm; _tail = elm;
elm->_prev = p; elm->_prev = p;
p->_next = elm; p->_next = elm;
_cnt++; _cnt++;
} }
else else
{ {
delete elm; delete elm;
elm = nullptr; elm = nullptr;
} }
} }
_mutex.unlock(); _mutex.unlock();
return elm; return elm;
} }
MessageIdElement* MessageIdTable::find(uint16_t msgId) MessageIdElement* MessageIdTable::find(uint16_t msgId)
{ {
MessageIdElement* p = _head; MessageIdElement* p = _head;
while ( p ) while (p)
{ {
if ( p->_msgId == msgId) if (p->_msgId == msgId)
{ {
break; break;
} }
p = p->_next; p = p->_next;
} }
return p; return p;
} }
MessageIdElement* MessageIdTable::find(Client* client, uint16_t clientMsgId) MessageIdElement* MessageIdTable::find(Client* client, uint16_t clientMsgId)
{ {
MessageIdElement* p = _head; MessageIdElement* p = _head;
while ( p ) while (p)
{ {
if ( p->_clientMsgId == clientMsgId && p->_client == client) if (p->_clientMsgId == clientMsgId && p->_client == client)
{ {
break; break;
} }
p = p->_next; p = p->_next;
} }
return p; return p;
} }
Client* MessageIdTable::getClientMsgId(uint16_t msgId, uint16_t* clientMsgId) Client* MessageIdTable::getClientMsgId(uint16_t msgId, uint16_t* clientMsgId)
{ {
Client* clt = nullptr; Client* clt = nullptr;
*clientMsgId = 0; *clientMsgId = 0;
_mutex.lock(); _mutex.lock();
MessageIdElement* p = find(msgId); MessageIdElement* p = find(msgId);
if ( p != nullptr ) if (p != nullptr)
{ {
clt = p->_client; clt = p->_client;
*clientMsgId = p->_clientMsgId; *clientMsgId = p->_clientMsgId;
clear(p); clear(p);
} }
_mutex.unlock(); _mutex.unlock();
return clt; return clt;
} }
void MessageIdTable::erase(uint16_t msgId) void MessageIdTable::erase(uint16_t msgId)
{ {
_mutex.lock(); _mutex.lock();
MessageIdElement* p = find(msgId); MessageIdElement* p = find(msgId);
clear(p); clear(p);
_mutex.unlock(); _mutex.unlock();
} }
void MessageIdTable::clear(MessageIdElement* elm) void MessageIdTable::clear(MessageIdElement* elm)
{ {
if ( elm == nullptr ) if (elm == nullptr)
{ {
return; return;
} }
if ( elm->_prev == nullptr ) if (elm->_prev == nullptr)
{ {
_head = elm->_next; _head = elm->_next;
if ( _head == nullptr) if (_head == nullptr)
{ {
_tail = nullptr; _tail = nullptr;
} }
else else
{ {
_head->_prev = nullptr; _head->_prev = nullptr;
} }
delete elm; delete elm;
_cnt--; _cnt--;
return; return;
} }
else else
{ {
elm->_prev->_next = elm->_next; elm->_prev->_next = elm->_next;
if ( elm->_next == nullptr ) if (elm->_next == nullptr)
{ {
_tail = elm->_prev; _tail = elm->_prev;
} }
else else
{ {
elm->_next->_prev = elm->_prev; elm->_next->_prev = elm->_prev;
} }
delete elm; delete elm;
_cnt--; _cnt--;
return; return;
} }
} }
uint16_t MessageIdTable::getMsgId(Client* client, uint16_t clientMsgId) uint16_t MessageIdTable::getMsgId(Client* client, uint16_t clientMsgId)
{ {
uint16_t msgId = 0; uint16_t msgId = 0;
MessageIdElement* p = find(client, clientMsgId); MessageIdElement* p = find(client, clientMsgId);
if ( p != nullptr ) if (p != nullptr)
{ {
msgId = p->_msgId; msgId = p->_msgId;
} }
return msgId; return msgId;
} }
/*=============================== /*===============================
* Class MessageIdElement * Class MessageIdElement
===============================*/ ===============================*/
MessageIdElement::MessageIdElement(void) MessageIdElement::MessageIdElement(void) :
: _msgId{0} _msgId
, _clientMsgId {0} { 0 }, _clientMsgId
, _client {nullptr} { 0 }, _client
, _next {nullptr} { nullptr }, _next
, _prev {nullptr} { nullptr }, _prev
{ nullptr }
{ {
} }
MessageIdElement::MessageIdElement(uint16_t msgId, Client* client, uint16_t clientMsgId) MessageIdElement::MessageIdElement(uint16_t msgId, Client* client,
: MessageIdElement() uint16_t clientMsgId) :
MessageIdElement()
{ {
_msgId = msgId; _msgId = msgId;
_client = client; _client = client;
_clientMsgId = clientMsgId; _clientMsgId = clientMsgId;
} }
MessageIdElement::~MessageIdElement(void) MessageIdElement::~MessageIdElement(void)

32
MQTTSNGateway/src/MQTTSNGWMessageIdTable.h
View File

@@ -34,22 +34,23 @@ class Aggregater;
class MessageIdTable class MessageIdTable
{ {
public: public:
MessageIdTable(); MessageIdTable();
~MessageIdTable(); ~MessageIdTable();
MessageIdElement* add(Aggregater* aggregater, Client* client, uint16_t clientMsgId); MessageIdElement* add(Aggregater* aggregater, Client* client,
Client* getClientMsgId(uint16_t msgId, uint16_t* clientMsgId); uint16_t clientMsgId);
uint16_t getMsgId(Client* client, uint16_t clientMsgId); Client* getClientMsgId(uint16_t msgId, uint16_t* clientMsgId);
void erase(uint16_t msgId); uint16_t getMsgId(Client* client, uint16_t clientMsgId);
void clear(MessageIdElement* elm); void erase(uint16_t msgId);
void clear(MessageIdElement* elm);
private: private:
MessageIdElement* find(uint16_t msgId); MessageIdElement* find(uint16_t msgId);
MessageIdElement* find(Client* client, uint16_t clientMsgId); MessageIdElement* find(Client* client, uint16_t clientMsgId);
MessageIdElement* _head {nullptr}; MessageIdElement* _head { nullptr };
MessageIdElement* _tail {nullptr}; MessageIdElement* _tail{ nullptr };
int _cnt {0}; int _cnt { 0 };
int _maxSize {MAX_MESSAGEID_TABLE_SIZE}; int _maxSize { MAX_MESSAGEID_TABLE_SIZE };
Mutex _mutex; Mutex _mutex;
}; };
/*===================================== /*=====================================
@@ -67,12 +68,11 @@ public:
private: private:
uint16_t _msgId; uint16_t _msgId;
uint16_t _clientMsgId; uint16_t _clientMsgId;
Client* _client; Client* _client;
MessageIdElement* _next; MessageIdElement* _next;
MessageIdElement* _prev; MessageIdElement* _prev;
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWMESSAGEIDTABLE_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWMESSAGEIDTABLE_H_ */

673
MQTTSNGateway/src/MQTTSNGWPacket.cpp
View File

@@ -29,286 +29,293 @@ void writeInt(unsigned char** pptr, int msgId);
MQTTSNPacket::MQTTSNPacket(void) MQTTSNPacket::MQTTSNPacket(void)
{ {
_buf = nullptr; _buf = nullptr;
_bufLen = 0; _bufLen = 0;
} }
MQTTSNPacket::MQTTSNPacket(MQTTSNPacket& packet) MQTTSNPacket::MQTTSNPacket(MQTTSNPacket& packet)
{ {
_buf = (unsigned char*)malloc(packet._bufLen); _buf = (unsigned char*) malloc(packet._bufLen);
if (_buf) if (_buf)
{ {
_bufLen = packet._bufLen; _bufLen = packet._bufLen;
memcpy(_buf, packet._buf, _bufLen); memcpy(_buf, packet._buf, _bufLen);
} }
else else
{ {
_buf = nullptr; _buf = nullptr;
_bufLen = 0; _bufLen = 0;
} }
} }
MQTTSNPacket::~MQTTSNPacket() MQTTSNPacket::~MQTTSNPacket()
{ {
if (_buf) if (_buf)
{ {
free(_buf); free(_buf);
} }
} }
int MQTTSNPacket::unicast(SensorNetwork* network, SensorNetAddress* sendTo) int MQTTSNPacket::unicast(SensorNetwork* network, SensorNetAddress* sendTo)
{ {
return network->unicast(_buf, _bufLen, sendTo); return network->unicast(_buf, _bufLen, sendTo);
} }
int MQTTSNPacket::broadcast(SensorNetwork* network) int MQTTSNPacket::broadcast(SensorNetwork* network)
{ {
return network->broadcast(_buf, _bufLen); return network->broadcast(_buf, _bufLen);
} }
int MQTTSNPacket::serialize(uint8_t* buf) int MQTTSNPacket::serialize(uint8_t* buf)
{ {
buf = _buf; buf = _buf;
return _bufLen; return _bufLen;
} }
int MQTTSNPacket::desirialize(unsigned char* buf, unsigned short len) int MQTTSNPacket::desirialize(unsigned char* buf, unsigned short len)
{ {
if ( _buf ) if (_buf)
{ {
free(_buf); free(_buf);
} }
_buf = (unsigned char*)calloc(len, sizeof(unsigned char)); _buf = (unsigned char*) calloc(len, sizeof(unsigned char));
if ( _buf ) if (_buf)
{ {
memcpy(_buf, buf, len); memcpy(_buf, buf, len);
_bufLen = len; _bufLen = len;
} }
else else
{ {
_bufLen = 0; _bufLen = 0;
} }
return _bufLen; return _bufLen;
} }
int MQTTSNPacket::recv(SensorNetwork* network) int MQTTSNPacket::recv(SensorNetwork* network)
{ {
uint8_t buf[MQTTSNGW_MAX_PACKET_SIZE]; uint8_t buf[MQTTSNGW_MAX_PACKET_SIZE];
int len = network->read((uint8_t*) buf, MQTTSNGW_MAX_PACKET_SIZE); int len = network->read((uint8_t*) buf, MQTTSNGW_MAX_PACKET_SIZE);
if (len > 1) if (len > 1)
{ {
len = desirialize(buf, len); len = desirialize(buf, len);
} }
else else
{ {
len = 0; len = 0;
} }
return len; return len;
} }
int MQTTSNPacket::getType(void) int MQTTSNPacket::getType(void)
{ {
if ( _bufLen == 0 ) if (_bufLen == 0)
{ {
return 0; return 0;
} }
int value = 0; int value = 0;
int p = MQTTSNPacket_decode(_buf, _bufLen, &value); int p = MQTTSNPacket_decode(_buf, _bufLen, &value);
return _buf[p]; return _buf[p];
} }
bool MQTTSNPacket::isQoSMinusPUBLISH(void) bool MQTTSNPacket::isQoSMinusPUBLISH(void)
{ {
if ( _bufLen == 0 ) if (_bufLen == 0)
{ {
return false;; return false;;
} }
int value = 0; int value = 0;
int p = MQTTSNPacket_decode(_buf, _bufLen, &value); int p = MQTTSNPacket_decode(_buf, _bufLen, &value);
return ( (_buf[p] == MQTTSN_PUBLISH) && ((_buf[p + 1] & 0x60 ) == 0x60 )); return ((_buf[p] == MQTTSN_PUBLISH) && ((_buf[p + 1] & 0x60) == 0x60));
} }
unsigned char* MQTTSNPacket::getPacketData(void) unsigned char* MQTTSNPacket::getPacketData(void)
{ {
return _buf; return _buf;
} }
int MQTTSNPacket::getPacketLength(void) int MQTTSNPacket::getPacketLength(void)
{ {
return _bufLen; return _bufLen;
} }
const char* MQTTSNPacket::getName() const char* MQTTSNPacket::getName()
{ {
return MQTTSNPacket_name(getType()); return MQTTSNPacket_name(getType());
} }
int MQTTSNPacket::setADVERTISE(uint8_t gatewayid, uint16_t duration) int MQTTSNPacket::setADVERTISE(uint8_t gatewayid, uint16_t duration)
{ {
unsigned char buf[5]; unsigned char buf[5];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_advertise(buf, buflen, (unsigned char) gatewayid, int len = MQTTSNSerialize_advertise(buf, buflen, (unsigned char) gatewayid,
(unsigned short) duration); (unsigned short) duration);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setGWINFO(uint8_t gatewayId) int MQTTSNPacket::setGWINFO(uint8_t gatewayId)
{ {
unsigned char buf[3]; unsigned char buf[3];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_gwinfo(buf, buflen, (unsigned char) gatewayId, 0, 0); int len = MQTTSNSerialize_gwinfo(buf, buflen, (unsigned char) gatewayId, 0,
return desirialize(buf, len); 0);
return desirialize(buf, len);
} }
int MQTTSNPacket::setConnect(void) int MQTTSNPacket::setConnect(void)
{ {
unsigned char buf[40]; unsigned char buf[40];
int buflen = sizeof(buf); int buflen = sizeof(buf);
MQTTSNPacket_connectData data; MQTTSNPacket_connectData data;
data.clientID.cstring = (char*)"client01"; data.clientID.cstring = (char*) "client01";
int len = MQTTSNSerialize_connect(buf, buflen, &data); int len = MQTTSNSerialize_connect(buf, buflen, &data);
return desirialize(buf, len); return desirialize(buf, len);
} }
bool MQTTSNPacket::isAccepted(void) bool MQTTSNPacket::isAccepted(void)
{ {
return ( getType() == MQTTSN_CONNACK) && (_buf[2] == MQTTSN_RC_ACCEPTED); return (getType() == MQTTSN_CONNACK) && (_buf[2] == MQTTSN_RC_ACCEPTED);
} }
int MQTTSNPacket::setCONNACK(uint8_t returnCode) int MQTTSNPacket::setCONNACK(uint8_t returnCode)
{ {
unsigned char buf[3]; unsigned char buf[3];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_connack(buf, buflen, (int) returnCode); int len = MQTTSNSerialize_connack(buf, buflen, (int) returnCode);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setWILLTOPICREQ(void) int MQTTSNPacket::setWILLTOPICREQ(void)
{ {
unsigned char buf[2]; unsigned char buf[2];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_willtopicreq(buf, buflen); int len = MQTTSNSerialize_willtopicreq(buf, buflen);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setWILLMSGREQ(void) int MQTTSNPacket::setWILLMSGREQ(void)
{ {
unsigned char buf[2]; unsigned char buf[2];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_willmsgreq(buf, buflen); int len = MQTTSNSerialize_willmsgreq(buf, buflen);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setREGISTER(uint16_t topicId, uint16_t msgId, MQTTSNString* topicName) int MQTTSNPacket::setREGISTER(uint16_t topicId, uint16_t msgId,
MQTTSNString* topicName)
{ {
unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE]; unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_register(buf, buflen, (unsigned short) topicId, (unsigned short) msgId, int len = MQTTSNSerialize_register(buf, buflen, (unsigned short) topicId,
topicName); (unsigned short) msgId, topicName);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setREGACK(uint16_t topicId, uint16_t msgId, uint8_t returnCode) int MQTTSNPacket::setREGACK(uint16_t topicId, uint16_t msgId,
uint8_t returnCode)
{ {
unsigned char buf[7]; unsigned char buf[7];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_regack(buf, buflen, (unsigned short) topicId, (unsigned short) msgId, int len = MQTTSNSerialize_regack(buf, buflen, (unsigned short) topicId,
(unsigned char) returnCode); (unsigned short) msgId, (unsigned char) returnCode);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setPUBLISH(uint8_t dup, int qos, uint8_t retained, uint16_t msgId, MQTTSN_topicid topic, int MQTTSNPacket::setPUBLISH(uint8_t dup, int qos, uint8_t retained,
uint8_t* payload, uint16_t payloadlen) uint16_t msgId, MQTTSN_topicid topic, uint8_t* payload,
uint16_t payloadlen)
{ {
unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE]; unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_publish(buf, buflen, (unsigned char) dup, qos, (unsigned char) retained, int len = MQTTSNSerialize_publish(buf, buflen, (unsigned char) dup, qos,
(unsigned short) msgId, topic, (unsigned char*) payload, (int) payloadlen); (unsigned char) retained, (unsigned short) msgId, topic,
return desirialize(buf, len); (unsigned char*) payload, (int) payloadlen);
return desirialize(buf, len);
} }
int MQTTSNPacket::setPUBACK(uint16_t topicId, uint16_t msgId, uint8_t returnCode) int MQTTSNPacket::setPUBACK(uint16_t topicId, uint16_t msgId,
uint8_t returnCode)
{ {
unsigned char buf[7]; unsigned char buf[7];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_puback(buf, buflen, (unsigned short) topicId, (unsigned short) msgId, int len = MQTTSNSerialize_puback(buf, buflen, (unsigned short) topicId,
(unsigned char) returnCode); (unsigned short) msgId, (unsigned char) returnCode);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setPUBREC(uint16_t msgId) int MQTTSNPacket::setPUBREC(uint16_t msgId)
{ {
unsigned char buf[4]; unsigned char buf[4];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_pubrec(buf, buflen, (unsigned short) msgId); int len = MQTTSNSerialize_pubrec(buf, buflen, (unsigned short) msgId);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setPUBREL(uint16_t msgId) int MQTTSNPacket::setPUBREL(uint16_t msgId)
{ {
unsigned char buf[4]; unsigned char buf[4];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_pubrel(buf, buflen, (unsigned short) msgId); int len = MQTTSNSerialize_pubrel(buf, buflen, (unsigned short) msgId);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setPUBCOMP(uint16_t msgId) int MQTTSNPacket::setPUBCOMP(uint16_t msgId)
{ {
unsigned char buf[4]; unsigned char buf[4];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_pubcomp(buf, buflen, (unsigned short) msgId); int len = MQTTSNSerialize_pubcomp(buf, buflen, (unsigned short) msgId);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setSUBACK(int qos, uint16_t topicId, uint16_t msgId, uint8_t returnCode) int MQTTSNPacket::setSUBACK(int qos, uint16_t topicId, uint16_t msgId,
uint8_t returnCode)
{ {
unsigned char buf[8]; unsigned char buf[8];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_suback(buf, buflen, qos, (unsigned short) topicId, int len = MQTTSNSerialize_suback(buf, buflen, qos, (unsigned short) topicId,
(unsigned short) msgId, (unsigned char) returnCode); (unsigned short) msgId, (unsigned char) returnCode);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setUNSUBACK(uint16_t msgId) int MQTTSNPacket::setUNSUBACK(uint16_t msgId)
{ {
unsigned char buf[4]; unsigned char buf[4];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_unsuback(buf, buflen, (unsigned short) msgId); int len = MQTTSNSerialize_unsuback(buf, buflen, (unsigned short) msgId);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setPINGRESP(void) int MQTTSNPacket::setPINGRESP(void)
{ {
unsigned char buf[32]; unsigned char buf[32];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_pingresp(buf, buflen); int len = MQTTSNSerialize_pingresp(buf, buflen);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setDISCONNECT(uint16_t duration) int MQTTSNPacket::setDISCONNECT(uint16_t duration)
{ {
unsigned char buf[4]; unsigned char buf[4];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_disconnect(buf, buflen, (int) duration); int len = MQTTSNSerialize_disconnect(buf, buflen, (int) duration);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setWILLTOPICRESP(uint8_t returnCode) int MQTTSNPacket::setWILLTOPICRESP(uint8_t returnCode)
{ {
unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE]; unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_willtopicresp(buf, buflen, (int) returnCode); int len = MQTTSNSerialize_willtopicresp(buf, buflen, (int) returnCode);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setWILLMSGRESP(uint8_t returnCode) int MQTTSNPacket::setWILLMSGRESP(uint8_t returnCode)
{ {
unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE]; unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_willmsgresp(buf, buflen, (int) returnCode); int len = MQTTSNSerialize_willmsgresp(buf, buflen, (int) returnCode);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::setCONNECT(MQTTSNPacket_connectData* options) int MQTTSNPacket::setCONNECT(MQTTSNPacket_connectData* options)
@@ -323,262 +330,276 @@ int MQTTSNPacket::setPINGREQ(MQTTSNString* clientId)
{ {
unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE]; unsigned char buf[MQTTSNGW_MAX_PACKET_SIZE];
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len = MQTTSNSerialize_pingreq( buf, buflen, *clientId); int len = MQTTSNSerialize_pingreq(buf, buflen, *clientId);
return desirialize(buf, len); return desirialize(buf, len);
} }
int MQTTSNPacket::getSERCHGW(uint8_t* radius) int MQTTSNPacket::getSERCHGW(uint8_t* radius)
{ {
return MQTTSNDeserialize_searchgw((unsigned char*) radius, (unsigned char*) _buf, _bufLen); return MQTTSNDeserialize_searchgw((unsigned char*) radius,
(unsigned char*) _buf, _bufLen);
} }
int MQTTSNPacket::getCONNECT(MQTTSNPacket_connectData* data) int MQTTSNPacket::getCONNECT(MQTTSNPacket_connectData* data)
{ {
return MQTTSNDeserialize_connect(data, _buf, _bufLen); return MQTTSNDeserialize_connect(data, _buf, _bufLen);
} }
int MQTTSNPacket::getCONNACK(uint8_t* returnCode) int MQTTSNPacket::getCONNACK(uint8_t* returnCode)
{ {
return MQTTSNSerialize_connack(_buf, _bufLen, (int) *returnCode); return MQTTSNSerialize_connack(_buf, _bufLen, (int) *returnCode);
} }
int MQTTSNPacket::getWILLTOPIC(int* willQoS, uint8_t* willRetain, MQTTSNString* willTopic) int MQTTSNPacket::getWILLTOPIC(int* willQoS, uint8_t* willRetain,
MQTTSNString* willTopic)
{ {
return MQTTSNDeserialize_willtopic((int*) willQoS, (unsigned char*) willRetain, willTopic, _buf, _bufLen); return MQTTSNDeserialize_willtopic((int*) willQoS,
(unsigned char*) willRetain, willTopic, _buf, _bufLen);
} }
int MQTTSNPacket::getWILLMSG(MQTTSNString* willmsg) int MQTTSNPacket::getWILLMSG(MQTTSNString* willmsg)
{ {
return MQTTSNDeserialize_willmsg(willmsg, _buf, _bufLen); return MQTTSNDeserialize_willmsg(willmsg, _buf, _bufLen);
} }
int MQTTSNPacket::getREGISTER(uint16_t* topicId, uint16_t* msgId, MQTTSNString* topicName) int MQTTSNPacket::getREGISTER(uint16_t* topicId, uint16_t* msgId,
MQTTSNString* topicName)
{ {
return MQTTSNDeserialize_register((unsigned short*) topicId, (unsigned short*) msgId, topicName, return MQTTSNDeserialize_register((unsigned short*) topicId,
_buf, _bufLen); (unsigned short*) msgId, topicName, _buf, _bufLen);
} }
int MQTTSNPacket::getREGACK(uint16_t* topicId, uint16_t* msgId, uint8_t* returnCode) int MQTTSNPacket::getREGACK(uint16_t* topicId, uint16_t* msgId,
uint8_t* returnCode)
{ {
return MQTTSNDeserialize_regack((unsigned short*) topicId, (unsigned short*) msgId, (unsigned char*) returnCode, _buf, _bufLen); return MQTTSNDeserialize_regack((unsigned short*) topicId,
(unsigned short*) msgId, (unsigned char*) returnCode, _buf, _bufLen);
} }
int MQTTSNPacket::getPUBLISH(uint8_t* dup, int* qos, uint8_t* retained, uint16_t* msgId, MQTTSN_topicid* topic, int MQTTSNPacket::getPUBLISH(uint8_t* dup, int* qos, uint8_t* retained,
uint8_t** payload, int* payloadlen) uint16_t* msgId, MQTTSN_topicid* topic, uint8_t** payload,
int* payloadlen)
{ {
return MQTTSNDeserialize_publish((unsigned char*) dup, qos, (unsigned char*) retained, (unsigned short*) msgId, return MQTTSNDeserialize_publish((unsigned char*) dup, qos,
topic, (unsigned char**) payload, (int*) payloadlen, _buf, _bufLen); (unsigned char*) retained, (unsigned short*) msgId, topic,
(unsigned char**) payload, (int*) payloadlen, _buf, _bufLen);
} }
int MQTTSNPacket::getPUBACK(uint16_t* topicId, uint16_t* msgId, uint8_t* returnCode) int MQTTSNPacket::getPUBACK(uint16_t* topicId, uint16_t* msgId,
uint8_t* returnCode)
{ {
return MQTTSNDeserialize_puback((unsigned short*) topicId, (unsigned short*) msgId, (unsigned char*) returnCode, return MQTTSNDeserialize_puback((unsigned short*) topicId,
_buf, _bufLen); (unsigned short*) msgId, (unsigned char*) returnCode, _buf, _bufLen);
} }
int MQTTSNPacket::getACK(uint16_t* msgId) int MQTTSNPacket::getACK(uint16_t* msgId)
{ {
unsigned char type; unsigned char type;
return MQTTSNDeserialize_ack(&type, (unsigned short*) msgId, _buf, _bufLen); return MQTTSNDeserialize_ack(&type, (unsigned short*) msgId, _buf, _bufLen);
} }
int MQTTSNPacket::getSUBSCRIBE(uint8_t* dup, int* qos, uint16_t* msgId, MQTTSN_topicid* topicFilter) int MQTTSNPacket::getSUBSCRIBE(uint8_t* dup, int* qos, uint16_t* msgId,
MQTTSN_topicid* topicFilter)
{ {
return MQTTSNDeserialize_subscribe((unsigned char*) dup, qos, (unsigned short*) msgId, topicFilter, _buf, _bufLen); return MQTTSNDeserialize_subscribe((unsigned char*) dup, qos,
(unsigned short*) msgId, topicFilter, _buf, _bufLen);
} }
int MQTTSNPacket::getUNSUBSCRIBE(uint16_t* msgId, MQTTSN_topicid* topicFilter) int MQTTSNPacket::getUNSUBSCRIBE(uint16_t* msgId, MQTTSN_topicid* topicFilter)
{ {
return MQTTSNDeserialize_unsubscribe((unsigned short*) msgId, topicFilter, _buf, _bufLen); return MQTTSNDeserialize_unsubscribe((unsigned short*) msgId, topicFilter,
_buf, _bufLen);
} }
int MQTTSNPacket::getPINGREQ(void) int MQTTSNPacket::getPINGREQ(void)
{ {
if (getType() == MQTTSN_PINGRESP && _bufLen > 2 ) if (getType() == MQTTSN_PINGRESP && _bufLen > 2)
{ {
return _bufLen - 2; return _bufLen - 2;
} }
return 0; return 0;
} }
int MQTTSNPacket::getDISCONNECT(uint16_t* duration) int MQTTSNPacket::getDISCONNECT(uint16_t* duration)
{ {
int dur = 0; int dur = 0;
int rc = MQTTSNDeserialize_disconnect(&dur, _buf, _bufLen); int rc = MQTTSNDeserialize_disconnect(&dur, _buf, _bufLen);
*duration = (uint16_t)dur; *duration = (uint16_t) dur;
return rc; return rc;
} }
int MQTTSNPacket::getWILLTOPICUPD(uint8_t* willQoS, uint8_t* willRetain, MQTTSNString* willTopic) int MQTTSNPacket::getWILLTOPICUPD(uint8_t* willQoS, uint8_t* willRetain,
MQTTSNString* willTopic)
{ {
return MQTTSNDeserialize_willtopicupd((int*) willQoS, (unsigned char*) willRetain, willTopic, _buf, _bufLen); return MQTTSNDeserialize_willtopicupd((int*) willQoS,
(unsigned char*) willRetain, willTopic, _buf, _bufLen);
} }
int MQTTSNPacket::getWILLMSGUPD(MQTTSNString* willMsg) int MQTTSNPacket::getWILLMSGUPD(MQTTSNString* willMsg)
{ {
return MQTTSNDeserialize_willmsgupd(willMsg, _buf, _bufLen); return MQTTSNDeserialize_willmsgupd(willMsg, _buf, _bufLen);
} }
char* MQTTSNPacket::print(char* pbuf) char* MQTTSNPacket::print(char* pbuf)
{ {
char* ptr = pbuf; char* ptr = pbuf;
char** pptr = &pbuf; char** pptr = &pbuf;
int size = _bufLen > SIZE_OF_LOG_PACKET ? SIZE_OF_LOG_PACKET : _bufLen; int size = _bufLen > SIZE_OF_LOG_PACKET ? SIZE_OF_LOG_PACKET : _bufLen;
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
{ {
sprintf(*pptr, " %02X", *(_buf + i)); sprintf(*pptr, " %02X", *(_buf + i));
*pptr += 3; *pptr += 3;
} }
**pptr = 0; **pptr = 0;
return ptr; return ptr;
} }
char* MQTTSNPacket::getMsgId(char* pbuf) char* MQTTSNPacket::getMsgId(char* pbuf)
{ {
int value = 0; int value = 0;
int p = 0; int p = 0;
switch ( getType() ) switch (getType())
{ {
case MQTTSN_PUBLISH: case MQTTSN_PUBLISH:
p = MQTTSNPacket_decode(_buf, _bufLen, &value); p = MQTTSNPacket_decode(_buf, _bufLen, &value);
if ( _buf[p + 1] & 0x80 ) if (_buf[p + 1] & 0x80)
{ {
sprintf(pbuf, "+%02X%02X", _buf[p + 4], _buf[p + 5]); sprintf(pbuf, "+%02X%02X", _buf[p + 4], _buf[p + 5]);
} }
else else
{ {
sprintf(pbuf, " %02X%02X", _buf[p + 4], _buf[p + 5]); sprintf(pbuf, " %02X%02X", _buf[p + 4], _buf[p + 5]);
} }
break; break;
case MQTTSN_PUBACK: case MQTTSN_PUBACK:
case MQTTSN_REGISTER: case MQTTSN_REGISTER:
case MQTTSN_REGACK: case MQTTSN_REGACK:
sprintf(pbuf, " %02X%02X", _buf[4], _buf[5]); sprintf(pbuf, " %02X%02X", _buf[4], _buf[5]);
break; break;
case MQTTSN_PUBREC: case MQTTSN_PUBREC:
case MQTTSN_PUBREL: case MQTTSN_PUBREL:
case MQTTSN_PUBCOMP: case MQTTSN_PUBCOMP:
case MQTTSN_UNSUBACK: case MQTTSN_UNSUBACK:
sprintf(pbuf, " %02X%02X", _buf[2], _buf[3]); sprintf(pbuf, " %02X%02X", _buf[2], _buf[3]);
break; break;
case MQTTSN_SUBSCRIBE: case MQTTSN_SUBSCRIBE:
case MQTTSN_UNSUBSCRIBE: case MQTTSN_UNSUBSCRIBE:
p = MQTTSNPacket_decode(_buf, _bufLen, &value); p = MQTTSNPacket_decode(_buf, _bufLen, &value);
sprintf(pbuf, " %02X%02X", _buf[p + 2], _buf[p + 3]); sprintf(pbuf, " %02X%02X", _buf[p + 2], _buf[p + 3]);
break; break;
case MQTTSN_SUBACK: case MQTTSN_SUBACK:
sprintf(pbuf, " %02X%02X", _buf[5], _buf[6]); sprintf(pbuf, " %02X%02X", _buf[5], _buf[6]);
break; break;
default: default:
sprintf(pbuf, " "); sprintf(pbuf, " ");
break; break;
} }
if ( strcmp(pbuf, " 0000") == 0 ) if (strcmp(pbuf, " 0000") == 0)
{ {
sprintf(pbuf, " "); sprintf(pbuf, " ");
} }
return pbuf; return pbuf;
} }
int MQTTSNPacket::getMsgId(void) int MQTTSNPacket::getMsgId(void)
{ {
int value = 0; int value = 0;
int p = 0; int p = 0;
int msgId = 0; int msgId = 0;
char* ptr = 0; char* ptr = 0;
switch ( getType() ) switch (getType())
{ {
case MQTTSN_PUBLISH: case MQTTSN_PUBLISH:
p = MQTTSNPacket_decode(_buf, _bufLen, &value); p = MQTTSNPacket_decode(_buf, _bufLen, &value);
ptr = (char*)_buf + p + 4; ptr = (char*) _buf + p + 4;
msgId = readInt((char**)&ptr); msgId = readInt((char**) &ptr);
break; break;
case MQTTSN_PUBACK: case MQTTSN_PUBACK:
case MQTTSN_REGISTER: case MQTTSN_REGISTER:
case MQTTSN_REGACK: case MQTTSN_REGACK:
ptr = (char*)_buf + 4; ptr = (char*) _buf + 4;
msgId = readInt((char**)&ptr); msgId = readInt((char**) &ptr);
break; break;
case MQTTSN_PUBREC: case MQTTSN_PUBREC:
case MQTTSN_PUBREL: case MQTTSN_PUBREL:
case MQTTSN_PUBCOMP: case MQTTSN_PUBCOMP:
case MQTTSN_UNSUBACK: case MQTTSN_UNSUBACK:
ptr = (char*)_buf + 2; ptr = (char*) _buf + 2;
msgId = readInt((char**)&ptr); msgId = readInt((char**) &ptr);
break; break;
case MQTTSN_SUBSCRIBE: case MQTTSN_SUBSCRIBE:
case MQTTSN_UNSUBSCRIBE: case MQTTSN_UNSUBSCRIBE:
p = MQTTSNPacket_decode(_buf, _bufLen, &value); p = MQTTSNPacket_decode(_buf, _bufLen, &value);
ptr = (char*)_buf + p + 2; ptr = (char*) _buf + p + 2;
msgId = readInt((char**)&ptr); msgId = readInt((char**) &ptr);
break; break;
case MQTTSN_SUBACK: case MQTTSN_SUBACK:
ptr = (char*)_buf + 5; ptr = (char*) _buf + 5;
msgId = readInt((char**)&ptr); msgId = readInt((char**) &ptr);
break; break;
default: default:
break; break;
} }
return msgId; return msgId;
} }
void MQTTSNPacket::setMsgId(uint16_t msgId) void MQTTSNPacket::setMsgId(uint16_t msgId)
{ {
int value = 0; int value = 0;
int p = 0; int p = 0;
//unsigned char* ptr = 0; //unsigned char* ptr = 0;
switch ( getType() ) switch (getType())
{ {
case MQTTSN_PUBLISH: case MQTTSN_PUBLISH:
p = MQTTSNPacket_decode(_buf, _bufLen, &value); p = MQTTSNPacket_decode(_buf, _bufLen, &value);
_buf[p + 4] = (unsigned char)(msgId / 256); _buf[p + 4] = (unsigned char) (msgId / 256);
_buf[p + 5] = (unsigned char)(msgId % 256); _buf[p + 5] = (unsigned char) (msgId % 256);
//ptr = _buf + p + 4; //ptr = _buf + p + 4;
//writeInt(&ptr, msgId); //writeInt(&ptr, msgId);
break; break;
case MQTTSN_PUBACK: case MQTTSN_PUBACK:
case MQTTSN_REGISTER: case MQTTSN_REGISTER:
case MQTTSN_REGACK: case MQTTSN_REGACK:
_buf[4] = (unsigned char)(msgId / 256); _buf[4] = (unsigned char) (msgId / 256);
_buf[5] = (unsigned char)(msgId % 256); _buf[5] = (unsigned char) (msgId % 256);
//ptr = _buf + 4; //ptr = _buf + 4;
//writeInt(&ptr, msgId); //writeInt(&ptr, msgId);
break; break;
case MQTTSN_PUBREC: case MQTTSN_PUBREC:
case MQTTSN_PUBREL: case MQTTSN_PUBREL:
case MQTTSN_PUBCOMP: case MQTTSN_PUBCOMP:
case MQTTSN_UNSUBACK: case MQTTSN_UNSUBACK:
_buf[2] = (unsigned char)(msgId / 256); _buf[2] = (unsigned char) (msgId / 256);
_buf[3] = (unsigned char)(msgId % 256); _buf[3] = (unsigned char) (msgId % 256);
//ptr = _buf + 2; //ptr = _buf + 2;
//writeInt(&ptr, msgId); //writeInt(&ptr, msgId);
break; break;
case MQTTSN_SUBSCRIBE: case MQTTSN_SUBSCRIBE:
case MQTTSN_UNSUBSCRIBE: case MQTTSN_UNSUBSCRIBE:
p = MQTTSNPacket_decode(_buf, _bufLen, &value); p = MQTTSNPacket_decode(_buf, _bufLen, &value);
_buf[p + 2] = (unsigned char)(msgId / 256); _buf[p + 2] = (unsigned char) (msgId / 256);
_buf[p + 3] = (unsigned char)(msgId % 256); _buf[p + 3] = (unsigned char) (msgId % 256);
//ptr = _buf + p + 2; //ptr = _buf + p + 2;
//writeInt(&ptr, msgId); //writeInt(&ptr, msgId);
break; break;
case MQTTSN_SUBACK: case MQTTSN_SUBACK:
_buf[5] = (unsigned char)(msgId / 256); _buf[5] = (unsigned char) (msgId / 256);
_buf[6] = (unsigned char)(msgId % 256); _buf[6] = (unsigned char) (msgId % 256);
//ptr = _buf + 5; //ptr = _buf + 5;
//writeInt(&ptr, msgId); //writeInt(&ptr, msgId);
break; break;
default: default:
break; break;
} }
} }
bool MQTTSNPacket::isDuplicate(void) bool MQTTSNPacket::isDuplicate(void)
{ {
int value = 0; int value = 0;
int p = MQTTSNPacket_decode(_buf, _bufLen, &value); int p = MQTTSNPacket_decode(_buf, _bufLen, &value);
return ( _buf[p + 1] & 0x80 ); return (_buf[p + 1] & 0x80);
} }

125
MQTTSNGateway/src/MQTTSNGWPacket.h
View File

@@ -26,72 +26,77 @@ namespace MQTTSNGW
class MQTTSNPacket class MQTTSNPacket
{ {
public: public:
MQTTSNPacket(void); MQTTSNPacket(void);
MQTTSNPacket(MQTTSNPacket &packet); MQTTSNPacket(MQTTSNPacket &packet);
~MQTTSNPacket(void); ~MQTTSNPacket(void);
int unicast(SensorNetwork* network, SensorNetAddress* sendTo); int unicast(SensorNetwork* network, SensorNetAddress* sendTo);
int broadcast(SensorNetwork* network); int broadcast(SensorNetwork* network);
int recv(SensorNetwork* network); int recv(SensorNetwork* network);
int serialize(uint8_t* buf); int serialize(uint8_t* buf);
int desirialize(unsigned char* buf, unsigned short len); int desirialize(unsigned char* buf, unsigned short len);
int getType(void); int getType(void);
unsigned char* getPacketData(void); unsigned char* getPacketData(void);
int getPacketLength(void); int getPacketLength(void);
const char* getName(); const char* getName();
int setConnect(void); // Debug int setConnect(void); // Debug
int setADVERTISE(uint8_t gatewayid, uint16_t duration); int setADVERTISE(uint8_t gatewayid, uint16_t duration);
int setGWINFO(uint8_t gatewayId); int setGWINFO(uint8_t gatewayId);
int setCONNACK(uint8_t returnCode); int setCONNACK(uint8_t returnCode);
int setWILLTOPICREQ(void); int setWILLTOPICREQ(void);
int setWILLMSGREQ(void); int setWILLMSGREQ(void);
int setREGISTER(uint16_t topicId, uint16_t msgId, MQTTSNString* TopicName); int setREGISTER(uint16_t topicId, uint16_t msgId, MQTTSNString* TopicName);
int setREGACK(uint16_t topicId, uint16_t msgId, uint8_t returnCode); int setREGACK(uint16_t topicId, uint16_t msgId, uint8_t returnCode);
int setPUBLISH(uint8_t dup, int qos, uint8_t retained, uint16_t msgId, int setPUBLISH(uint8_t dup, int qos, uint8_t retained, uint16_t msgId,
MQTTSN_topicid topic, uint8_t* payload, uint16_t payloadlen); MQTTSN_topicid topic, uint8_t* payload, uint16_t payloadlen);
int setPUBACK(uint16_t topicId, uint16_t msgId, uint8_t returnCode); int setPUBACK(uint16_t topicId, uint16_t msgId, uint8_t returnCode);
int setPUBREC(uint16_t msgId); int setPUBREC(uint16_t msgId);
int setPUBREL(uint16_t msgId); int setPUBREL(uint16_t msgId);
int setPUBCOMP(uint16_t msgId); int setPUBCOMP(uint16_t msgId);
int setSUBACK(int qos, uint16_t topicId, uint16_t msgId, uint8_t returnCode); int setSUBACK(int qos, uint16_t topicId, uint16_t msgId,
int setUNSUBACK(uint16_t msgId); uint8_t returnCode);
int setPINGRESP(void); int setUNSUBACK(uint16_t msgId);
int setDISCONNECT(uint16_t duration); int setPINGRESP(void);
int setWILLTOPICRESP(uint8_t returnCode); int setDISCONNECT(uint16_t duration);
int setWILLMSGRESP(uint8_t returnCode); int setWILLTOPICRESP(uint8_t returnCode);
int setWILLMSGRESP(uint8_t returnCode);
int setCONNECT(MQTTSNPacket_connectData* options); int setCONNECT(MQTTSNPacket_connectData* options);
int setPINGREQ(MQTTSNString* clientId); int setPINGREQ(MQTTSNString* clientId);
int getSERCHGW(uint8_t* radius); int getSERCHGW(uint8_t* radius);
int getCONNECT(MQTTSNPacket_connectData* option); int getCONNECT(MQTTSNPacket_connectData* option);
int getCONNACK(uint8_t* returnCode); int getCONNACK(uint8_t* returnCode);
int getWILLTOPIC(int* willQoS, uint8_t* willRetain, MQTTSNString* willTopic); int getWILLTOPIC(int* willQoS, uint8_t* willRetain,
int getWILLMSG(MQTTSNString* willmsg); MQTTSNString* willTopic);
int getREGISTER(uint16_t* topicId, uint16_t* msgId, MQTTSNString* topicName); int getWILLMSG(MQTTSNString* willmsg);
int getREGACK(uint16_t* topicId, uint16_t* msgId, uint8_t* returnCode); int getREGISTER(uint16_t* topicId, uint16_t* msgId,
int getPUBLISH(uint8_t* dup, int* qos, uint8_t* retained, uint16_t* msgId, MQTTSNString* topicName);
MQTTSN_topicid* topic, unsigned char** payload, int* payloadlen); int getREGACK(uint16_t* topicId, uint16_t* msgId, uint8_t* returnCode);
int getPUBACK(uint16_t* topicId, uint16_t* msgId, uint8_t* returnCode); int getPUBLISH(uint8_t* dup, int* qos, uint8_t* retained, uint16_t* msgId,
int getACK(uint16_t* msgId); MQTTSN_topicid* topic, unsigned char** payload, int* payloadlen);
int getSUBSCRIBE(uint8_t* dup, int* qos, uint16_t* msgId, MQTTSN_topicid* topicFilter); int getPUBACK(uint16_t* topicId, uint16_t* msgId, uint8_t* returnCode);
int getUNSUBSCRIBE(uint16_t* msgId, MQTTSN_topicid* topicFilter); int getACK(uint16_t* msgId);
int getPINGREQ(void); int getSUBSCRIBE(uint8_t* dup, int* qos, uint16_t* msgId,
int getDISCONNECT(uint16_t* duration); MQTTSN_topicid* topicFilter);
int getWILLTOPICUPD(uint8_t* willQoS, uint8_t* willRetain, MQTTSNString* willTopic); int getUNSUBSCRIBE(uint16_t* msgId, MQTTSN_topicid* topicFilter);
int getWILLMSGUPD(MQTTSNString* willMsg); int getPINGREQ(void);
int getDISCONNECT(uint16_t* duration);
int getWILLTOPICUPD(uint8_t* willQoS, uint8_t* willRetain,
MQTTSNString* willTopic);
int getWILLMSGUPD(MQTTSNString* willMsg);
bool isAccepted(void); bool isAccepted(void);
bool isDuplicate(void); bool isDuplicate(void);
bool isQoSMinusPUBLISH(void); bool isQoSMinusPUBLISH(void);
char* getMsgId(char* buf); char* getMsgId(char* buf);
int getMsgId(void); int getMsgId(void);
void setMsgId(uint16_t msgId); void setMsgId(uint16_t msgId);
char* print(char* buf); char* print(char* buf);
private: private:
unsigned char* _buf; // Ptr to a packet data unsigned char* _buf; // Ptr to a packet data
int _bufLen; // length of the packet data int _bufLen; // length of the packet data
}; };
} }

577
MQTTSNGateway/src/MQTTSNGWPacketHandleTask.cpp
View File

@@ -44,16 +44,16 @@ char* currentDateTime(void);
PacketHandleTask::PacketHandleTask(Gateway* gateway) PacketHandleTask::PacketHandleTask(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
_gateway->attach((Thread*)this); _gateway->attach((Thread*) this);
_mqttConnection = new MQTTGWConnectionHandler(_gateway); _mqttConnection = new MQTTGWConnectionHandler(_gateway);
_mqttPublish = new MQTTGWPublishHandler(_gateway); _mqttPublish = new MQTTGWPublishHandler(_gateway);
_mqttSubscribe = new MQTTGWSubscribeHandler(_gateway); _mqttSubscribe = new MQTTGWSubscribeHandler(_gateway);
_mqttsnConnection = new MQTTSNConnectionHandler(_gateway); _mqttsnConnection = new MQTTSNConnectionHandler(_gateway);
_mqttsnPublish = new MQTTSNPublishHandler(_gateway); _mqttsnPublish = new MQTTSNPublishHandler(_gateway);
_mqttsnSubscribe = new MQTTSNSubscribeHandler(_gateway); _mqttsnSubscribe = new MQTTSNSubscribeHandler(_gateway);
_mqttsnAggrConnection = new MQTTSNAggregateConnectionHandler(_gateway); _mqttsnAggrConnection = new MQTTSNAggregateConnectionHandler(_gateway);
} }
/** /**
@@ -61,315 +61,314 @@ PacketHandleTask::PacketHandleTask(Gateway* gateway)
*/ */
PacketHandleTask::~PacketHandleTask() PacketHandleTask::~PacketHandleTask()
{ {
if ( _mqttConnection ) if (_mqttConnection)
{ {
delete _mqttConnection; delete _mqttConnection;
} }
if ( _mqttPublish ) if (_mqttPublish)
{ {
delete _mqttPublish; delete _mqttPublish;
} }
if ( _mqttSubscribe ) if (_mqttSubscribe)
{ {
delete _mqttSubscribe; delete _mqttSubscribe;
} }
if ( _mqttsnConnection ) if (_mqttsnConnection)
{ {
delete _mqttsnConnection; delete _mqttsnConnection;
} }
if ( _mqttsnPublish ) if (_mqttsnPublish)
{ {
delete _mqttsnPublish; delete _mqttsnPublish;
} }
if ( _mqttsnSubscribe ) if (_mqttsnSubscribe)
{ {
delete _mqttsnSubscribe; delete _mqttsnSubscribe;
} }
if ( _mqttsnAggrConnection ) if (_mqttsnAggrConnection)
{ {
delete _mqttsnAggrConnection; delete _mqttsnAggrConnection;
} }
} }
void PacketHandleTask::run() void PacketHandleTask::run()
{ {
Event* ev = nullptr; Event* ev = nullptr;
EventQue* eventQue = _gateway->getPacketEventQue(); EventQue* eventQue = _gateway->getPacketEventQue();
AdapterManager* adpMgr = _gateway->getAdapterManager(); AdapterManager* adpMgr = _gateway->getAdapterManager();
Client* client = nullptr; Client* client = nullptr;
MQTTSNPacket* snPacket = nullptr; MQTTSNPacket* snPacket = nullptr;
MQTTGWPacket* brPacket = nullptr; MQTTGWPacket* brPacket = nullptr;
char msgId[6]; char msgId[6];
memset(msgId, 0, 6); memset(msgId, 0, 6);
_advertiseTimer.start(_gateway->getGWParams()->keepAlive * 1000UL); _advertiseTimer.start(_gateway->getGWParams()->keepAlive * 1000UL);
while (true) while (true)
{ {
/* wait Event */ /* wait Event */
ev = eventQue->timedwait(EVENT_QUE_TIME_OUT); ev = eventQue->timedwait(EVENT_QUE_TIME_OUT);
if (ev->getEventType() == EtStop) if (ev->getEventType() == EtStop)
{ {
WRITELOG("\n%s PacketHandleTask stopped.", currentDateTime()); WRITELOG("\n%s PacketHandleTask stopped.", currentDateTime());
delete ev; delete ev;
return; return;
} }
if (ev->getEventType() == EtTimeout) if (ev->getEventType() == EtTimeout)
{ {
/*------ Check Keep Alive Timer & send Advertise ------*/ /*------ Check Keep Alive Timer & send Advertise ------*/
if (_advertiseTimer.isTimeup()) if (_advertiseTimer.isTimeup())
{ {
_mqttsnConnection->sendADVERTISE(); _mqttsnConnection->sendADVERTISE();
_advertiseTimer.start(_gateway->getGWParams()->keepAlive * 1000UL); _advertiseTimer.start(
} _gateway->getGWParams()->keepAlive * 1000UL);
}
/*------ Check Adapters Connect or PINGREQ ------*/ /*------ Check Adapters Connect or PINGREQ ------*/
adpMgr->checkConnection(); adpMgr->checkConnection();
} }
/*------ Handle SEARCHGW Message ---------*/ /*------ Handle SEARCHGW Message ---------*/
else if (ev->getEventType() == EtBroadcast) else if (ev->getEventType() == EtBroadcast)
{ {
snPacket = ev->getMQTTSNPacket(); snPacket = ev->getMQTTSNPacket();
_mqttsnConnection->handleSearchgw(snPacket); _mqttsnConnection->handleSearchgw(snPacket);
} }
/*------ Handle Messages form Clients ---------*/ /*------ Handle Messages form Clients ---------*/
else if (ev->getEventType() == EtClientRecv) else if (ev->getEventType() == EtClientRecv)
{ {
client = ev->getClient(); client = ev->getClient();
snPacket = ev->getMQTTSNPacket(); snPacket = ev->getMQTTSNPacket();
DEBUGLOG(" PacketHandleTask gets %s %s from the client.\n", snPacket->getName(), snPacket->getMsgId(msgId)); DEBUGLOG(" PacketHandleTask gets %s %s from the client.\n", snPacket->getName(), snPacket->getMsgId(msgId));
if ( adpMgr->isAggregatedClient(client) ) if (adpMgr->isAggregatedClient(client))
{ {
aggregatePacketHandler(client, snPacket); // client is converted to Aggregater by BrokerSendTask aggregatePacketHandler(client, snPacket); // client is converted to Aggregater by BrokerSendTask
} }
else else
{ {
transparentPacketHandler(client, snPacket); transparentPacketHandler(client, snPacket);
} }
/* Reset the Timer for PINGREQ. */
client->updateStatus(snPacket);
}
/*------ Handle Messages form Broker ---------*/
else if (ev->getEventType() == EtBrokerRecv)
{
client = ev->getClient();
brPacket = ev->getMQTTGWPacket();
DEBUGLOG(" PacketHandleTask gets %s %s from the broker.\n", brPacket->getName(), brPacket->getMsgId(msgId));
/* Reset the Timer for PINGREQ. */ if (client->isAggregater())
client->updateStatus(snPacket); {
} aggregatePacketHandler(client, brPacket);
/*------ Handle Messages form Broker ---------*/ }
else if ( ev->getEventType() == EtBrokerRecv ) else
{ {
client = ev->getClient(); transparentPacketHandler(client, brPacket);
brPacket = ev->getMQTTGWPacket(); }
DEBUGLOG(" PacketHandleTask gets %s %s from the broker.\n", brPacket->getName(), brPacket->getMsgId(msgId)); }
delete ev;
}
if ( client->isAggregater() )
{
aggregatePacketHandler(client, brPacket);
}
else
{
transparentPacketHandler(client, brPacket);
}
}
delete ev;
}
} }
void PacketHandleTask::aggregatePacketHandler(Client*client,
MQTTSNPacket* packet)
void PacketHandleTask::aggregatePacketHandler(Client*client, MQTTSNPacket* packet)
{ {
switch (packet->getType()) switch (packet->getType())
{ {
case MQTTSN_CONNECT: case MQTTSN_CONNECT:
_mqttsnAggrConnection->handleConnect(client, packet); _mqttsnAggrConnection->handleConnect(client, packet);
break; break;
case MQTTSN_WILLTOPIC: case MQTTSN_WILLTOPIC:
_mqttsnConnection->handleWilltopic(client, packet); _mqttsnConnection->handleWilltopic(client, packet);
break; break;
case MQTTSN_WILLMSG: case MQTTSN_WILLMSG:
_mqttsnAggrConnection->handleWillmsg(client, packet); _mqttsnAggrConnection->handleWillmsg(client, packet);
break; break;
case MQTTSN_DISCONNECT: case MQTTSN_DISCONNECT:
_mqttsnAggrConnection->handleDisconnect(client, packet); _mqttsnAggrConnection->handleDisconnect(client, packet);
break; break;
case MQTTSN_WILLTOPICUPD: case MQTTSN_WILLTOPICUPD:
_mqttsnConnection->handleWilltopicupd(client, packet); _mqttsnConnection->handleWilltopicupd(client, packet);
break; break;
case MQTTSN_WILLMSGUPD: case MQTTSN_WILLMSGUPD:
_mqttsnConnection->handleWillmsgupd(client, packet); _mqttsnConnection->handleWillmsgupd(client, packet);
break; break;
case MQTTSN_PINGREQ: case MQTTSN_PINGREQ:
_mqttsnAggrConnection->handlePingreq(client, packet); _mqttsnAggrConnection->handlePingreq(client, packet);
break; break;
case MQTTSN_PUBLISH: case MQTTSN_PUBLISH:
_mqttsnPublish->handleAggregatePublish(client, packet); _mqttsnPublish->handleAggregatePublish(client, packet);
break; break;
case MQTTSN_PUBACK: case MQTTSN_PUBACK:
_mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBACK); _mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBACK);
break; break;
case MQTTSN_PUBREC: case MQTTSN_PUBREC:
_mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBREC); _mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBREC);
break; break;
case MQTTSN_PUBREL: case MQTTSN_PUBREL:
_mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBREL); _mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBREL);
break; break;
case MQTTSN_PUBCOMP: case MQTTSN_PUBCOMP:
_mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBCOMP); _mqttsnPublish->handleAggregateAck(client, packet, MQTTSN_PUBCOMP);
break; break;
case MQTTSN_REGISTER: case MQTTSN_REGISTER:
_mqttsnPublish->handleRegister(client, packet); _mqttsnPublish->handleRegister(client, packet);
break; break;
case MQTTSN_REGACK: case MQTTSN_REGACK:
_mqttsnPublish->handleRegAck(client, packet); _mqttsnPublish->handleRegAck(client, packet);
break; break;
case MQTTSN_SUBSCRIBE: case MQTTSN_SUBSCRIBE:
_mqttsnSubscribe->handleAggregateSubscribe(client, packet); _mqttsnSubscribe->handleAggregateSubscribe(client, packet);
break; break;
case MQTTSN_UNSUBSCRIBE: case MQTTSN_UNSUBSCRIBE:
_mqttsnSubscribe->handleAggregateUnsubscribe(client, packet); _mqttsnSubscribe->handleAggregateUnsubscribe(client, packet);
break; break;
default: default:
break; break;
} }
} }
void PacketHandleTask::aggregatePacketHandler(Client*client,
void PacketHandleTask::aggregatePacketHandler(Client*client, MQTTGWPacket* packet) MQTTGWPacket* packet)
{ {
switch (packet->getType()) switch (packet->getType())
{ {
case CONNACK: case CONNACK:
_mqttConnection->handleConnack(client, packet); _mqttConnection->handleConnack(client, packet);
break; break;
case PINGRESP: case PINGRESP:
_mqttConnection->handlePingresp(client, packet); _mqttConnection->handlePingresp(client, packet);
break; break;
case PUBLISH: case PUBLISH:
_mqttPublish->handleAggregatePublish(client, packet); _mqttPublish->handleAggregatePublish(client, packet);
break; break;
case PUBACK: case PUBACK:
_mqttPublish->handleAggregatePuback(client, packet); _mqttPublish->handleAggregatePuback(client, packet);
break; break;
case PUBREC: case PUBREC:
_mqttPublish->handleAggregateAck(client, packet, PUBREC); _mqttPublish->handleAggregateAck(client, packet, PUBREC);
break; break;
case PUBREL: case PUBREL:
_mqttPublish->handleAggregatePubrel(client, packet); _mqttPublish->handleAggregatePubrel(client, packet);
break; break;
case PUBCOMP: case PUBCOMP:
_mqttPublish->handleAggregateAck(client, packet, PUBCOMP); _mqttPublish->handleAggregateAck(client, packet, PUBCOMP);
break; break;
case SUBACK: case SUBACK:
_mqttSubscribe->handleAggregateSuback(client, packet); _mqttSubscribe->handleAggregateSuback(client, packet);
break; break;
case UNSUBACK: case UNSUBACK:
_mqttSubscribe->handleAggregateUnsuback(client, packet); _mqttSubscribe->handleAggregateUnsuback(client, packet);
break; break;
default: default:
break; break;
} }
} }
void PacketHandleTask::transparentPacketHandler(Client*client, MQTTSNPacket* packet) void PacketHandleTask::transparentPacketHandler(Client*client,
MQTTSNPacket* packet)
{ {
switch (packet->getType()) switch (packet->getType())
{ {
case MQTTSN_CONNECT: case MQTTSN_CONNECT:
_mqttsnConnection->handleConnect(client, packet); _mqttsnConnection->handleConnect(client, packet);
break; break;
case MQTTSN_WILLTOPIC: case MQTTSN_WILLTOPIC:
_mqttsnConnection->handleWilltopic(client, packet); _mqttsnConnection->handleWilltopic(client, packet);
break; break;
case MQTTSN_WILLMSG: case MQTTSN_WILLMSG:
_mqttsnConnection->handleWillmsg(client, packet); _mqttsnConnection->handleWillmsg(client, packet);
break; break;
case MQTTSN_DISCONNECT: case MQTTSN_DISCONNECT:
_mqttsnConnection->handleDisconnect(client, packet); _mqttsnConnection->handleDisconnect(client, packet);
break; break;
case MQTTSN_WILLTOPICUPD: case MQTTSN_WILLTOPICUPD:
_mqttsnConnection->handleWilltopicupd(client, packet); _mqttsnConnection->handleWilltopicupd(client, packet);
break; break;
case MQTTSN_WILLMSGUPD: case MQTTSN_WILLMSGUPD:
_mqttsnConnection->handleWillmsgupd(client, packet); _mqttsnConnection->handleWillmsgupd(client, packet);
break; break;
case MQTTSN_PINGREQ: case MQTTSN_PINGREQ:
_mqttsnConnection->handlePingreq(client, packet); _mqttsnConnection->handlePingreq(client, packet);
break; break;
case MQTTSN_PUBLISH: case MQTTSN_PUBLISH:
_mqttsnPublish->handlePublish(client, packet); _mqttsnPublish->handlePublish(client, packet);
break; break;
case MQTTSN_PUBACK: case MQTTSN_PUBACK:
_mqttsnPublish->handlePuback(client, packet); _mqttsnPublish->handlePuback(client, packet);
break; break;
case MQTTSN_PUBREC: case MQTTSN_PUBREC:
_mqttsnPublish->handleAck(client, packet, PUBREC); _mqttsnPublish->handleAck(client, packet, PUBREC);
break; break;
case MQTTSN_PUBREL: case MQTTSN_PUBREL:
_mqttsnPublish->handleAck(client, packet, PUBREL); _mqttsnPublish->handleAck(client, packet, PUBREL);
break; break;
case MQTTSN_PUBCOMP: case MQTTSN_PUBCOMP:
_mqttsnPublish->handleAck(client, packet, PUBCOMP); _mqttsnPublish->handleAck(client, packet, PUBCOMP);
break; break;
case MQTTSN_REGISTER: case MQTTSN_REGISTER:
_mqttsnPublish->handleRegister(client, packet); _mqttsnPublish->handleRegister(client, packet);
break; break;
case MQTTSN_REGACK: case MQTTSN_REGACK:
_mqttsnPublish->handleRegAck(client, packet); _mqttsnPublish->handleRegAck(client, packet);
break; break;
case MQTTSN_SUBSCRIBE: case MQTTSN_SUBSCRIBE:
_mqttsnSubscribe->handleSubscribe(client, packet); _mqttsnSubscribe->handleSubscribe(client, packet);
break; break;
case MQTTSN_UNSUBSCRIBE: case MQTTSN_UNSUBSCRIBE:
_mqttsnSubscribe->handleUnsubscribe(client, packet); _mqttsnSubscribe->handleUnsubscribe(client, packet);
break; break;
default: default:
break; break;
} }
} }
void PacketHandleTask::transparentPacketHandler(Client*client,
void PacketHandleTask::transparentPacketHandler(Client*client, MQTTGWPacket* packet) MQTTGWPacket* packet)
{ {
switch (packet->getType()) switch (packet->getType())
{ {
case CONNACK: case CONNACK:
_mqttConnection->handleConnack(client, packet); _mqttConnection->handleConnack(client, packet);
break; break;
case PINGRESP: case PINGRESP:
_mqttConnection->handlePingresp(client, packet); _mqttConnection->handlePingresp(client, packet);
break; break;
case PUBLISH: case PUBLISH:
_mqttPublish->handlePublish(client, packet); _mqttPublish->handlePublish(client, packet);
break; break;
case PUBACK: case PUBACK:
_mqttPublish->handlePuback(client, packet); _mqttPublish->handlePuback(client, packet);
break; break;
case PUBREC: case PUBREC:
_mqttPublish->handleAck(client, packet, PUBREC); _mqttPublish->handleAck(client, packet, PUBREC);
break; break;
case PUBREL: case PUBREL:
_mqttPublish->handleAck(client, packet, PUBREL); _mqttPublish->handleAck(client, packet, PUBREL);
break; break;
case PUBCOMP: case PUBCOMP:
_mqttPublish->handleAck(client, packet, PUBCOMP); _mqttPublish->handleAck(client, packet, PUBCOMP);
break; break;
case SUBACK: case SUBACK:
_mqttSubscribe->handleSuback(client, packet); _mqttSubscribe->handleSuback(client, packet);
break; break;
case UNSUBACK: case UNSUBACK:
_mqttSubscribe->handleUnsuback(client, packet); _mqttSubscribe->handleUnsuback(client, packet);
break; break;
case DISCONNECT: case DISCONNECT:
client->disconnected(); // Just change Client's status to "Disconnected" client->disconnected(); // Just change Client's status to "Disconnected"
break; break;
default: default:
break; break;
} }
} }

53
MQTTSNGateway/src/MQTTSNGWPacketHandleTask.h
View File

@@ -40,40 +40,39 @@ class MQTTSNAggregateConnectionHandler;
class Thread; class Thread;
class Timer; class Timer;
/*===================================== /*=====================================
Class PacketHandleTask Class PacketHandleTask
=====================================*/ =====================================*/
class PacketHandleTask : public Thread class PacketHandleTask: public Thread
{ {
MAGIC_WORD_FOR_THREAD; MAGIC_WORD_FOR_THREAD;
friend class MQTTGWAggregatePublishHandler; friend class MQTTGWAggregatePublishHandler;
friend class MQTTGWAggregateSubscribeHandler; friend class MQTTGWAggregateSubscribeHandler;
friend class MQTTSNAggregateConnectionHandler; friend class MQTTSNAggregateConnectionHandler;
friend class MQTTSNAggregatePublishHandler; friend class MQTTSNAggregatePublishHandler;
friend class MQTTSNAggregateSubscribeHandler; friend class MQTTSNAggregateSubscribeHandler;
public: public:
PacketHandleTask(Gateway* gateway); PacketHandleTask(Gateway* gateway);
~PacketHandleTask(); ~PacketHandleTask();
void run(); void run();
private: private:
void aggregatePacketHandler(Client*client, MQTTSNPacket* packet); void aggregatePacketHandler(Client*client, MQTTSNPacket* packet);
void aggregatePacketHandler(Client*client, MQTTGWPacket* packet); void aggregatePacketHandler(Client*client, MQTTGWPacket* packet);
void transparentPacketHandler(Client*client, MQTTSNPacket* packet); void transparentPacketHandler(Client*client, MQTTSNPacket* packet);
void transparentPacketHandler(Client*client, MQTTGWPacket* packet); void transparentPacketHandler(Client*client, MQTTGWPacket* packet);
Gateway* _gateway {nullptr}; Gateway* _gateway
Timer _advertiseTimer; { nullptr };
Timer _sendUnixTimer; Timer _advertiseTimer;
MQTTGWConnectionHandler* _mqttConnection {nullptr}; Timer _sendUnixTimer;
MQTTGWPublishHandler* _mqttPublish {nullptr}; MQTTGWConnectionHandler* _mqttConnection { nullptr };
MQTTGWSubscribeHandler* _mqttSubscribe {nullptr}; MQTTGWPublishHandler* _mqttPublish { nullptr };
MQTTSNConnectionHandler* _mqttsnConnection {nullptr}; MQTTGWSubscribeHandler* _mqttSubscribe { nullptr };
MQTTSNPublishHandler* _mqttsnPublish {nullptr}; MQTTSNConnectionHandler* _mqttsnConnection { nullptr };
MQTTSNSubscribeHandler* _mqttsnSubscribe {nullptr}; MQTTSNPublishHandler* _mqttsnPublish { nullptr };
MQTTSNSubscribeHandler* _mqttsnSubscribe { nullptr };
MQTTSNAggregateConnectionHandler* _mqttsnAggrConnection {nullptr}; MQTTSNAggregateConnectionHandler* _mqttsnAggrConnection { nullptr };
}; };
} }
#endif /* MQTTSNGWPACKETHANDLETASK_H_ */ #endif /* MQTTSNGWPACKETHANDLETASK_H_ */

452
MQTTSNGateway/src/MQTTSNGWProcess.cpp
View File

@@ -44,7 +44,7 @@ volatile int theSignaled = 0;
static void signalHandler(int sig) static void signalHandler(int sig)
{ {
theSignaled = sig; theSignaled = sig;
} }
/*===================================== /*=====================================
@@ -52,23 +52,23 @@ static void signalHandler(int sig)
====================================*/ ====================================*/
Process::Process() Process::Process()
{ {
_argc = 0; _argc = 0;
_argv = 0; _argv = 0;
_configDir = CONFIG_DIRECTORY; _configDir = CONFIG_DIRECTORY;
_configFile = CONFIG_FILE; _configFile = CONFIG_FILE;
_log = 0; _log = 0;
} }
Process::~Process() Process::~Process()
{ {
if (_rb ) if (_rb)
{ {
delete _rb; delete _rb;
} }
if ( _rbsem ) if (_rbsem)
{ {
delete _rbsem; delete _rbsem;
} }
} }
void Process::run() void Process::run()
@@ -78,168 +78,169 @@ void Process::run()
void Process::initialize(int argc, char** argv) void Process::initialize(int argc, char** argv)
{ {
char param[MQTTSNGW_PARAM_MAX]; char param[MQTTSNGW_PARAM_MAX];
_argc = argc; _argc = argc;
_argv = argv; _argv = argv;
signal(SIGINT, signalHandler); signal(SIGINT, signalHandler);
signal(SIGTERM, signalHandler); signal(SIGTERM, signalHandler);
signal(SIGHUP, signalHandler); signal(SIGHUP, signalHandler);
int opt; int opt;
while ((opt = getopt(_argc, _argv, "f:")) != -1) while ((opt = getopt(_argc, _argv, "f:")) != -1)
{ {
if ( opt == 'f' ) if (opt == 'f')
{ {
string config = string(optarg); string config = string(optarg);
size_t pos = 0; size_t pos = 0;
if ( (pos = config.find_last_of("/")) == string::npos ) if ((pos = config.find_last_of("/")) == string::npos)
{ {
_configFile = optarg; _configFile = optarg;
} }
else else
{ {
_configFile = config.substr(pos + 1, config.size() - pos - 1);; _configFile = config.substr(pos + 1, config.size() - pos - 1);
_configDir = config.substr(0, pos + 1); ;
} _configDir = config.substr(0, pos + 1);
} }
} }
_rbsem = new NamedSemaphore(MQTTSNGW_RB_SEMAPHOR_NAME, 0); }
_rb = new RingBuffer(_configDir.c_str()); _rbsem = new NamedSemaphore(MQTTSNGW_RB_SEMAPHOR_NAME, 0);
_rb = new RingBuffer(_configDir.c_str());
if (getParam("ShearedMemory", param) == 0) if (getParam("ShearedMemory", param) == 0)
{ {
if (!strcasecmp(param, "YES")) if (!strcasecmp(param, "YES"))
{ {
_log = 1; _log = 1;
} }
else else
{ {
_log = 0; _log = 0;
} }
} }
} }
void Process::putLog(const char* format, ...) void Process::putLog(const char* format, ...)
{ {
_mt.lock(); _mt.lock();
va_list arg; va_list arg;
va_start(arg, format); va_start(arg, format);
vsprintf(_rbdata, format, arg); vsprintf(_rbdata, format, arg);
va_end(arg); va_end(arg);
if (strlen(_rbdata)) if (strlen(_rbdata))
{ {
if ( _log > 0 ) if (_log > 0)
{ {
_rb->put(_rbdata); _rb->put(_rbdata);
_rbsem->post(); _rbsem->post();
} }
else else
{ {
printf("%s", _rbdata); printf("%s", _rbdata);
} }
} }
_mt.unlock(); _mt.unlock();
} }
int Process::getArgc() int Process::getArgc()
{ {
return _argc; return _argc;
} }
char** Process::getArgv() char** Process::getArgv()
{ {
return _argv; return _argv;
} }
int Process::getParam(const char* parameter, char* value) int Process::getParam(const char* parameter, char* value)
{ {
char str[MQTTSNGW_PARAM_MAX]; char str[MQTTSNGW_PARAM_MAX];
char param[MQTTSNGW_PARAM_MAX]; char param[MQTTSNGW_PARAM_MAX];
FILE *fp; FILE *fp;
int i = 0, j = 0; int i = 0, j = 0;
string configPath = _configDir + _configFile; string configPath = _configDir + _configFile;
if ((fp = fopen(configPath.c_str(), "r")) == NULL) if ((fp = fopen(configPath.c_str(), "r")) == NULL)
{ {
throw Exception("No config file:[" + configPath + "]\n"); throw Exception("No config file:[" + configPath + "]\n");
} }
while (true) while (true)
{ {
if (fgets(str, MQTTSNGW_PARAM_MAX - 1, fp) == NULL) if (fgets(str, MQTTSNGW_PARAM_MAX - 1, fp) == NULL)
{ {
fclose(fp); fclose(fp);
return -3; return -3;
} }
if (!strncmp(str, parameter, strlen(parameter))) if (!strncmp(str, parameter, strlen(parameter)))
{ {
while (str[i++] != '=') while (str[i++] != '=')
{ {
; ;
} }
while (str[i] != '\n') while (str[i] != '\n')
{ {
param[j++] = str[i++]; param[j++] = str[i++];
} }
param[j] = '\0'; param[j] = '\0';
for (i = strlen(param) - 1; i >= 0 && isspace(param[i]); i--) for (i = strlen(param) - 1; i >= 0 && isspace(param[i]); i--)
; ;
param[i + 1] = '\0'; param[i + 1] = '\0';
for (i = 0; isspace(param[i]); i++) for (i = 0; isspace(param[i]); i++)
; ;
if (i > 0) if (i > 0)
{ {
j = 0; j = 0;
while (param[i]) while (param[i])
param[j++] = param[i++]; param[j++] = param[i++];
param[j] = '\0'; param[j] = '\0';
} }
strcpy(value, param); strcpy(value, param);
fclose(fp); fclose(fp);
return 0; return 0;
} }
} }
fclose(fp); fclose(fp);
return -2; return -2;
} }
const char* Process::getLog() const char* Process::getLog()
{ {
int len = 0; int len = 0;
_mt.lock(); _mt.lock();
while ((len = _rb->get(_rbdata, PROCESS_LOG_BUFFER_SIZE)) == 0) while ((len = _rb->get(_rbdata, PROCESS_LOG_BUFFER_SIZE)) == 0)
{ {
_rbsem->timedwait(1000); _rbsem->timedwait(1000);
if ( checkSignal() == SIGINT) if (checkSignal() == SIGINT)
{ {
break; break;
} }
} }
*(_rbdata + len) = 0; *(_rbdata + len) = 0;
_mt.unlock(); _mt.unlock();
return _rbdata; return _rbdata;
} }
void Process::resetRingBuffer() void Process::resetRingBuffer()
{ {
_rb->reset(); _rb->reset();
} }
int Process::checkSignal(void) int Process::checkSignal(void)
{ {
return theSignaled; return theSignaled;
} }
const string* Process::getConfigDirName(void) const string* Process::getConfigDirName(void)
{ {
return &_configDir; return &_configDir;
} }
const string* Process::getConfigFileName(void) const string* Process::getConfigFileName(void)
{ {
return &_configFile; return &_configFile;
} }
/*===================================== /*=====================================
@@ -247,99 +248,97 @@ const string* Process::getConfigFileName(void)
====================================*/ ====================================*/
MultiTaskProcess::MultiTaskProcess() MultiTaskProcess::MultiTaskProcess()
{ {
theMultiTaskProcess = this; theMultiTaskProcess = this;
_threadCount = 0; _threadCount = 0;
_stopCount = 0; _stopCount = 0;
} }
MultiTaskProcess::~MultiTaskProcess() MultiTaskProcess::~MultiTaskProcess()
{ {
for (int i = 0; i < _threadCount; i++) for (int i = 0; i < _threadCount; i++)
{ {
_threadList[i]->stop(); _threadList[i]->stop();
} }
} }
void MultiTaskProcess::initialize(int argc, char** argv) void MultiTaskProcess::initialize(int argc, char** argv)
{ {
Process::initialize(argc, argv); Process::initialize(argc, argv);
for (int i = 0; i < _threadCount; i++) for (int i = 0; i < _threadCount; i++)
{ {
_threadList[i]->initialize(argc, argv); _threadList[i]->initialize(argc, argv);
} }
} }
void MultiTaskProcess::run(void) void MultiTaskProcess::run(void)
{ {
for (int i = 0; i < _threadCount; i++) for (int i = 0; i < _threadCount; i++)
{ {
_threadList[i]->start(); _threadList[i]->start();
} }
try try
{ {
while(true) while (true)
{ {
if (theProcess->checkSignal() == SIGINT) if (theProcess->checkSignal() == SIGINT)
{ {
return; return;
} }
sleep(1); sleep(1);
} }
} } catch (Exception* ex)
catch(Exception* ex) {
{ ex->writeMessage();
ex->writeMessage(); } catch (...)
} {
catch(...) throw;
{ }
throw;
}
} }
void MultiTaskProcess::waitStop(void) void MultiTaskProcess::waitStop(void)
{ {
while (_stopCount < _threadCount) while (_stopCount < _threadCount)
{ {
sleep(1); sleep(1);
} }
} }
void MultiTaskProcess::threadStopped(void) void MultiTaskProcess::threadStopped(void)
{ {
_mutex.lock(); _mutex.lock();
_stopCount++; _stopCount++;
_mutex.unlock(); _mutex.unlock();
} }
void MultiTaskProcess::attach(Thread* thread) void MultiTaskProcess::attach(Thread* thread)
{ {
_mutex.lock(); _mutex.lock();
if (_threadCount < MQTTSNGW_MAX_TASK) if (_threadCount < MQTTSNGW_MAX_TASK)
{ {
_threadList[_threadCount] = thread; _threadList[_threadCount] = thread;
_threadCount++; _threadCount++;
} }
else else
{ {
_mutex.unlock(); _mutex.unlock();
throw Exception("Full of Threads"); throw Exception("Full of Threads");
} }
_mutex.unlock(); _mutex.unlock();
} }
int MultiTaskProcess::getParam(const char* parameter, char* value) int MultiTaskProcess::getParam(const char* parameter, char* value)
{ {
_mutex.lock(); _mutex.lock();
int rc = Process::getParam(parameter, value); int rc = Process::getParam(parameter, value);
_mutex.unlock(); _mutex.unlock();
if (rc == -1) if (rc == -1)
{ {
throw Exception("No config file."); throw Exception("No config file.");
} }
return rc; return rc;
} }
/*===================================== /*=====================================
@@ -347,30 +346,30 @@ int MultiTaskProcess::getParam(const char* parameter, char* value)
======================================*/ ======================================*/
Exception::Exception(const string& message) Exception::Exception(const string& message)
{ {
_message = message; _message = message;
_exNo = 0; _exNo = 0;
_fileName = 0; _fileName = 0;
_functionName = 0; _functionName = 0;
_line = 0; _line = 0;
} }
Exception::Exception(const int exNo, const string& message) Exception::Exception(const int exNo, const string& message)
{ {
_message = message; _message = message;
_exNo = exNo; _exNo = exNo;
_fileName = nullptr; _fileName = nullptr;
_functionName = nullptr; _functionName = nullptr;
_line = 0; _line = 0;
} }
Exception::Exception(const int exNo, const string& message, const char* file, Exception::Exception(const int exNo, const string& message, const char* file,
const char* function, const int line) const char* function, const int line)
{ {
_message = message; _message = message;
_exNo = exNo; _exNo = exNo;
_fileName = file; _fileName = file;
_functionName = function; _functionName = function;
_line = line; _line = line;
} }
Exception::~Exception() throw () Exception::~Exception() throw ()
@@ -380,38 +379,39 @@ Exception::~Exception() throw ()
const char* Exception::what() const throw () const char* Exception::what() const throw ()
{ {
return _message.c_str(); return _message.c_str();
} }
const char* Exception::getFileName() const char* Exception::getFileName()
{ {
return _fileName; return _fileName;
} }
const char* Exception::getFunctionName() const char* Exception::getFunctionName()
{ {
return _functionName; return _functionName;
} }
const int Exception::getLineNo() const int Exception::getLineNo()
{ {
return _line; return _line;
} }
const int Exception::getExceptionNo() const int Exception::getExceptionNo()
{ {
return _exNo; return _exNo;
} }
void Exception::writeMessage() void Exception::writeMessage()
{ {
if (getExceptionNo() == 0 ) if (getExceptionNo() == 0)
{ {
WRITELOG("%s %s\n", currentDateTime(), what()); WRITELOG("%s %s\n", currentDateTime(), what());
} }
else else
{ {
WRITELOG("%s:%-6d %s line %-4d %s() : %s\n", currentDateTime(), getExceptionNo(), WRITELOG("%s:%-6d %s line %-4d %s() : %s\n", currentDateTime(),
getFileName(), getLineNo(), getFunctionName(), what()); getExceptionNo(), getFileName(), getLineNo(), getFunctionName(),
} what());
}
} }

1647
MQTTSNGateway/src/MQTTSNGWProcess.h
View File

File diff suppressed because it is too large Load Diff

451
MQTTSNGateway/src/MQTTSNGWPublishHandler.cpp
View File

@@ -27,7 +27,7 @@ using namespace MQTTSNGW;
MQTTSNPublishHandler::MQTTSNPublishHandler(Gateway* gateway) MQTTSNPublishHandler::MQTTSNPublishHandler(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTSNPublishHandler::~MQTTSNPublishHandler() MQTTSNPublishHandler::~MQTTSNPublishHandler()
@@ -35,265 +35,280 @@ MQTTSNPublishHandler::~MQTTSNPublishHandler()
} }
MQTTGWPacket* MQTTSNPublishHandler::handlePublish(Client* client, MQTTSNPacket* packet) MQTTGWPacket* MQTTSNPublishHandler::handlePublish(Client* client,
MQTTSNPacket* packet)
{ {
uint8_t dup; uint8_t dup;
int qos; int qos;
uint8_t retained; uint8_t retained;
uint16_t msgId; uint16_t msgId;
uint8_t* payload; uint8_t* payload;
MQTTSN_topicid topicid; MQTTSN_topicid topicid;
int payloadlen; int payloadlen;
Publish pub = MQTTPacket_Publish_Initializer; Publish pub = MQTTPacket_Publish_Initializer;
char shortTopic[2]; char shortTopic[2];
if ( !_gateway->getAdapterManager()->getQoSm1Proxy()->isActive() ) if (!_gateway->getAdapterManager()->getQoSm1Proxy()->isActive())
{ {
if ( client->isQoSm1() ) if (client->isQoSm1())
{ {
_gateway->getAdapterManager()->getQoSm1Proxy()->savePacket(client, packet); _gateway->getAdapterManager()->getQoSm1Proxy()->savePacket(client,
packet);
return nullptr; return nullptr;
} }
} }
if ( packet->getPUBLISH(&dup, &qos, &retained, &msgId, &topicid, &payload, &payloadlen) ==0 ) if (packet->getPUBLISH(&dup, &qos, &retained, &msgId, &topicid, &payload,
{ &payloadlen) == 0)
return nullptr; {
} return nullptr;
pub.msgId = msgId; }
pub.header.bits.dup = dup; pub.msgId = msgId;
pub.header.bits.qos = ( qos == 3 ? 0 : qos ); pub.header.bits.dup = dup;
pub.header.bits.retain = retained; pub.header.bits.qos = (qos == 3 ? 0 : qos);
pub.header.bits.retain = retained;
Topic* topic = nullptr; Topic* topic = nullptr;
if( topicid.type == MQTTSN_TOPIC_TYPE_SHORT ) if (topicid.type == MQTTSN_TOPIC_TYPE_SHORT)
{ {
shortTopic[0] = topicid.data.short_name[0]; shortTopic[0] = topicid.data.short_name[0];
shortTopic[1] = topicid.data.short_name[1]; shortTopic[1] = topicid.data.short_name[1];
pub.topic = shortTopic; pub.topic = shortTopic;
pub.topiclen = 2; pub.topiclen = 2;
} }
else else
{ {
topic = client->getTopics()->getTopicById(&topicid); topic = client->getTopics()->getTopicById(&topicid);
if ( !topic ) if (!topic)
{ {
topic = _gateway->getTopics()->getTopicById(&topicid); topic = _gateway->getTopics()->getTopicById(&topicid);
if ( topic ) if (topic)
{ {
topic = client->getTopics()->add(topic->getTopicName()->c_str(), topic->getTopicId()); topic = client->getTopics()->add(topic->getTopicName()->c_str(),
} topic->getTopicId());
} }
}
if( !topic && qos == 3 ) if (!topic && qos == 3)
{ {
WRITELOG("%s Invalid TopicId.%s %s\n", ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER); WRITELOG("%s Invalid TopicId.%s %s\n", ERRMSG_HEADER,
return nullptr; client->getClientId(), ERRMSG_FOOTER);
} return nullptr;
}
if ( ( qos == 0 || qos == 3 ) && msgId > 0 ) if ((qos == 0 || qos == 3) && msgId > 0)
{ {
WRITELOG("%s Invalid MsgId.%s %s\n", ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER); WRITELOG("%s Invalid MsgId.%s %s\n", ERRMSG_HEADER,
return nullptr; client->getClientId(), ERRMSG_FOOTER);
} return nullptr;
}
if( !topic && msgId && qos > 0 && qos < 3 ) if (!topic && msgId && qos > 0 && qos < 3)
{ {
/* Reply PubAck with INVALID_TOPIC_ID to the client */ /* Reply PubAck with INVALID_TOPIC_ID to the client */
MQTTSNPacket* pubAck = new MQTTSNPacket(); MQTTSNPacket* pubAck = new MQTTSNPacket();
pubAck->setPUBACK( topicid.data.id, msgId, MQTTSN_RC_REJECTED_INVALID_TOPIC_ID); pubAck->setPUBACK(topicid.data.id, msgId,
Event* ev1 = new Event(); MQTTSN_RC_REJECTED_INVALID_TOPIC_ID);
ev1->setClientSendEvent(client, pubAck); Event* ev1 = new Event();
_gateway->getClientSendQue()->post(ev1); ev1->setClientSendEvent(client, pubAck);
return nullptr; _gateway->getClientSendQue()->post(ev1);
} return nullptr;
if ( topic ) }
{ if (topic)
pub.topic = (char*)topic->getTopicName()->data(); {
pub.topiclen = topic->getTopicName()->length(); pub.topic = (char*) topic->getTopicName()->data();
} pub.topiclen = topic->getTopicName()->length();
} }
/* Save a msgId & a TopicId pare for PUBACK */ }
if( msgId && qos > 0 && qos < 3) /* Save a msgId & a TopicId pare for PUBACK */
{ if (msgId && qos > 0 && qos < 3)
client->setWaitedPubTopicId(msgId, topicid.data.id, topicid.type); {
} client->setWaitedPubTopicId(msgId, topicid.data.id, topicid.type);
}
pub.payload = (char*)payload; pub.payload = (char*) payload;
pub.payloadlen = payloadlen; pub.payloadlen = payloadlen;
MQTTGWPacket* publish = new MQTTGWPacket(); MQTTGWPacket* publish = new MQTTGWPacket();
publish->setPUBLISH(&pub); publish->setPUBLISH(&pub);
if ( _gateway->getAdapterManager()->isAggregaterActive() && client->isAggregated() ) if (_gateway->getAdapterManager()->isAggregaterActive()
{ && client->isAggregated())
return publish; {
} return publish;
else }
{ else
Event* ev1 = new Event(); {
ev1->setBrokerSendEvent(client, publish); Event* ev1 = new Event();
_gateway->getBrokerSendQue()->post(ev1); ev1->setBrokerSendEvent(client, publish);
return nullptr; _gateway->getBrokerSendQue()->post(ev1);
} return nullptr;
}
} }
void MQTTSNPublishHandler::handlePuback(Client* client, MQTTSNPacket* packet) void MQTTSNPublishHandler::handlePuback(Client* client, MQTTSNPacket* packet)
{ {
uint16_t topicId; uint16_t topicId;
uint16_t msgId;
uint8_t rc;
if ( client->isActive() )
{
if ( packet->getPUBACK(&topicId, &msgId, &rc) == 0 )
{
return;
}
if ( rc == MQTTSN_RC_ACCEPTED)
{
if ( !_gateway->getAdapterManager()->getAggregater()->isActive() )
{
MQTTGWPacket* pubAck = new MQTTGWPacket();
pubAck->setAck(PUBACK, msgId);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, pubAck);
_gateway->getBrokerSendQue()->post(ev1);
}
}
else if ( rc == MQTTSN_RC_REJECTED_INVALID_TOPIC_ID)
{
WRITELOG(" PUBACK %d : Invalid Topic ID\n", msgId);
}
}
}
void MQTTSNPublishHandler::handleAck(Client* client, MQTTSNPacket* packet, uint8_t packetType)
{
uint16_t msgId;
if ( client->isActive() )
{
if ( packet->getACK(&msgId) == 0 )
{
return;
}
MQTTGWPacket* ackPacket = new MQTTGWPacket();
ackPacket->setAck(packetType, msgId);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, ackPacket);
_gateway->getBrokerSendQue()->post(ev1);
}
}
void MQTTSNPublishHandler::handleRegister(Client* client, MQTTSNPacket* packet)
{
uint16_t id;
uint16_t msgId;
MQTTSNString topicName = MQTTSNString_initializer;;
MQTTSN_topicid topicid;
if ( client->isActive() || client->isAwake())
{
if ( packet->getREGISTER(&id, &msgId, &topicName) == 0 )
{
return;
}
topicid.type = MQTTSN_TOPIC_TYPE_NORMAL;
topicid.data.long_.len = topicName.lenstring.len;
topicid.data.long_.name = topicName.lenstring.data;
id = client->getTopics()->add(&topicid)->getTopicId();
MQTTSNPacket* regAck = new MQTTSNPacket();
regAck->setREGACK(id, msgId, MQTTSN_RC_ACCEPTED);
Event* ev = new Event();
ev->setClientSendEvent(client, regAck);
_gateway->getClientSendQue()->post(ev);
}
}
void MQTTSNPublishHandler::handleRegAck( Client* client, MQTTSNPacket* packet)
{
uint16_t id;
uint16_t msgId; uint16_t msgId;
uint8_t rc; uint8_t rc;
if ( client->isActive() || client->isAwake())
if (client->isActive())
{ {
if ( packet->getREGACK(&id, &msgId, &rc) == 0 ) if (packet->getPUBACK(&topicId, &msgId, &rc) == 0)
{ {
return; return;
} }
MQTTSNPacket* regAck = client->getWaitREGACKPacketList()->getPacket(msgId); if (rc == MQTTSN_RC_ACCEPTED)
{
if (!_gateway->getAdapterManager()->getAggregater()->isActive())
{
MQTTGWPacket* pubAck = new MQTTGWPacket();
pubAck->setAck(PUBACK, msgId);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, pubAck);
_gateway->getBrokerSendQue()->post(ev1);
}
}
else if (rc == MQTTSN_RC_REJECTED_INVALID_TOPIC_ID)
{
WRITELOG(" PUBACK %d : Invalid Topic ID\n", msgId);
}
}
}
if ( regAck != nullptr ) void MQTTSNPublishHandler::handleAck(Client* client, MQTTSNPacket* packet,
uint8_t packetType)
{
uint16_t msgId;
if (client->isActive())
{
if (packet->getACK(&msgId) == 0)
{
return;
}
MQTTGWPacket* ackPacket = new MQTTGWPacket();
ackPacket->setAck(packetType, msgId);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, ackPacket);
_gateway->getBrokerSendQue()->post(ev1);
}
}
void MQTTSNPublishHandler::handleRegister(Client* client, MQTTSNPacket* packet)
{
uint16_t id;
uint16_t msgId;
MQTTSNString topicName = MQTTSNString_initializer;
;
MQTTSN_topicid topicid;
if (client->isActive() || client->isAwake())
{
if (packet->getREGISTER(&id, &msgId, &topicName) == 0)
{
return;
}
topicid.type = MQTTSN_TOPIC_TYPE_NORMAL;
topicid.data.long_.len = topicName.lenstring.len;
topicid.data.long_.name = topicName.lenstring.data;
id = client->getTopics()->add(&topicid)->getTopicId();
MQTTSNPacket* regAck = new MQTTSNPacket();
regAck->setREGACK(id, msgId, MQTTSN_RC_ACCEPTED);
Event* ev = new Event();
ev->setClientSendEvent(client, regAck);
_gateway->getClientSendQue()->post(ev);
}
}
void MQTTSNPublishHandler::handleRegAck(Client* client, MQTTSNPacket* packet)
{
uint16_t id;
uint16_t msgId;
uint8_t rc;
if (client->isActive() || client->isAwake())
{
if (packet->getREGACK(&id, &msgId, &rc) == 0)
{
return;
}
MQTTSNPacket* regAck = client->getWaitREGACKPacketList()->getPacket(
msgId);
if (regAck != nullptr)
{ {
client->getWaitREGACKPacketList()->erase(msgId); client->getWaitREGACKPacketList()->erase(msgId);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientSendEvent(client, regAck); ev->setClientSendEvent(client, regAck);
_gateway->getClientSendQue()->post(ev); _gateway->getClientSendQue()->post(ev);
} }
if (client->isHoldPingReqest() && client->getWaitREGACKPacketList()->getCount() == 0 ) if (client->isHoldPingReqest()
&& client->getWaitREGACKPacketList()->getCount() == 0)
{ {
/* send PINGREQ to the broker */ /* send PINGREQ to the broker */
client->resetPingRequest(); client->resetPingRequest();
MQTTGWPacket* pingreq = new MQTTGWPacket(); MQTTGWPacket* pingreq = new MQTTGWPacket();
pingreq->setHeader(PINGREQ); pingreq->setHeader(PINGREQ);
Event* evt = new Event(); Event* evt = new Event();
evt->setBrokerSendEvent(client, pingreq); evt->setBrokerSendEvent(client, pingreq);
_gateway->getBrokerSendQue()->post(evt); _gateway->getBrokerSendQue()->post(evt);
} }
} }
} }
void MQTTSNPublishHandler::handleAggregatePublish(Client* client,
MQTTSNPacket* packet)
void MQTTSNPublishHandler::handleAggregatePublish(Client* client, MQTTSNPacket* packet)
{ {
int msgId = 0; int msgId = 0;
MQTTGWPacket* publish = handlePublish(client, packet); MQTTGWPacket* publish = handlePublish(client, packet);
if ( publish != nullptr ) if (publish != nullptr)
{ {
if ( publish->getMsgId() > 0 ) if (publish->getMsgId() > 0)
{ {
if ( packet->isDuplicate() ) if (packet->isDuplicate())
{ {
msgId = _gateway->getAdapterManager()->getAggregater()->getMsgId(client, packet->getMsgId()); msgId =
} _gateway->getAdapterManager()->getAggregater()->getMsgId(
else client, packet->getMsgId());
{ }
msgId = _gateway->getAdapterManager()->getAggregater()->addMessageIdTable(client, packet->getMsgId()); else
} {
publish->setMsgId(msgId); msgId =
} _gateway->getAdapterManager()->getAggregater()->addMessageIdTable(
Event* ev1 = new Event(); client, packet->getMsgId());
ev1->setBrokerSendEvent(client, publish); }
_gateway->getBrokerSendQue()->post(ev1); publish->setMsgId(msgId);
} }
Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, publish);
_gateway->getBrokerSendQue()->post(ev1);
}
} }
void MQTTSNPublishHandler::handleAggregateAck(Client* client, MQTTSNPacket* packet, int type) void MQTTSNPublishHandler::handleAggregateAck(Client* client,
MQTTSNPacket* packet, int type)
{ {
if ( type == MQTTSN_PUBREC ) if (type == MQTTSN_PUBREC)
{ {
uint16_t msgId; uint16_t msgId;
if ( packet->getACK(&msgId) == 0 ) if (packet->getACK(&msgId) == 0)
{ {
return; return;
} }
MQTTSNPacket* ackPacket = new MQTTSNPacket(); MQTTSNPacket* ackPacket = new MQTTSNPacket();
ackPacket->setPUBREL(msgId); ackPacket->setPUBREL(msgId);
Event* ev = new Event(); Event* ev = new Event();
ev->setClientSendEvent(client, ackPacket); ev->setClientSendEvent(client, ackPacket);
_gateway->getClientSendQue()->post(ev); _gateway->getClientSendQue()->post(ev);
} }
} }

20
MQTTSNGateway/src/MQTTSNGWPublishHandler.h
View File

@@ -25,19 +25,19 @@ namespace MQTTSNGW
class MQTTSNPublishHandler class MQTTSNPublishHandler
{ {
public: public:
MQTTSNPublishHandler(Gateway* gateway); MQTTSNPublishHandler(Gateway* gateway);
~MQTTSNPublishHandler(); ~MQTTSNPublishHandler();
MQTTGWPacket* handlePublish(Client* client, MQTTSNPacket* packet); MQTTGWPacket* handlePublish(Client* client, MQTTSNPacket* packet);
void handlePuback(Client* client, MQTTSNPacket* packet); void handlePuback(Client* client, MQTTSNPacket* packet);
void handleAck(Client* client, MQTTSNPacket* packet, uint8_t packetType); void handleAck(Client* client, MQTTSNPacket* packet, uint8_t packetType);
void handleRegister(Client* client, MQTTSNPacket* packet); void handleRegister(Client* client, MQTTSNPacket* packet);
void handleRegAck( Client* client, MQTTSNPacket* packet); void handleRegAck(Client* client, MQTTSNPacket* packet);
void handleAggregatePublish(Client* client, MQTTSNPacket* packet); void handleAggregatePublish(Client* client, MQTTSNPacket* packet);
void handleAggregateAck(Client* client, MQTTSNPacket* packet, int type); void handleAggregateAck(Client* client, MQTTSNPacket* packet, int type);
private: private:
Gateway* _gateway; Gateway* _gateway;
}; };
} }

24
MQTTSNGateway/src/MQTTSNGWQoSm1Proxy.cpp
View File

@@ -21,13 +21,13 @@
#include <string> #include <string>
#include <string.h> #include <string.h>
using namespace MQTTSNGW; using namespace MQTTSNGW;
/*===================================== /*=====================================
Class QoSm1Proxy Class QoSm1Proxy
=====================================*/ =====================================*/
QoSm1Proxy:: QoSm1Proxy(Gateway* gw) : Adapter(gw) QoSm1Proxy::QoSm1Proxy(Gateway* gw) :
Adapter(gw)
{ {
_gateway = gw; _gateway = gw;
} }
@@ -37,24 +37,22 @@ QoSm1Proxy::~QoSm1Proxy(void)
} }
void QoSm1Proxy::initialize(char* gwName) void QoSm1Proxy::initialize(char* gwName)
{ {
if ( _gateway->hasSecureConnection() ) if (_gateway->hasSecureConnection())
{ {
_isSecure = true; _isSecure = true;
} }
/* Create QoS-1 Clients from clients.conf */ /* Create QoS-1 Clients from clients.conf */
_gateway->getClientList()->setClientList(QOSM1PROXY_TYPE); _gateway->getClientList()->setClientList(QOSM1PROXY_TYPE);
/* Create a client for QoS-1 proxy */ /* Create a client for QoS-1 proxy */
string name = string(gwName) + string("_QoS-1"); string name = string(gwName) + string("_QoS-1");
setup(name.c_str(), Atype_QoSm1Proxy); setup(name.c_str(), Atype_QoSm1Proxy);
_isActive = true; _isActive = true;
} }
bool QoSm1Proxy::isActive(void) bool QoSm1Proxy::isActive(void)
{ {
return _isActive; return _isActive;

13
MQTTSNGateway/src/MQTTSNGWQoSm1Proxy.h
View File

@@ -27,12 +27,12 @@ class SensorNetAddress;
class MQTTSNPacket; class MQTTSNPacket;
/*===================================== /*=====================================
Class QoSm1Proxy Class QoSm1Proxy
=====================================*/ =====================================*/
class QoSm1Proxy : public Adapter class QoSm1Proxy: public Adapter
{ {
public: public:
QoSm1Proxy(Gateway* gw); QoSm1Proxy(Gateway* gw);
~QoSm1Proxy(void); ~QoSm1Proxy(void);
void initialize(char* GWnAME); void initialize(char* GWnAME);
@@ -41,13 +41,10 @@ public:
private: private:
Gateway* _gateway; Gateway* _gateway;
bool _isActive {false}; bool _isActive { false };
bool _isSecure {false}; bool _isSecure { false };
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWQOSM1PROXY_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWQOSM1PROXY_H_ */

284
MQTTSNGateway/src/MQTTSNGWSubscribeHandler.cpp
View File

@@ -26,7 +26,7 @@ using namespace MQTTSNGW;
MQTTSNSubscribeHandler::MQTTSNSubscribeHandler(Gateway* gateway) MQTTSNSubscribeHandler::MQTTSNSubscribeHandler(Gateway* gateway)
{ {
_gateway = gateway; _gateway = gateway;
} }
MQTTSNSubscribeHandler::~MQTTSNSubscribeHandler() MQTTSNSubscribeHandler::~MQTTSNSubscribeHandler()
@@ -34,65 +34,70 @@ MQTTSNSubscribeHandler::~MQTTSNSubscribeHandler()
} }
MQTTGWPacket* MQTTSNSubscribeHandler::handleSubscribe(Client* client, MQTTSNPacket* packet) MQTTGWPacket* MQTTSNSubscribeHandler::handleSubscribe(Client* client,
MQTTSNPacket* packet)
{ {
uint8_t dup; uint8_t dup;
int qos; int qos;
uint16_t msgId; uint16_t msgId;
MQTTSN_topicid topicFilter; MQTTSN_topicid topicFilter;
Topic* topic = nullptr; Topic* topic = nullptr;
uint16_t topicId = 0; uint16_t topicId = 0;
MQTTGWPacket* subscribe; MQTTGWPacket* subscribe;
Event* ev1; Event* ev1;
Event* evsuback; Event* evsuback;
if ( packet->getSUBSCRIBE(&dup, &qos, &msgId, &topicFilter) == 0 ) if (packet->getSUBSCRIBE(&dup, &qos, &msgId, &topicFilter) == 0)
{ {
return nullptr; return nullptr;
} }
if ( msgId == 0 ) if (msgId == 0)
{ {
return nullptr; return nullptr;
} }
if ( topicFilter.type == MQTTSN_TOPIC_TYPE_PREDEFINED ) if (topicFilter.type == MQTTSN_TOPIC_TYPE_PREDEFINED)
{ {
topic = client->getTopics()->getTopicById(&topicFilter); topic = client->getTopics()->getTopicById(&topicFilter);
if ( !topic ) if (!topic)
{ {
topic = _gateway->getTopics()->getTopicById(&topicFilter); topic = _gateway->getTopics()->getTopicById(&topicFilter);
if ( topic ) if (topic)
{ {
topic = client->getTopics()->add(topic->getTopicName()->c_str(), topic->getTopicId()); topic = client->getTopics()->add(topic->getTopicName()->c_str(),
} topic->getTopicId());
else }
{ else
goto RespExit; {
} goto RespExit;
}
} }
topicId = topic->getTopicId(); topicId = topic->getTopicId();
subscribe = new MQTTGWPacket(); subscribe = new MQTTGWPacket();
subscribe->setSUBSCRIBE((char*)topic->getTopicName()->c_str(), (uint8_t)qos, (uint16_t)msgId); subscribe->setSUBSCRIBE((char*) topic->getTopicName()->c_str(),
(uint8_t) qos, (uint16_t) msgId);
} }
else if (topicFilter.type == MQTTSN_TOPIC_TYPE_NORMAL) else if (topicFilter.type == MQTTSN_TOPIC_TYPE_NORMAL)
{ {
topic = client->getTopics()->getTopicByName(&topicFilter); topic = client->getTopics()->getTopicByName(&topicFilter);
if ( topic == nullptr ) if (topic == nullptr)
{ {
topic = client->getTopics()->add(&topicFilter); topic = client->getTopics()->add(&topicFilter);
if ( topic == nullptr ) if (topic == nullptr)
{ {
WRITELOG("%s Client(%s) can't add the Topic.%s\n", ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER); WRITELOG("%s Client(%s) can't add the Topic.%s\n",
ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER);
return nullptr; return nullptr;
} }
} }
topicId = topic->getTopicId(); topicId = topic->getTopicId();
subscribe = new MQTTGWPacket(); subscribe = new MQTTGWPacket();
subscribe->setSUBSCRIBE((char*)topic->getTopicName()->c_str(), (uint8_t)qos, (uint16_t)msgId); subscribe->setSUBSCRIBE((char*) topic->getTopicName()->c_str(),
(uint8_t) qos, (uint16_t) msgId);
} }
else //MQTTSN_TOPIC_TYPE_SHORT else //MQTTSN_TOPIC_TYPE_SHORT
{ {
@@ -103,73 +108,72 @@ MQTTGWPacket* MQTTSNSubscribeHandler::handleSubscribe(Client* client, MQTTSNPack
topicId = topicFilter.data.short_name[0] << 8; topicId = topicFilter.data.short_name[0] << 8;
topicId |= topicFilter.data.short_name[1]; topicId |= topicFilter.data.short_name[1];
subscribe = new MQTTGWPacket(); subscribe = new MQTTGWPacket();
subscribe->setSUBSCRIBE(topicstr, (uint8_t)qos, (uint16_t)msgId); subscribe->setSUBSCRIBE(topicstr, (uint8_t) qos, (uint16_t) msgId);
} }
client->setWaitedSubTopicId(msgId, topicId, topicFilter.type); client->setWaitedSubTopicId(msgId, topicId, topicFilter.type);
if ( !client->isAggregated() ) if (!client->isAggregated())
{ {
ev1 = new Event(); ev1 = new Event();
ev1->setBrokerSendEvent(client, subscribe); ev1->setBrokerSendEvent(client, subscribe);
_gateway->getBrokerSendQue()->post(ev1); _gateway->getBrokerSendQue()->post(ev1);
return nullptr; return nullptr;
} }
else else
{ {
return subscribe; return subscribe;
} }
RespExit: MQTTSNPacket* sSuback = new MQTTSNPacket();
RespExit: sSuback->setSUBACK(qos, topicFilter.data.id, msgId,
MQTTSNPacket* sSuback = new MQTTSNPacket(); MQTTSN_RC_NOT_SUPPORTED);
sSuback->setSUBACK(qos, topicFilter.data.id, msgId, MQTTSN_RC_NOT_SUPPORTED); evsuback = new Event();
evsuback = new Event(); evsuback->setClientSendEvent(client, sSuback);
evsuback->setClientSendEvent(client, sSuback); _gateway->getClientSendQue()->post(evsuback);
_gateway->getClientSendQue()->post(evsuback); return nullptr;
return nullptr;
} }
MQTTGWPacket* MQTTSNSubscribeHandler::handleUnsubscribe(Client* client, MQTTSNPacket* packet) MQTTGWPacket* MQTTSNSubscribeHandler::handleUnsubscribe(Client* client,
MQTTSNPacket* packet)
{ {
uint16_t msgId; uint16_t msgId;
MQTTSN_topicid topicFilter; MQTTSN_topicid topicFilter;
MQTTGWPacket* unsubscribe = nullptr; MQTTGWPacket* unsubscribe = nullptr;
if ( packet->getUNSUBSCRIBE(&msgId, &topicFilter) == 0 ) if (packet->getUNSUBSCRIBE(&msgId, &topicFilter) == 0)
{
return nullptr;
}
if ( msgId == 0 )
{ {
return nullptr; return nullptr;
} }
if (msgId == 0)
{
return nullptr;
}
if (topicFilter.type == MQTTSN_TOPIC_TYPE_SHORT) if (topicFilter.type == MQTTSN_TOPIC_TYPE_SHORT)
{ {
char shortTopic[3]; char shortTopic[3];
shortTopic[0] = topicFilter.data.short_name[0]; shortTopic[0] = topicFilter.data.short_name[0];
shortTopic[1] = topicFilter.data.short_name[1]; shortTopic[1] = topicFilter.data.short_name[1];
shortTopic[2] = 0; shortTopic[2] = 0;
unsubscribe = new MQTTGWPacket(); unsubscribe = new MQTTGWPacket();
unsubscribe->setUNSUBSCRIBE(shortTopic, msgId); unsubscribe->setUNSUBSCRIBE(shortTopic, msgId);
} }
else else
{ {
Topic* topic = nullptr; Topic* topic = nullptr;
if (topicFilter.type == MQTTSN_TOPIC_TYPE_PREDEFINED) if (topicFilter.type == MQTTSN_TOPIC_TYPE_PREDEFINED)
{ {
topic = client->getTopics()->getTopicById(&topicFilter); topic = client->getTopics()->getTopicById(&topicFilter);
} }
else else
{ {
topic = client->getTopics()->getTopicByName(&topicFilter); topic = client->getTopics()->getTopicByName(&topicFilter);
} }
if ( topic == nullptr ) if (topic == nullptr)
{ {
MQTTSNPacket* sUnsuback = new MQTTSNPacket(); MQTTSNPacket* sUnsuback = new MQTTSNPacket();
sUnsuback->setUNSUBACK(msgId); sUnsuback->setUNSUBACK(msgId);
@@ -183,85 +187,99 @@ MQTTGWPacket* MQTTSNSubscribeHandler::handleUnsubscribe(Client* client, MQTTSNPa
unsubscribe = new MQTTGWPacket(); unsubscribe = new MQTTGWPacket();
unsubscribe->setUNSUBSCRIBE(topic->getTopicName()->c_str(), msgId); unsubscribe->setUNSUBSCRIBE(topic->getTopicName()->c_str(), msgId);
} }
} }
if ( !client->isAggregated() ) if (!client->isAggregated())
{ {
Event* ev1 = new Event(); Event* ev1 = new Event();
ev1->setBrokerSendEvent(client, unsubscribe); ev1->setBrokerSendEvent(client, unsubscribe);
_gateway->getBrokerSendQue()->post(ev1); _gateway->getBrokerSendQue()->post(ev1);
return nullptr; return nullptr;
} }
else else
{ {
return unsubscribe; return unsubscribe;
} }
} }
void MQTTSNSubscribeHandler::handleAggregateSubscribe(Client* client, MQTTSNPacket* packet) void MQTTSNSubscribeHandler::handleAggregateSubscribe(Client* client,
MQTTSNPacket* packet)
{ {
MQTTGWPacket* subscribe = handleSubscribe(client, packet); MQTTGWPacket* subscribe = handleSubscribe(client, packet);
if ( subscribe != nullptr ) if (subscribe != nullptr)
{ {
int msgId = 0; int msgId = 0;
if ( packet->isDuplicate() ) if (packet->isDuplicate())
{ {
msgId = _gateway->getAdapterManager()->getAggregater()->getMsgId(client, packet->getMsgId()); msgId = _gateway->getAdapterManager()->getAggregater()->getMsgId(
} client, packet->getMsgId());
else }
{ else
msgId = _gateway->getAdapterManager()->getAggregater()->addMessageIdTable(client, packet->getMsgId()); {
} msgId =
_gateway->getAdapterManager()->getAggregater()->addMessageIdTable(
client, packet->getMsgId());
}
if ( msgId == 0 ) if (msgId == 0)
{ {
WRITELOG("%s MQTTSNSubscribeHandler can't create MessageIdTableElement %s%s\n", ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER); WRITELOG(
return; "%s MQTTSNSubscribeHandler can't create MessageIdTableElement %s%s\n",
} ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER);
return;
}
UTF8String str = subscribe->getTopic(); UTF8String str = subscribe->getTopic();
string* topicName = new string(str.data, str.len); // topicName is delete by topic string* topicName = new string(str.data, str.len); // topicName is delete by topic
Topic topic = Topic(topicName, MQTTSN_TOPIC_TYPE_NORMAL); Topic topic = Topic(topicName, MQTTSN_TOPIC_TYPE_NORMAL);
_gateway->getAdapterManager()->getAggregater()->addAggregateTopic(&topic, client); _gateway->getAdapterManager()->getAggregater()->addAggregateTopic(
&topic, client);
subscribe->setMsgId(msgId); subscribe->setMsgId(msgId);
Event* ev = new Event(); Event* ev = new Event();
ev->setBrokerSendEvent(client, subscribe); ev->setBrokerSendEvent(client, subscribe);
_gateway->getBrokerSendQue()->post(ev); _gateway->getBrokerSendQue()->post(ev);
} }
} }
void MQTTSNSubscribeHandler::handleAggregateUnsubscribe(Client* client, MQTTSNPacket* packet) void MQTTSNSubscribeHandler::handleAggregateUnsubscribe(Client* client,
MQTTSNPacket* packet)
{ {
MQTTGWPacket* unsubscribe = handleUnsubscribe(client, packet); MQTTGWPacket* unsubscribe = handleUnsubscribe(client, packet);
if ( unsubscribe != nullptr ) if (unsubscribe != nullptr)
{ {
int msgId = 0; int msgId = 0;
if ( packet->isDuplicate() ) if (packet->isDuplicate())
{ {
msgId = _gateway->getAdapterManager()->getAggregater()->getMsgId(client, packet->getMsgId()); msgId = _gateway->getAdapterManager()->getAggregater()->getMsgId(
} client, packet->getMsgId());
else }
{ else
msgId = _gateway->getAdapterManager()->getAggregater()->addMessageIdTable(client, packet->getMsgId()); {
} msgId =
_gateway->getAdapterManager()->getAggregater()->addMessageIdTable(
client, packet->getMsgId());
}
if ( msgId == 0 ) if (msgId == 0)
{ {
WRITELOG("%s MQTTSNUnsubscribeHandler can't create MessageIdTableElement %s%s\n", ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER); WRITELOG(
return; "%s MQTTSNUnsubscribeHandler can't create MessageIdTableElement %s%s\n",
} ERRMSG_HEADER, client->getClientId(), ERRMSG_FOOTER);
return;
}
UTF8String str = unsubscribe->getTopic(); UTF8String str = unsubscribe->getTopic();
string* topicName = new string(str.data, str.len); // topicName is delete by topic string* topicName = new string(str.data, str.len); // topicName is delete by topic
Topic topic = Topic(topicName, MQTTSN_TOPIC_TYPE_NORMAL); Topic topic = Topic(topicName, MQTTSN_TOPIC_TYPE_NORMAL);
_gateway->getAdapterManager()->getAggregater()->removeAggregateTopic(&topic, client); _gateway->getAdapterManager()->getAggregater()->removeAggregateTopic(
&topic, client);
unsubscribe->setMsgId(msgId); unsubscribe->setMsgId(msgId);
Event* ev = new Event(); Event* ev = new Event();
ev->setBrokerSendEvent(client, unsubscribe); ev->setBrokerSendEvent(client, unsubscribe);
_gateway->getBrokerSendQue()->post(ev); _gateway->getBrokerSendQue()->post(ev);
} }
} }

17
MQTTSNGateway/src/MQTTSNGWSubscribeHandler.h
View File

@@ -24,23 +24,22 @@
namespace MQTTSNGW namespace MQTTSNGW
{ {
/*===================================== /*=====================================
Class MQTTSNSubscribeHandler Class MQTTSNSubscribeHandler
=====================================*/ =====================================*/
class MQTTSNSubscribeHandler class MQTTSNSubscribeHandler
{ {
public: public:
MQTTSNSubscribeHandler(Gateway* gateway); MQTTSNSubscribeHandler(Gateway* gateway);
~MQTTSNSubscribeHandler(); ~MQTTSNSubscribeHandler();
MQTTGWPacket* handleSubscribe(Client* client, MQTTSNPacket* packet); MQTTGWPacket* handleSubscribe(Client* client, MQTTSNPacket* packet);
MQTTGWPacket* handleUnsubscribe(Client* client, MQTTSNPacket* packet); MQTTGWPacket* handleUnsubscribe(Client* client, MQTTSNPacket* packet);
void handleAggregateSubscribe(Client* client, MQTTSNPacket* packet); void handleAggregateSubscribe(Client* client, MQTTSNPacket* packet);
void handleAggregateUnsubscribe(Client* client, MQTTSNPacket* packet); void handleAggregateUnsubscribe(Client* client, MQTTSNPacket* packet);
private: private:
Gateway* _gateway; Gateway* _gateway;
}; };
} }
#endif /* MQTTSNGWSUBSCRIBEHANDLER_H_ */ #endif /* MQTTSNGWSUBSCRIBEHANDLER_H_ */

278
MQTTSNGateway/src/MQTTSNGWTopic.cpp
View File

@@ -27,35 +27,35 @@ using namespace MQTTSNGW;
Topic::Topic() Topic::Topic()
{ {
_type = MQTTSN_TOPIC_TYPE_NORMAL; _type = MQTTSN_TOPIC_TYPE_NORMAL;
_topicName = nullptr; _topicName = nullptr;
_topicId = 0; _topicId = 0;
_next = nullptr; _next = nullptr;
} }
Topic::Topic(string* topic, MQTTSN_topicTypes type) Topic::Topic(string* topic, MQTTSN_topicTypes type)
{ {
_type = type; _type = type;
_topicName = topic; _topicName = topic;
_topicId = 0; _topicId = 0;
_next = nullptr; _next = nullptr;
} }
Topic::~Topic() Topic::~Topic()
{ {
if ( _topicName ) if (_topicName)
{ {
delete _topicName; delete _topicName;
} }
} }
string* Topic::getTopicName(void) string* Topic::getTopicName(void)
{ {
return _topicName; return _topicName;
} }
uint16_t Topic::getTopicId(void) uint16_t Topic::getTopicId(void)
{ {
return _topicId; return _topicId;
} }
MQTTSN_topicTypes Topic::getType(void) MQTTSN_topicTypes Topic::getType(void)
@@ -65,108 +65,109 @@ MQTTSN_topicTypes Topic::getType(void)
Topic* Topic::duplicate(void) Topic* Topic::duplicate(void)
{ {
Topic* newTopic = new Topic(); Topic* newTopic = new Topic();
newTopic->_type = _type; newTopic->_type = _type;
newTopic->_topicId = _topicId; newTopic->_topicId = _topicId;
newTopic->_topicName = new string(_topicName->c_str()); newTopic->_topicName = new string(_topicName->c_str());
return newTopic; return newTopic;
} }
bool Topic::isMatch(string* topicName) bool Topic::isMatch(string* topicName)
{ {
string::size_type tlen = _topicName->size(); string::size_type tlen = _topicName->size();
string::size_type tpos = 0; string::size_type tpos = 0;
string::size_type tloc = 0; string::size_type tloc = 0;
string::size_type pos = 0; string::size_type pos = 0;
string::size_type loc = 0; string::size_type loc = 0;
string wildcard = "#"; string wildcard = "#";
string wildcards = "+"; string wildcards = "+";
while(true) while (true)
{ {
loc = topicName->find('/', pos); loc = topicName->find('/', pos);
tloc = _topicName->find('/', tpos); tloc = _topicName->find('/', tpos);
if ( loc != string::npos && tloc != string::npos ) if (loc != string::npos && tloc != string::npos)
{ {
string subtopic = topicName->substr(pos, loc - pos); string subtopic = topicName->substr(pos, loc - pos);
string subtopict = _topicName->substr(tpos, tloc - tpos); string subtopict = _topicName->substr(tpos, tloc - tpos);
if (subtopict == wildcard) if (subtopict == wildcard)
{ {
return true; return true;
} }
else if (subtopict == wildcards) else if (subtopict == wildcards)
{ {
if ( (tpos = tloc + 1 ) > tlen ) if ((tpos = tloc + 1) > tlen)
{ {
pos = loc + 1; pos = loc + 1;
loc = topicName->find('/', pos); loc = topicName->find('/', pos);
if ( loc == string::npos ) if (loc == string::npos)
{ {
return true; return true;
} }
else else
{ {
return false; return false;
} }
} }
pos = loc + 1; pos = loc + 1;
} }
else if ( subtopic != subtopict ) else if (subtopic != subtopict)
{ {
return false; return false;
} }
else else
{ {
if ( (tpos = tloc + 1) > tlen ) if ((tpos = tloc + 1) > tlen)
{ {
return false; return false;
} }
pos = loc + 1; pos = loc + 1;
} }
} }
else if ( loc == string::npos && tloc == string::npos ) else if (loc == string::npos && tloc == string::npos)
{ {
string subtopic = topicName->substr(pos); string subtopic = topicName->substr(pos);
string subtopict = _topicName->substr(tpos); string subtopict = _topicName->substr(tpos);
if ( subtopict == wildcard || subtopict == wildcards) if (subtopict == wildcard || subtopict == wildcards)
{ {
return true; return true;
} }
else if ( subtopic == subtopict ) else if (subtopic == subtopict)
{ {
return true; return true;
} }
else else
{ {
return false; return false;
} }
} }
else if ( loc == string::npos && tloc != string::npos ) else if (loc == string::npos && tloc != string::npos)
{ {
string subtopic = topicName->substr(pos); string subtopic = topicName->substr(pos);
string subtopict = _topicName->substr(tpos, tloc - tpos); string subtopict = _topicName->substr(tpos, tloc - tpos);
if ( subtopic != subtopict) if (subtopic != subtopict)
{ {
return false; return false;
} }
tpos = tloc + 1; tpos = tloc + 1;
return _topicName->substr(tpos) == wildcard; return _topicName->substr(tpos) == wildcard;
} }
else if ( loc != string::npos && tloc == string::npos ) else if (loc != string::npos && tloc == string::npos)
{ {
return _topicName->substr(tpos) == wildcard; return _topicName->substr(tpos) == wildcard;
} }
} }
} }
void Topic::print(void) void Topic::print(void)
{ {
WRITELOG("TopicName=%s ID=%d Type=%d\n", _topicName->c_str(), _topicId, _type); WRITELOG("TopicName=%s ID=%d Type=%d\n", _topicName->c_str(), _topicId,
_type);
} }
/*===================================== /*=====================================
@@ -198,11 +199,11 @@ Topic* Topics::getTopicByName(const MQTTSN_topicid* topicid)
string sname = string(ch, ch + topicid->data.long_.len); string sname = string(ch, ch + topicid->data.long_.len);
while (p) while (p)
{ {
if ( p->_topicName->compare(sname) == 0 ) if (p->_topicName->compare(sname) == 0)
{ {
return p; return p;
} }
p = p->_next; p = p->_next;
} }
return 0; return 0;
} }
@@ -213,7 +214,7 @@ Topic* Topics::getTopicById(const MQTTSN_topicid* topicid)
while (p) while (p)
{ {
if ( p->_type == topicid->type && p->_topicId == topicid->data.id ) if (p->_type == topicid->type && p->_topicId == topicid->data.id)
{ {
return p; return p;
} }
@@ -225,14 +226,14 @@ Topic* Topics::getTopicById(const MQTTSN_topicid* topicid)
// For MQTTSN_TOPIC_TYPE_NORMAL */ // For MQTTSN_TOPIC_TYPE_NORMAL */
Topic* Topics::add(const MQTTSN_topicid* topicid) Topic* Topics::add(const MQTTSN_topicid* topicid)
{ {
if (topicid->type != MQTTSN_TOPIC_TYPE_NORMAL ) if (topicid->type != MQTTSN_TOPIC_TYPE_NORMAL)
{ {
return 0; return 0;
} }
Topic* topic = getTopicByName(topicid); Topic* topic = getTopicByName(topicid);
if ( topic ) if (topic)
{ {
return topic; return topic;
} }
@@ -244,18 +245,17 @@ Topic* Topics::add(const char* topicName, uint16_t id)
{ {
MQTTSN_topicid topicId; MQTTSN_topicid topicId;
if ( _cnt >= MAX_TOPIC_PAR_CLIENT ) if (_cnt >= MAX_TOPIC_PAR_CLIENT)
{ {
return 0; return 0;
} }
topicId.data.long_.name = (char*)const_cast<char*>(topicName); topicId.data.long_.name = (char*) const_cast<char*>(topicName);
topicId.data.long_.len = strlen(topicName); topicId.data.long_.len = strlen(topicName);
Topic* topic = getTopicByName(&topicId); Topic* topic = getTopicByName(&topicId);
if ( topic ) if (topic)
{ {
return topic; return topic;
} }
@@ -270,7 +270,7 @@ Topic* Topics::add(const char* topicName, uint16_t id)
string* name = new string(topicName); string* name = new string(topicName);
topic->_topicName = name; topic->_topicName = name;
if ( id == 0 ) if (id == 0)
{ {
topic->_type = MQTTSN_TOPIC_TYPE_NORMAL; topic->_type = MQTTSN_TOPIC_TYPE_NORMAL;
topic->_topicId = getNextTopicId(); topic->_topicId = getNextTopicId();
@@ -278,12 +278,12 @@ Topic* Topics::add(const char* topicName, uint16_t id)
else else
{ {
topic->_type = MQTTSN_TOPIC_TYPE_PREDEFINED; topic->_type = MQTTSN_TOPIC_TYPE_PREDEFINED;
topic->_topicId = id; topic->_topicId = id;
} }
_cnt++; _cnt++;
if ( _first == nullptr) if (_first == nullptr)
{ {
_first = topic; _first = topic;
} }
@@ -331,7 +331,6 @@ Topic* Topics::match(const MQTTSN_topicid* topicid)
return 0; return 0;
} }
void Topics::eraseNormal(void) void Topics::eraseNormal(void)
{ {
Topic* topic = _first; Topic* topic = _first;
@@ -340,14 +339,14 @@ void Topics::eraseNormal(void)
while (topic) while (topic)
{ {
if ( topic->_type == MQTTSN_TOPIC_TYPE_NORMAL ) if (topic->_type == MQTTSN_TOPIC_TYPE_NORMAL)
{ {
next = topic->_next; next = topic->_next;
if ( _first == topic ) if (_first == topic)
{ {
_first = next; _first = next;
} }
if ( prev ) if (prev)
{ {
prev->_next = next; prev->_next = next;
} }
@@ -365,18 +364,18 @@ void Topics::eraseNormal(void)
Topic* Topics::getFirstTopic(void) Topic* Topics::getFirstTopic(void)
{ {
return _first; return _first;
} }
Topic* Topics::getNextTopic(Topic* topic) Topic* Topics::getNextTopic(Topic* topic)
{ {
return topic->_next; return topic->_next;
} }
void Topics::print(void) void Topics::print(void)
{ {
Topic* topic = _first; Topic* topic = _first;
if (topic == nullptr ) if (topic == nullptr)
{ {
WRITELOG("No Topic.\n"); WRITELOG("No Topic.\n");
} }
@@ -398,7 +397,8 @@ uint8_t Topics::getCount(void)
/*===================================== /*=====================================
Class TopicIdMap Class TopicIdMap
=====================================*/ =====================================*/
TopicIdMapElement::TopicIdMapElement(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type) TopicIdMapElement::TopicIdMapElement(uint16_t msgId, uint16_t topicId,
MQTTSN_topicTypes type)
{ {
_msgId = msgId; _msgId = msgId;
_topicId = topicId; _topicId = topicId;
@@ -419,7 +419,7 @@ MQTTSN_topicTypes TopicIdMapElement::getTopicType(void)
uint16_t TopicIdMapElement::getTopicId(void) uint16_t TopicIdMapElement::getTopicId(void)
{ {
return _topicId; return _topicId;
} }
TopicIdMap::TopicIdMap() TopicIdMap::TopicIdMap()
@@ -434,7 +434,7 @@ TopicIdMap::TopicIdMap()
TopicIdMap::~TopicIdMap() TopicIdMap::~TopicIdMap()
{ {
TopicIdMapElement* p = _first; TopicIdMapElement* p = _first;
while ( p ) while (p)
{ {
TopicIdMapElement* q = p->_next; TopicIdMapElement* q = p->_next;
delete p; delete p;
@@ -445,9 +445,9 @@ TopicIdMap::~TopicIdMap()
TopicIdMapElement* TopicIdMap::getElement(uint16_t msgId) TopicIdMapElement* TopicIdMap::getElement(uint16_t msgId)
{ {
TopicIdMapElement* p = _first; TopicIdMapElement* p = _first;
while ( p ) while (p)
{ {
if ( p->_msgId == msgId ) if (p->_msgId == msgId)
{ {
return p; return p;
} }
@@ -456,23 +456,25 @@ TopicIdMapElement* TopicIdMap::getElement(uint16_t msgId)
return 0; return 0;
} }
TopicIdMapElement* TopicIdMap::add(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type) TopicIdMapElement* TopicIdMap::add(uint16_t msgId, uint16_t topicId,
MQTTSN_topicTypes type)
{ {
if ( _cnt > _maxInflight * 2 || ( topicId == 0 && type != MQTTSN_TOPIC_TYPE_SHORT ) ) if (_cnt > _maxInflight * 2
|| (topicId == 0 && type != MQTTSN_TOPIC_TYPE_SHORT))
{ {
return 0; return 0;
} }
if ( getElement(msgId) ) if (getElement(msgId))
{ {
erase(msgId); erase(msgId);
} }
TopicIdMapElement* elm = new TopicIdMapElement(msgId, topicId, type); TopicIdMapElement* elm = new TopicIdMapElement(msgId, topicId, type);
if ( elm == 0 ) if (elm == 0)
{ {
return 0; return 0;
} }
if ( _first == nullptr ) if (_first == nullptr)
{ {
_first = elm; _first = elm;
_end = elm; _end = elm;
@@ -490,11 +492,11 @@ TopicIdMapElement* TopicIdMap::add(uint16_t msgId, uint16_t topicId, MQTTSN_topi
void TopicIdMap::erase(uint16_t msgId) void TopicIdMap::erase(uint16_t msgId)
{ {
TopicIdMapElement* p = _first; TopicIdMapElement* p = _first;
while ( p ) while (p)
{ {
if ( p->_msgId == msgId ) if (p->_msgId == msgId)
{ {
if ( p->_prev == nullptr ) if (p->_prev == nullptr)
{ {
_first = p->_next; _first = p->_next;
} }
@@ -503,7 +505,7 @@ void TopicIdMap::erase(uint16_t msgId)
p->_prev->_next = p->_next; p->_prev->_next = p->_next;
} }
if ( p->_next == nullptr ) if (p->_next == nullptr)
{ {
_end = p->_prev; _end = p->_prev;
} }
@@ -523,7 +525,7 @@ void TopicIdMap::erase(uint16_t msgId)
void TopicIdMap::clear(void) void TopicIdMap::clear(void)
{ {
TopicIdMapElement* p = _first; TopicIdMapElement* p = _first;
while ( p ) while (p)
{ {
TopicIdMapElement* q = p->_next; TopicIdMapElement* q = p->_next;
delete p; delete p;
@@ -534,5 +536,3 @@ void TopicIdMap::clear(void)
_cnt = 0; _cnt = 0;
} }

11
MQTTSNGateway/src/MQTTSNGWTopic.h
View File

@@ -24,7 +24,6 @@
namespace MQTTSNGW namespace MQTTSNGW
{ {
/*===================================== /*=====================================
Class Topic Class Topic
======================================*/ ======================================*/
@@ -46,7 +45,7 @@ public:
private: private:
MQTTSN_topicTypes _type; MQTTSN_topicTypes _type;
uint16_t _topicId; uint16_t _topicId;
string* _topicName; string* _topicName;
Topic* _next; Topic* _next;
}; };
@@ -72,7 +71,7 @@ public:
private: private:
uint16_t _nextTopicId; uint16_t _nextTopicId;
Topic* _first; Topic* _first;
uint8_t _cnt; uint8_t _cnt;
}; };
/*===================================== /*=====================================
@@ -101,7 +100,8 @@ public:
TopicIdMap(); TopicIdMap();
~TopicIdMap(); ~TopicIdMap();
TopicIdMapElement* getElement(uint16_t msgId); TopicIdMapElement* getElement(uint16_t msgId);
TopicIdMapElement* add(uint16_t msgId, uint16_t topicId, MQTTSN_topicTypes type); TopicIdMapElement* add(uint16_t msgId, uint16_t topicId,
MQTTSN_topicTypes type);
void erase(uint16_t msgId); void erase(uint16_t msgId);
void clear(void); void clear(void);
private: private:
@@ -112,9 +112,6 @@ private:
int _maxInflight; int _maxInflight;
}; };
} }
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWTOPIC_H_ */ #endif /* MQTTSNGATEWAY_SRC_MQTTSNGWTOPIC_H_ */

2
MQTTSNGateway/src/MQTTSNGWVersion.h
View File

@@ -17,6 +17,6 @@
#ifndef MQTTSNGWVERSION_H_IN_ #ifndef MQTTSNGWVERSION_H_IN_
#define MQTTSNGWVERSION_H_IN_ #define MQTTSNGWVERSION_H_IN_
#define PAHO_GATEWAY_VERSION "1.4.0" #define PAHO_GATEWAY_VERSION "1.5.0"
#endif /* MQTTSNGWVERSION_H_IN_ */ #endif /* MQTTSNGWVERSION_H_IN_ */

652
MQTTSNGateway/src/MQTTSNGateway.cpp
View File

@@ -43,77 +43,77 @@ Gateway::Gateway(void)
Gateway::~Gateway() Gateway::~Gateway()
{ {
if ( _params.loginId ) if (_params.loginId)
{ {
free(_params.loginId); free(_params.loginId);
} }
if ( _params.password ) if (_params.password)
{ {
free(_params.password); free(_params.password);
} }
if ( _params.gatewayName ) if (_params.gatewayName)
{ {
free(_params.gatewayName); free(_params.gatewayName);
} }
if ( _params.brokerName ) if (_params.brokerName)
{ {
free(_params.brokerName); free(_params.brokerName);
} }
if ( _params.port ) if (_params.port)
{ {
free(_params.port); free(_params.port);
} }
if ( _params.portSecure ) if (_params.portSecure)
{ {
free(_params.portSecure); free(_params.portSecure);
} }
if ( _params.certKey ) if (_params.certKey)
{ {
free(_params.certKey); free(_params.certKey);
} }
if ( _params.privateKey ) if (_params.privateKey)
{ {
free(_params.privateKey); free(_params.privateKey);
} }
if ( _params.rootCApath ) if (_params.rootCApath)
{ {
free(_params.rootCApath); free(_params.rootCApath);
} }
if ( _params.rootCAfile ) if (_params.rootCAfile)
{ {
free(_params.rootCAfile); free(_params.rootCAfile);
} }
if ( _params.clientListName ) if (_params.clientListName)
{ {
free(_params.clientListName); free(_params.clientListName);
} }
if ( _params.predefinedTopicFileName ) if (_params.predefinedTopicFileName)
{ {
free( _params.predefinedTopicFileName); free(_params.predefinedTopicFileName);
} }
if ( _params.configName ) if (_params.configName)
{ {
free(_params.configName); free(_params.configName);
} }
if ( _params.qosMinusClientListName ) if (_params.qosMinusClientListName)
{ {
free(_params.qosMinusClientListName); free(_params.qosMinusClientListName);
} }
if ( _adapterManager ) if (_adapterManager)
{ {
delete _adapterManager; delete _adapterManager;
} }
if ( _clientList ) if (_clientList)
{ {
delete _clientList; delete _clientList;
} }
if ( _topics ) if (_topics)
{ {
delete _topics; delete _topics;
} }
// WRITELOG("Gateway is deleted normally.\r\n"); // WRITELOG("Gateway is deleted normally.\r\n");
} }
@@ -124,256 +124,258 @@ int Gateway::getParam(const char* parameter, char* value)
char* Gateway::getClientListFileName(void) char* Gateway::getClientListFileName(void)
{ {
return _params.clientListName; return _params.clientListName;
} }
char* Gateway::getPredefinedTopicFileName(void) char* Gateway::getPredefinedTopicFileName(void)
{ {
return _params.predefinedTopicFileName; return _params.predefinedTopicFileName;
} }
void Gateway::initialize(int argc, char** argv) void Gateway::initialize(int argc, char** argv)
{ {
char param[MQTTSNGW_PARAM_MAX]; char param[MQTTSNGW_PARAM_MAX];
string fileName; string fileName;
theGateway = this; theGateway = this;
MultiTaskProcess::initialize(argc, argv); MultiTaskProcess::initialize(argc, argv);
resetRingBuffer(); resetRingBuffer();
_params.configDir = *getConfigDirName(); _params.configDir = *getConfigDirName();
fileName = _params.configDir + *getConfigFileName(); fileName = _params.configDir + *getConfigFileName();
_params.configName = strdup(fileName.c_str()); _params.configName = strdup(fileName.c_str());
if (getParam("BrokerName", param) == 0) if (getParam("BrokerName", param) == 0)
{ {
_params.brokerName = strdup(param); _params.brokerName = strdup(param);
} }
if (getParam("BrokerPortNo", param) == 0) if (getParam("BrokerPortNo", param) == 0)
{ {
_params.port = strdup(param); _params.port = strdup(param);
} }
if (getParam("BrokerSecurePortNo", param) == 0) if (getParam("BrokerSecurePortNo", param) == 0)
{ {
_params.portSecure = strdup(param); _params.portSecure = strdup(param);
} }
if (getParam("CertKey", param) == 0) if (getParam("CertKey", param) == 0)
{ {
_params.certKey = strdup(param); _params.certKey = strdup(param);
} }
if (getParam("PrivateKey", param) == 0) if (getParam("PrivateKey", param) == 0)
{ {
_params.privateKey = strdup(param); _params.privateKey = strdup(param);
} }
if (getParam("RootCApath", param) == 0) if (getParam("RootCApath", param) == 0)
{ {
_params.rootCApath = strdup(param); _params.rootCApath = strdup(param);
} }
if (getParam("RootCAfile", param) == 0) if (getParam("RootCAfile", param) == 0)
{ {
_params.rootCAfile = strdup(param); _params.rootCAfile = strdup(param);
} }
if (getParam("GatewayID", param) == 0) if (getParam("GatewayID", param) == 0)
{ {
_params.gatewayId = atoi(param); _params.gatewayId = atoi(param);
} }
if (_params.gatewayId == 0 || _params.gatewayId > 255) if (_params.gatewayId == 0 || _params.gatewayId > 255)
{ {
throw Exception( "Gateway::initialize: invalid Gateway Id"); throw Exception("Gateway::initialize: invalid Gateway Id");
} }
if (getParam("GatewayName", param) == 0) if (getParam("GatewayName", param) == 0)
{ {
_params.gatewayName = strdup(param); _params.gatewayName = strdup(param);
} }
if (_params.gatewayName == 0 ) if (_params.gatewayName == 0)
{ {
throw Exception( "Gateway::initialize: Gateway Name is missing."); throw Exception("Gateway::initialize: Gateway Name is missing.");
} }
_params.mqttVersion = DEFAULT_MQTT_VERSION; _params.mqttVersion = DEFAULT_MQTT_VERSION;
if (getParam("MQTTVersion", param) == 0) if (getParam("MQTTVersion", param) == 0)
{ {
_params.mqttVersion = atoi(param); _params.mqttVersion = atoi(param);
} }
_params.maxInflightMsgs = DEFAULT_MQTT_VERSION; _params.maxInflightMsgs = DEFAULT_MQTT_VERSION;
if (getParam("MaxInflightMsgs", param) == 0) if (getParam("MaxInflightMsgs", param) == 0)
{ {
_params.maxInflightMsgs = atoi(param); _params.maxInflightMsgs = atoi(param);
} }
_params.keepAlive = DEFAULT_KEEP_ALIVE_TIME; _params.keepAlive = DEFAULT_KEEP_ALIVE_TIME;
if (getParam("KeepAlive", param) == 0) if (getParam("KeepAlive", param) == 0)
{ {
_params.keepAlive = atoi(param); _params.keepAlive = atoi(param);
} }
if (getParam("LoginID", param) == 0) if (getParam("LoginID", param) == 0)
{ {
_params.loginId = strdup(param); _params.loginId = strdup(param);
} }
if (getParam("Password", param) == 0) if (getParam("Password", param) == 0)
{ {
_params.password = strdup(param); _params.password = strdup(param);
} }
if (getParam("ClientAuthentication", param) == 0) if (getParam("ClientAuthentication", param) == 0)
{ {
if (!strcasecmp(param, "YES")) if (!strcasecmp(param, "YES"))
{ {
_params.clientAuthentication = true; _params.clientAuthentication = true;
} }
} }
if (getParam("ClientsList", param) == 0) if (getParam("ClientsList", param) == 0)
{ {
_params.clientListName = strdup(param); _params.clientListName = strdup(param);
} }
if (getParam("PredefinedTopic", param) == 0) if (getParam("PredefinedTopic", param) == 0)
{ {
if ( !strcasecmp(param, "YES") ) if (!strcasecmp(param, "YES"))
{ {
_params.predefinedTopic = true; _params.predefinedTopic = true;
if (getParam("PredefinedTopicList", param) == 0) if (getParam("PredefinedTopicList", param) == 0)
{ {
_params.predefinedTopicFileName = strdup(param); _params.predefinedTopicFileName = strdup(param);
} }
} }
} }
if (getParam("AggregatingGateway", param) == 0) if (getParam("AggregatingGateway", param) == 0)
{ {
if ( !strcasecmp(param, "YES") ) if (!strcasecmp(param, "YES"))
{ {
_params.aggregatingGw = true; _params.aggregatingGw = true;
} }
} }
if (getParam("Forwarder", param) == 0) if (getParam("Forwarder", param) == 0)
{ {
if ( !strcasecmp(param, "YES") ) if (!strcasecmp(param, "YES"))
{ {
_params.forwarder = true; _params.forwarder = true;
} }
} }
if (getParam("QoS-1", param) == 0) if (getParam("QoS-1", param) == 0)
{ {
if ( !strcasecmp(param, "YES") ) if (!strcasecmp(param, "YES"))
{ {
_params.qosMinus1 = true; _params.qosMinus1 = true;
} }
} }
/* Initialize adapters */
_adapterManager->initialize(_params.gatewayName, _params.aggregatingGw,
_params.forwarder, _params.qosMinus1);
/* Initialize adapters */ /* Setup ClientList and Predefined topics */
_adapterManager->initialize( _params.gatewayName, _params.aggregatingGw, _params.forwarder, _params.qosMinus1); _clientList->initialize(_params.aggregatingGw);
/* Setup ClientList and Predefined topics */
_clientList->initialize(_params.aggregatingGw);
} }
void Gateway::run(void) void Gateway::run(void)
{ {
/* write prompts */ /* write prompts */
_lightIndicator.redLight(true); _lightIndicator.redLight(true);
WRITELOG("\n%s", PAHO_COPYRIGHT4); WRITELOG("\n%s", PAHO_COPYRIGHT4);
WRITELOG("\n%s\n", PAHO_COPYRIGHT0); WRITELOG("\n%s\n", PAHO_COPYRIGHT0);
WRITELOG("%s\n", PAHO_COPYRIGHT1); WRITELOG("%s\n", PAHO_COPYRIGHT1);
WRITELOG("%s\n", PAHO_COPYRIGHT2); WRITELOG("%s\n", PAHO_COPYRIGHT2);
WRITELOG(" *\n%s\n", PAHO_COPYRIGHT3); WRITELOG(" *\n%s\n", PAHO_COPYRIGHT3);
WRITELOG(" * Version: %s\n", PAHO_GATEWAY_VERSION); WRITELOG(" * Version: %s\n", PAHO_GATEWAY_VERSION);
WRITELOG("%s\n", PAHO_COPYRIGHT4); WRITELOG("%s\n", PAHO_COPYRIGHT4);
WRITELOG("\n%s %s has been started.\n\n", currentDateTime(), _params.gatewayName); WRITELOG("\n%s %s has been started.\n\n", currentDateTime(),
WRITELOG(" ConfigFile: %s\n", _params.configName); _params.gatewayName);
WRITELOG(" ConfigFile: %s\n", _params.configName);
if ( _params.clientListName ) if (_params.clientListName)
{ {
WRITELOG(" ClientList: %s\n", _params.clientListName); WRITELOG(" ClientList: %s\n", _params.clientListName);
} }
if ( _params.predefinedTopicFileName ) if (_params.predefinedTopicFileName)
{ {
WRITELOG(" PreDefFile: %s\n", _params.predefinedTopicFileName); WRITELOG(" PreDefFile: %s\n", _params.predefinedTopicFileName);
} }
WRITELOG(" SensorN/W: %s\n", _sensorNetwork.getDescription()); WRITELOG(" SensorN/W: %s\n", _sensorNetwork.getDescription());
WRITELOG(" Broker: %s : %s, %s\n", _params.brokerName, _params.port, _params.portSecure); WRITELOG(" Broker: %s : %s, %s\n", _params.brokerName, _params.port,
WRITELOG(" RootCApath: %s\n", _params.rootCApath); _params.portSecure);
WRITELOG(" RootCAfile: %s\n", _params.rootCAfile); WRITELOG(" RootCApath: %s\n", _params.rootCApath);
WRITELOG(" CertKey: %s\n", _params.certKey); WRITELOG(" RootCAfile: %s\n", _params.rootCAfile);
WRITELOG(" PrivateKey: %s\n\n\n", _params.privateKey); WRITELOG(" CertKey: %s\n", _params.certKey);
WRITELOG(" PrivateKey: %s\n\n\n", _params.privateKey);
_stopFlg = false; _stopFlg = false;
/* Run Tasks until CTRL+C entred */ /* Run Tasks until CTRL+C entred */
MultiTaskProcess::run(); MultiTaskProcess::run();
_stopFlg = true; _stopFlg = true;
/* stop Tasks */ /* stop Tasks */
Event* ev = new Event(); Event* ev = new Event();
ev->setStop(); ev->setStop();
_packetEventQue.post(ev); _packetEventQue.post(ev);
ev = new Event(); ev = new Event();
ev->setStop(); ev->setStop();
_brokerSendQue.post(ev); _brokerSendQue.post(ev);
ev = new Event(); ev = new Event();
ev->setStop(); ev->setStop();
_clientSendQue.post(ev); _clientSendQue.post(ev);
/* wait until all Task stop */ /* wait until all Task stop */
MultiTaskProcess::waitStop(); MultiTaskProcess::waitStop();
WRITELOG("\n\n%s MQTT-SN Gateway stopped.\n\n", currentDateTime()); WRITELOG("\n\n%s MQTT-SN Gateway stopped.\n\n", currentDateTime());
_lightIndicator.allLightOff(); _lightIndicator.allLightOff();
} }
bool Gateway::IsStopping(void) bool Gateway::IsStopping(void)
{ {
return _stopFlg; return _stopFlg;
} }
EventQue* Gateway::getPacketEventQue() EventQue* Gateway::getPacketEventQue()
{ {
return &_packetEventQue; return &_packetEventQue;
} }
EventQue* Gateway::getClientSendQue() EventQue* Gateway::getClientSendQue()
{ {
return &_clientSendQue; return &_clientSendQue;
} }
EventQue* Gateway::getBrokerSendQue() EventQue* Gateway::getBrokerSendQue()
{ {
return &_brokerSendQue; return &_brokerSendQue;
} }
ClientList* Gateway::getClientList() ClientList* Gateway::getClientList()
{ {
return _clientList; return _clientList;
} }
SensorNetwork* Gateway::getSensorNetwork() SensorNetwork* Gateway::getSensorNetwork()
{ {
return &_sensorNetwork; return &_sensorNetwork;
} }
LightIndicator* Gateway::getLightIndicator() LightIndicator* Gateway::getLightIndicator()
{ {
return &_lightIndicator; return &_lightIndicator;
} }
GatewayParams* Gateway::getGWParams(void) GatewayParams* Gateway::getGWParams(void)
{ {
return &_params; return &_params;
} }
AdapterManager* Gateway::getAdapterManager(void) AdapterManager* Gateway::getAdapterManager(void)
@@ -388,10 +390,8 @@ Topics* Gateway::getTopics(void)
bool Gateway::hasSecureConnection(void) bool Gateway::hasSecureConnection(void)
{ {
return ( _params.certKey return (_params.certKey && _params.privateKey && _params.rootCApath
&& _params.privateKey && _params.rootCAfile);
&& _params.rootCApath
&& _params.rootCAfile );
} }
/*===================================== /*=====================================
Class EventQue Class EventQue
@@ -403,87 +403,86 @@ EventQue::EventQue()
EventQue::~EventQue() EventQue::~EventQue()
{ {
_mutex.lock(); _mutex.lock();
while (_que.size() > 0) while (_que.size() > 0)
{ {
delete _que.front(); delete _que.front();
_que.pop(); _que.pop();
} }
_mutex.unlock(); _mutex.unlock();
} }
void EventQue::setMaxSize(uint16_t maxSize) void EventQue::setMaxSize(uint16_t maxSize)
{ {
_que.setMaxSize((int)maxSize); _que.setMaxSize((int) maxSize);
} }
Event* EventQue::wait(void) Event* EventQue::wait(void)
{ {
Event* ev = nullptr; Event* ev = nullptr;
while(ev == nullptr) while (ev == nullptr)
{ {
if ( _que.size() == 0 ) if (_que.size() == 0)
{ {
_sem.wait(); _sem.wait();
} }
_mutex.lock(); _mutex.lock();
ev = _que.front(); ev = _que.front();
_que.pop(); _que.pop();
_mutex.unlock(); _mutex.unlock();
} }
return ev; return ev;
} }
Event* EventQue::timedwait(uint16_t millsec) Event* EventQue::timedwait(uint16_t millsec)
{ {
Event* ev; Event* ev;
if ( _que.size() == 0 ) if (_que.size() == 0)
{ {
_sem.timedwait(millsec); _sem.timedwait(millsec);
} }
_mutex.lock(); _mutex.lock();
if (_que.size() == 0) if (_que.size() == 0)
{ {
ev = new Event(); ev = new Event();
ev->setTimeout(); ev->setTimeout();
} }
else else
{ {
ev = _que.front(); ev = _que.front();
_que.pop(); _que.pop();
} }
_mutex.unlock(); _mutex.unlock();
return ev; return ev;
} }
void EventQue::post(Event* ev) void EventQue::post(Event* ev)
{ {
if ( ev ) if (ev)
{ {
_mutex.lock(); _mutex.lock();
if ( _que.post(ev) ) if (_que.post(ev))
{ {
_sem.post(); _sem.post();
} }
else else
{ {
delete ev; delete ev;
} }
_mutex.unlock(); _mutex.unlock();
} }
} }
int EventQue::size() int EventQue::size()
{ {
_mutex.lock(); _mutex.lock();
int sz = _que.size(); int sz = _que.size();
_mutex.unlock(); _mutex.unlock();
return sz; return sz;
} }
/*===================================== /*=====================================
Class Event Class Event
=====================================*/ =====================================*/
@@ -494,96 +493,95 @@ Event::Event()
Event::~Event() Event::~Event()
{ {
if (_sensorNetAddr) if (_sensorNetAddr)
{ {
delete _sensorNetAddr; delete _sensorNetAddr;
} }
if (_mqttSNPacket) if (_mqttSNPacket)
{ {
delete _mqttSNPacket; delete _mqttSNPacket;
} }
if (_mqttGWPacket) if (_mqttGWPacket)
{ {
delete _mqttGWPacket; delete _mqttGWPacket;
} }
} }
EventType Event::getEventType() EventType Event::getEventType()
{ {
return _eventType; return _eventType;
} }
void Event::setClientSendEvent(Client* client, MQTTSNPacket* packet) void Event::setClientSendEvent(Client* client, MQTTSNPacket* packet)
{ {
_client = client; _client = client;
_eventType = EtClientSend; _eventType = EtClientSend;
_mqttSNPacket = packet; _mqttSNPacket = packet;
} }
void Event::setBrokerSendEvent(Client* client, MQTTGWPacket* packet) void Event::setBrokerSendEvent(Client* client, MQTTGWPacket* packet)
{ {
_client = client; _client = client;
_eventType = EtBrokerSend; _eventType = EtBrokerSend;
_mqttGWPacket = packet; _mqttGWPacket = packet;
} }
void Event::setClientRecvEvent(Client* client, MQTTSNPacket* packet) void Event::setClientRecvEvent(Client* client, MQTTSNPacket* packet)
{ {
_client = client; _client = client;
_eventType = EtClientRecv; _eventType = EtClientRecv;
_mqttSNPacket = packet; _mqttSNPacket = packet;
} }
void Event::setBrokerRecvEvent(Client* client, MQTTGWPacket* packet) void Event::setBrokerRecvEvent(Client* client, MQTTGWPacket* packet)
{ {
_client = client; _client = client;
_eventType = EtBrokerRecv; _eventType = EtBrokerRecv;
_mqttGWPacket = packet; _mqttGWPacket = packet;
} }
void Event::setTimeout(void) void Event::setTimeout(void)
{ {
_eventType = EtTimeout; _eventType = EtTimeout;
} }
void Event::setStop(void) void Event::setStop(void)
{ {
_eventType = EtStop; _eventType = EtStop;
} }
void Event::setBrodcastEvent(MQTTSNPacket* msg) void Event::setBrodcastEvent(MQTTSNPacket* msg)
{ {
_mqttSNPacket = msg; _mqttSNPacket = msg;
_eventType = EtBroadcast; _eventType = EtBroadcast;
} }
void Event::setClientSendEvent(SensorNetAddress* addr, MQTTSNPacket* msg) void Event::setClientSendEvent(SensorNetAddress* addr, MQTTSNPacket* msg)
{ {
_eventType = EtSensornetSend; _eventType = EtSensornetSend;
_sensorNetAddr = addr; _sensorNetAddr = addr;
_mqttSNPacket = msg; _mqttSNPacket = msg;
} }
Client* Event::getClient(void) Client* Event::getClient(void)
{ {
return _client; return _client;
} }
SensorNetAddress* Event::getSensorNetAddress(void) SensorNetAddress* Event::getSensorNetAddress(void)
{ {
return _sensorNetAddr; return _sensorNetAddr;
} }
MQTTSNPacket* Event::getMQTTSNPacket() MQTTSNPacket* Event::getMQTTSNPacket()
{ {
return _mqttSNPacket; return _mqttSNPacket;
} }
MQTTGWPacket* Event::getMQTTGWPacket(void) MQTTGWPacket* Event::getMQTTGWPacket(void)
{ {
return _mqttGWPacket; return _mqttGWPacket;
} }

209
MQTTSNGateway/src/MQTTSNGateway.h
View File

@@ -46,8 +46,8 @@ namespace MQTTSNGW
#define LEFTARROW "<---" #define LEFTARROW "<---"
#define RIGHTARROW "--->" #define RIGHTARROW "--->"
#define LEFTARROWB "<===" #define LEFTARROWB "<==="
#define RIGHTARROWB "===>" #define RIGHTARROWB "===>"
#define FORMAT_Y_G_G_NL "\n%s \033[0m\033[0;33m%-18s\033[0m\033[0;32m%-6s%-34.32s \033[0m\033[0;34m%s\033[0m\033[0;37m\n" #define FORMAT_Y_G_G_NL "\n%s \033[0m\033[0;33m%-18s\033[0m\033[0;32m%-6s%-34.32s \033[0m\033[0;34m%s\033[0m\033[0;37m\n"
#define FORMAT_Y_G_G "%s \033[0m\033[0;33m%-18s\033[0m\033[0;32m%-6s%-34.32s \033[0m\033[0;34m%s\033[0m\033[0;37m\n" #define FORMAT_Y_G_G "%s \033[0m\033[0;33m%-18s\033[0m\033[0;32m%-6s%-34.32s \033[0m\033[0;34m%s\033[0m\033[0;37m\n"
@@ -68,150 +68,147 @@ namespace MQTTSNGW
#define FORMAT_BL_NL "\n%s \033[0m\033[0;34m%-18s%-6s%-34.32s %s\033[0m\033[0;37m\n" #define FORMAT_BL_NL "\n%s \033[0m\033[0;34m%-18s%-6s%-34.32s %s\033[0m\033[0;37m\n"
#define FORMAT_W_NL "\n%s %-18s%-6s%-34.32s %s\n" #define FORMAT_W_NL "\n%s %-18s%-6s%-34.32s %s\n"
#define ERRMSG_HEADER "\033[0m\033[0;31mError:" #define ERRMSG_HEADER "\033[0m\033[0;31mError:"
#define ERRMSG_FOOTER "\033[0m\033[0;37m" #define ERRMSG_FOOTER "\033[0m\033[0;37m"
/*===================================== /*=====================================
Class Event Class Event
====================================*/ ====================================*/
class Client; class Client;
enum EventType{ enum EventType
Et_NA = 0, {
EtStop, Et_NA = 0,
EtTimeout, EtStop,
EtBrokerRecv, EtTimeout,
EtBrokerSend, EtBrokerRecv,
EtClientRecv, EtBrokerSend,
EtClientSend, EtClientRecv,
EtBroadcast, EtClientSend,
EtSensornetSend EtBroadcast,
EtSensornetSend
}; };
class Event
class Event{ {
public: public:
Event(); Event();
~Event(); ~Event();
EventType getEventType(void); EventType getEventType(void);
void setClientRecvEvent(Client*, MQTTSNPacket*); void setClientRecvEvent(Client*, MQTTSNPacket*);
void setClientSendEvent(Client*, MQTTSNPacket*); void setClientSendEvent(Client*, MQTTSNPacket*);
void setBrokerRecvEvent(Client*, MQTTGWPacket*); void setBrokerRecvEvent(Client*, MQTTGWPacket*);
void setBrokerSendEvent(Client*, MQTTGWPacket*); void setBrokerSendEvent(Client*, MQTTGWPacket*);
void setBrodcastEvent(MQTTSNPacket*); // ADVERTISE and GWINFO void setBrodcastEvent(MQTTSNPacket*); // ADVERTISE and GWINFO
void setTimeout(void); // Required by EventQue<Event>.timedwait() void setTimeout(void); // Required by EventQue<Event>.timedwait()
void setStop(void); void setStop(void);
void setClientSendEvent(SensorNetAddress*, MQTTSNPacket*); void setClientSendEvent(SensorNetAddress*, MQTTSNPacket*);
Client* getClient(void); Client* getClient(void);
SensorNetAddress* getSensorNetAddress(void); SensorNetAddress* getSensorNetAddress(void);
MQTTSNPacket* getMQTTSNPacket(void); MQTTSNPacket* getMQTTSNPacket(void);
MQTTGWPacket* getMQTTGWPacket(void); MQTTGWPacket* getMQTTGWPacket(void);
private: private:
EventType _eventType {Et_NA}; EventType _eventType { Et_NA };
Client* _client {nullptr}; Client* _client { nullptr };
SensorNetAddress* _sensorNetAddr {nullptr}; SensorNetAddress* _sensorNetAddr { nullptr };
MQTTSNPacket* _mqttSNPacket {nullptr}; MQTTSNPacket* _mqttSNPacket { nullptr };
MQTTGWPacket* _mqttGWPacket {nullptr}; MQTTGWPacket* _mqttGWPacket { nullptr };
}; };
/*===================================== /*=====================================
Class EventQue Class EventQue
====================================*/ ====================================*/
class EventQue class EventQue
{ {
public: public:
EventQue(); EventQue();
~EventQue(); ~EventQue();
Event* wait(void); Event* wait(void);
Event* timedwait(uint16_t millsec); Event* timedwait(uint16_t millsec);
void setMaxSize(uint16_t maxSize); void setMaxSize(uint16_t maxSize);
void post(Event*); void post(Event*);
int size(); int size();
private: private:
Que<Event> _que; Que<Event> _que;
Mutex _mutex; Mutex _mutex;
Semaphore _sem; Semaphore _sem;
}; };
/*===================================== /*=====================================
Class GatewayParams Class GatewayParams
====================================*/ ====================================*/
class GatewayParams class GatewayParams
{ {
public: public:
string configDir; string configDir;
char* configName {nullptr}; char* configName { nullptr };
char* clientListName {nullptr}; char* clientListName { nullptr };
char* loginId {nullptr}; char* loginId { nullptr };
char* password {nullptr}; char* password { nullptr };
uint16_t keepAlive {0}; uint16_t keepAlive { 0 };
uint8_t gatewayId {0}; uint8_t gatewayId { 0 };
uint8_t mqttVersion {0}; uint8_t mqttVersion { 0 };
uint16_t maxInflightMsgs {0}; uint16_t maxInflightMsgs { 0 };
char* gatewayName {nullptr}; char* gatewayName { nullptr };
char* brokerName {nullptr}; char* brokerName { nullptr };
char* port {nullptr}; char* port { nullptr };
char* portSecure {nullptr}; char* portSecure{ nullptr };
char* rootCApath {nullptr}; char* rootCApath { nullptr };
char* rootCAfile {nullptr}; char* rootCAfile { nullptr };
char* certKey {nullptr}; char* certKey { nullptr };
char* predefinedTopicFileName {nullptr}; char* predefinedTopicFileName { nullptr };
char* privateKey {nullptr}; char* privateKey { nullptr };
char* qosMinusClientListName {nullptr}; char* qosMinusClientListName { nullptr };
bool clientAuthentication {false}; bool clientAuthentication { false };
bool predefinedTopic {false}; bool predefinedTopic { false };
bool aggregatingGw {false}; bool aggregatingGw { false };
bool qosMinus1 {false}; bool qosMinus1 { false };
bool forwarder {false}; bool forwarder { false };
}; };
/*===================================== /*=====================================
Class Gateway Class Gateway
=====================================*/ =====================================*/
class AdapterManager; class AdapterManager;
class ClientList; class ClientList;
class Gateway: public MultiTaskProcess{ class Gateway: public MultiTaskProcess
{
public: public:
Gateway(void); Gateway(void);
~Gateway(); ~Gateway();
virtual void initialize(int argc, char** argv); virtual void initialize(int argc, char** argv);
void run(void); void run(void);
EventQue* getPacketEventQue(void); EventQue* getPacketEventQue(void);
EventQue* getClientSendQue(void); EventQue* getClientSendQue(void);
EventQue* getBrokerSendQue(void); EventQue* getBrokerSendQue(void);
ClientList* getClientList(void); ClientList* getClientList(void);
SensorNetwork* getSensorNetwork(void); SensorNetwork* getSensorNetwork(void);
LightIndicator* getLightIndicator(void); LightIndicator* getLightIndicator(void);
GatewayParams* getGWParams(void); GatewayParams* getGWParams(void);
AdapterManager* getAdapterManager(void); AdapterManager* getAdapterManager(void);
int getParam(const char* parameter, char* value); int getParam(const char* parameter, char* value);
char* getClientListFileName(void); char* getClientListFileName(void);
char* getPredefinedTopicFileName(void); char* getPredefinedTopicFileName(void);
bool hasSecureConnection(void); bool hasSecureConnection(void);
Topics* getTopics(void); Topics* getTopics(void);
bool IsStopping(void); bool IsStopping(void);
private: private:
GatewayParams _params; GatewayParams _params;
ClientList* _clientList {nullptr}; ClientList* _clientList { nullptr };
EventQue _packetEventQue; EventQue _packetEventQue;
EventQue _brokerSendQue; EventQue _brokerSendQue;
EventQue _clientSendQue; EventQue _clientSendQue;
LightIndicator _lightIndicator; LightIndicator _lightIndicator;
SensorNetwork _sensorNetwork; SensorNetwork _sensorNetwork;
AdapterManager* _adapterManager {nullptr}; AdapterManager* _adapterManager { nullptr };
Topics* _topics; Topics* _topics;
bool _stopFlg; bool _stopFlg;
}; };
} }

25
MQTTSNGateway/src/mainGateway.cpp
View File

@@ -26,11 +26,11 @@ using namespace MQTTSNGW;
* Gateway Application * Gateway Application
*/ */
Gateway gateway; Gateway gateway;
PacketHandleTask task1(&gateway); PacketHandleTask task1(&gateway);
ClientRecvTask task2(&gateway); ClientRecvTask task2(&gateway);
ClientSendTask task3(&gateway); ClientSendTask task3(&gateway);
BrokerRecvTask task4(&gateway); BrokerRecvTask task4(&gateway);
BrokerSendTask task5(&gateway); BrokerSendTask task5(&gateway);
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
@@ -38,13 +38,12 @@ int main(int argc, char** argv)
gateway.run(); gateway.run();
try try
{ {
gateway.initialize(argc, argv); gateway.initialize(argc, argv);
gateway.run(); gateway.run();
} } catch (const std::exception &ex)
catch (const std::exception &ex)
{ {
WRITELOG("\nEclipse Paho MQTT-SN Gateway exception: %s\n", ex.what()); WRITELOG("\nEclipse Paho MQTT-SN Gateway exception: %s\n", ex.what());
WRITELOG("MQTT-SNGateway [-f Config file name]\n"); WRITELOG("MQTT-SNGateway [-f Config file name]\n");
} }
return 0; return 0;
} }

9
MQTTSNGateway/src/mainLogmonitor.cpp
View File

@@ -19,15 +19,14 @@
using namespace MQTTSNGW; using namespace MQTTSNGW;
/* /*
* Logmonitor process * Logmonitor process
*/ */
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Logmonitor monitor = Logmonitor(); Logmonitor monitor = Logmonitor();
monitor.initialize(argc, argv); monitor.initialize(argc, argv);
monitor.run(); monitor.run();
return 0; return 0;
} }