/*-------------------------------------------------------
Downstream MQTTPublish
-------------------------------------------------------*/
void GatewayControlTask::handlePublish(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTPublish* mqMsg = static_cast<MQTTPublish*>(msg);
MQTTSnPublish* snMsg = new MQTTSnPublish();
string* tp = mqMsg->getTopic();
uint16_t tpId;
if(tp->size() == 2){
tpId = getUint16((uint8_t*)tp);
snMsg->setFlags(MQTTSN_TOPIC_TYPE_SHORT);
}else{
tpId = clnode->getTopics()->getTopicId(tp);
snMsg->setFlags(MQTTSN_TOPIC_TYPE_NORMAL);
}
if(tpId == 0){
/* ----- may be a publish message response of subscribed with '#' or '+' -----*/
tpId = clnode->getTopics()->createTopic(tp);
if(tpId > 0){
MQTTSnRegister* regMsg = new MQTTSnRegister();
regMsg->setTopicId(tpId);
regMsg->setTopicName(tp);
printf(FORMAT2, currentDateTime(), "REGISTER", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(regMsg));
clnode->setClientSendMessage(regMsg);
Event* evrg = new Event();
evrg->setClientSendEvent(clnode);
_res->getClientSendQue()->post(evrg); // Send Register first.
}else{
printf("GatewayControlTask Can't create Topic %s\n", tp->c_str());
return;
}
}
snMsg->setTopicId(tpId);
snMsg->setMsgId(mqMsg->getMessageId());
snMsg->setData(mqMsg->getPayload(),mqMsg->getPayloadLength());
snMsg->setQos(mqMsg->getQos());
if(mqMsg->isDup()){
snMsg->setDup();
}
if(mqMsg->isRetain()){
snMsg->setDup();
}
clnode->setClientSendMessage(snMsg);
printf(GREEN_FORMAT1, currentDateTime(), "PUBLISH", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
void GatewayControlTask::run(){
Timer advertiseTimer;
Timer sendUnixTimer;
Event* ev = 0;
_gatewayId = atoi(_res->getArgv('i'));
if (_gatewayId == 0 || _gatewayId > 255){
THROW_EXCEPTION(ExFatal, ERRNO_SYS_05, "Invalid Gateway Id"); // ABORT
}
int keepAlive = KEEP_ALIVE_TIME;
if(_res->getArgv('k') != 0){
keepAlive =atoi( _res->getArgv('k'));
if (keepAlive > 65536){
THROW_EXCEPTION(ExFatal, ERRNO_SYS_06, "KeepAliveTime is grater than 65536 Secs"); // ABORT
}
}
if(_res->getArgv('l') != 0){
_loginId = _res->getArgv('l');
}
if(_res->getArgv('w') != 0){
_password = _res->getArgv('w');
}
_eventQue = _res->getGatewayEventQue();
advertiseTimer.start(keepAlive * 1000UL);
printf("%s TomyGateway start\n", currentDateTime());
while(true){
ev = _eventQue->timedwait(TIMEOUT_PERIOD);
/*------ Check Client is Lost ---------*/
if(ev->getEventType() == EtTimeout){
ClientList* clist = _res->getClientList();
for( int i = 0; i < clist->getClientCount(); i++){
if((*clist)[i]){
(*clist)[i]->checkTimeover();
}else{
break;
}
}
/*------ Check Keep Alive Timer & send Advertise ------*/
if(advertiseTimer.isTimeup()){
MQTTSnAdvertise* adv = new MQTTSnAdvertise();
adv->setGwId(_gatewayId);
adv->setDuration(keepAlive);
Event* ev1 = new Event();
ev1->setEvent(adv); //broadcast
printf(YELLOW_FORMAT2, currentDateTime(), "ADVERTISE", LEFTARROW, GATEWAY, msgPrint(adv));
_res->getClientSendQue()->post(ev1);
advertiseTimer.start(keepAlive * 1000UL);
sendUnixTimer.start(SEND_UNIXTIME_TIME * 1000UL);
}
/*------ Check Timer & send UixTime ------*/
if(sendUnixTimer.isTimeup()){
uint8_t buf[4];
uint32_t tm = time(0);
setUint32(buf,tm);
MQTTSnPublish* msg = new MQTTSnPublish();
msg->setTopicId(MQTTSN_TOPICID_PREDEFINED_TIME);
msg->setTopicIdType(MQTTSN_TOPIC_TYPE_PREDEFINED);
msg->setData(buf, 4);
msg->setQos(0);
Event* ev1 = new Event();
ev1->setEvent(msg);
printf(YELLOW_FORMAT2, currentDateTime(), "PUBLISH", LEFTARROW, GATEWAY, msgPrint(msg));
_res->getClientSendQue()->post(ev1);
sendUnixTimer.stop();
}
}
/*------ Check SEARCHGW & send GWINFO ---------*/
else if(ev->getEventType() == EtBroadcast){
MQTTSnMessage* msg = ev->getMqttSnMessage();
printf(YELLOW_FORMAT2, currentDateTime(), "SERCHGW", LEFTARROW, CLIENT, msgPrint(msg));
if(msg->getType() == MQTTSN_TYPE_SEARCHGW){
if(_res->getClientList()->getClientCount() < MAX_CLIENT_NODES ){
MQTTSnGwInfo* gwinfo = new MQTTSnGwInfo();
gwinfo->setGwId(_gatewayId);
Event* ev1 = new Event();
ev1->setEvent(gwinfo);
printf(YELLOW_FORMAT1, currentDateTime(), "GWINFO", RIGHTARROW, CLIENT, msgPrint(gwinfo));
_res->getClientSendQue()->post(ev1);
}
}
}
/*------ Message form Clients ---------*/
else if(ev->getEventType() == EtClientRecv){
ClientNode* clnode = ev->getClientNode();
MQTTSnMessage* msg = clnode->getClientRecvMessage();
clnode->updateStatus(msg);
if(msg->getType() == MQTTSN_TYPE_PUBLISH){
handleSnPublish(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_SUBSCRIBE){
handleSnSubscribe(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_UNSUBSCRIBE){
handleSnUnsubscribe(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_PINGREQ){
handleSnPingReq(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_PUBACK){
handleSnPubAck(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_CONNECT){
handleSnConnect(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_WILLTOPIC){
handleSnWillTopic(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_WILLMSG){
handleSnWillMsg(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_DISCONNECT){
handleSnDisconnect(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_REGISTER){
handleSnRegister(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_PUBREC){
handleSnPubRec(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_PUBREL){
handleSnPubRel(ev, clnode, msg);
}else if(msg->getType() == MQTTSN_TYPE_PUBCOMP){
handleSnPubComp(ev, clnode, msg);
}else{
printf("%s Irregular ClientRecvMessage\n", currentDateTime());
}
}
/*------ Message form Broker ---------*/
else if(ev->getEventType() == EtBrokerRecv){
ClientNode* clnode = ev->getClientNode();
MQTTMessage* msg = clnode->getBrokerRecvMessage();
if(msg->getType() == MQTT_TYPE_PUBACK){
handlePuback(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_PINGRESP){
handlePingresp(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_SUBACK){
handleSuback(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_UNSUBACK){
handleUnsuback(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_CONNACK){
handleConnack(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_PUBLISH){
handlePublish(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_DISCONNECT){
handleDisconnect(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_PUBREC){
handlePubRec(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_PUBREL){
handlePubRel(ev, clnode, msg);
}else if(msg->getType() == MQTT_TYPE_PUBCOMP){
handlePubComp(ev, clnode, msg);
}else{
printf("%s Irregular BrokerRecvMessage\n", currentDateTime());
}
}
delete ev;
}
}
/*-------------------------------------------------------
Upstream MQTTSnSubscribe
-------------------------------------------------------*/
void GatewayControlTask::handleSnSubscribe(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT2, currentDateTime(), "SUBSCRIBE", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnSubscribe* sSubscribe = new MQTTSnSubscribe();
MQTTSubscribe* subscribe = new MQTTSubscribe();
sSubscribe->absorb(msg);
uint8_t topicIdType = sSubscribe->getFlags() & 0x03;
subscribe->setMessageId(sSubscribe->getMsgId());
if(sSubscribe->getFlags() & MQTTSN_FLAG_DUP ){
subscribe->setDup();
}
if(sSubscribe->getFlags() & MQTTSN_FLAG_RETAIN){
subscribe->setRetain();
}
subscribe->setQos(sSubscribe->getQos());
if(topicIdType != MQTTSN_FLAG_TOPICID_TYPE_RESV){
if(topicIdType == MQTTSN_FLAG_TOPICID_TYPE_PREDEFINED){
/*----- Predefined TopicId ------*/
MQTTSnSubAck* sSuback = new MQTTSnSubAck();
if(sSubscribe->getMsgId()){ // MessageID
sSuback->setQos(sSubscribe->getQos());
sSuback->setTopicId(sSubscribe->getTopicId());
sSuback->setMsgId(sSubscribe->getMsgId());
if(sSubscribe->getTopicId() == MQTTSN_TOPICID_PREDEFINED_TIME){
sSuback->setReturnCode(MQTT_RC_ACCEPTED);
}else{
sSuback->setReturnCode(MQTT_RC_REFUSED_IDENTIFIER_REJECTED);
}
clnode->setClientSendMessage(sSuback);
Event* evsuback = new Event();
evsuback->setClientSendEvent(clnode);
printf(FORMAT1, currentDateTime(), "SUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(sSuback));
_res->getClientSendQue()->post(evsuback);
}
if(sSubscribe->getTopicId() == MQTTSN_TOPICID_PREDEFINED_TIME){
MQTTSnPublish* pub = new MQTTSnPublish();
pub->setTopicIdType(1); // pre-defined
pub->setTopicId(MQTTSN_TOPICID_PREDEFINED_TIME);
pub->setMsgId(clnode->getNextSnMsgId());
uint8_t buf[4];
uint32_t tm = time(0);
setUint32(buf,tm);
pub->setData(buf, 4);
printf(GREEN_FORMAT1, currentDateTime(), "PUBLISH", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(pub));
clnode->setClientSendMessage(pub);
Event *evpub = new Event();
evpub->setClientSendEvent(clnode);
_res->getClientSendQue()->post(evpub);
}
delete subscribe;
}else{
uint16_t tpId;
Topic* tp = clnode->getTopics()->getTopic(sSubscribe->getTopicName());
if (tp){
tpId = tp->getTopicId();
}else{
tpId = clnode->getTopics()->createTopic(sSubscribe->getTopicName());
}
subscribe->setTopic(sSubscribe->getTopicName(), sSubscribe->getQos());
if(sSubscribe->getMsgId()){
MQTTSnSubAck* sSuback = new MQTTSnSubAck();
sSuback->setMsgId(sSubscribe->getMsgId());
sSuback->setTopicId(tpId);
clnode->setWaitedSubAck(sSuback);
}
clnode->setBrokerSendMessage(subscribe);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
delete sSubscribe;
return;
}
}else{
/*-- Irregular TopicIdType --*/
if(sSubscribe->getMsgId()){
MQTTSnSubAck* sSuback = new MQTTSnSubAck();
sSuback->setMsgId(sSubscribe->getMsgId());
sSuback->setTopicId(sSubscribe->getTopicId());
sSuback->setReturnCode(MQTT_RC_REFUSED_IDENTIFIER_REJECTED);
clnode->setClientSendMessage(sSuback);
Event* evun = new Event();
evun->setClientSendEvent(clnode);
printf(FORMAT1, currentDateTime(), "SUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(sSuback));
_res->getClientSendQue()->post(evun); // Send SUBACK to Client
}
delete subscribe;
}
delete sSubscribe;
}
/*-------------------------------------------------------
* Upstream MQTTSnPublish
-------------------------------------------------------*/
void GatewayControlTask::handleSnPublish(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(BLUE_FORMAT2, currentDateTime(), "PUBLISH", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnPublish* sPublish = new MQTTSnPublish();
MQTTPublish* mqMsg = new MQTTPublish();
sPublish->absorb(msg);
Topic* tp = clnode->getTopics()->getTopic(sPublish->getTopicId());
if(tp || ((sPublish->getFlags() && MQTTSN_TOPIC_TYPE) == MQTTSN_TOPIC_TYPE_SHORT)){
if(tp){
mqMsg->setTopic(tp->getTopicName());
}else{
string str;
mqMsg->setTopic(sPublish->getTopic(&str));
}
if(sPublish->getMsgId()){
MQTTSnPubAck* sPuback = new MQTTSnPubAck();
sPuback->setMsgId(sPublish->getMsgId());
sPuback->setTopicId(sPublish->getTopicId());
if(clnode->getWaitedPubAck()){
delete clnode->getWaitedPubAck();
}
clnode->setWaitedPubAck(sPuback);
mqMsg->setMessageId(sPublish->getMsgId());
}
mqMsg->setQos(sPublish->getQos());
if(sPublish->getFlags() && MQTTSN_FLAG_DUP){
mqMsg->setDup();
}
if(sPublish->getFlags() && MQTTSN_FLAG_RETAIN){
mqMsg->setRetain();
}
mqMsg->setPayload(sPublish->getData() , sPublish->getDataLength());
clnode->setBrokerSendMessage(mqMsg);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
}else{
if(sPublish->getMsgId()){
MQTTSnPubAck* sPuback = new MQTTSnPubAck();
sPuback->setMsgId(sPublish->getMsgId());
sPuback->setTopicId(sPublish->getTopicId());
sPuback->setReturnCode(MQTTSN_RC_REJECTED_INVALID_TOPIC_ID);
clnode->setClientSendMessage(sPuback);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
printf(BLUE_FORMAT1, currentDateTime(), "PUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(sPuback));
_res->getClientSendQue()->post(ev1); // Send PubAck INVALID_TOPIC_ID
}
}
delete sPublish;
}
void ClientRecvTask::run(){
if(_sp.begin(_res->getArgv()[ARGV_DEVICE_NAME], B57600, O_RDONLY) == -1){
THROW_EXCEPTION(ExFatal, ERRNO_SYS_02, "can't open device.");
}
_zb.setSerialPort(&_sp);
_res->getClientList()->authorize(FILE_NAME_CLIENT_LIST);
while(true){
XBResponse* resp = new XBResponse();
bool eventSetFlg = true;
if(_zb.getResponse(resp)){
Event* ev = new Event();
ClientNode* clnode = _res->getClientList()->getClient(resp->getRemoteAddress64());
if(!clnode){
if(resp->getPayloadPtr()[1] == MQTTSN_TYPE_CONNECT){
ClientNode* node = _res->getClientList()->createNode(resp->getRemoteAddress64());
if(!node){
delete ev;
D_MQTT("Client is not authorized.\n");
continue;
}
MQTTSnConnect* msg = new MQTTSnConnect();
msg->absorb(resp);
node->setAddress16(resp->getRemoteAddress16());
if(msg->getClientId()->size() > 0){
node->setNodeId(msg->getClientId());
}
node->setClientRecvMessage(msg);
ev->setClientRecvEvent(node);
}else if(resp->getPayloadPtr()[1] == MQTTSN_TYPE_SEARCHGW){
MQTTSnSearchGw* msg = new MQTTSnSearchGw();
msg->absorb(resp);
ev->setEvent(msg);
}else{
eventSetFlg = false;
}
}else{
if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_CONNECT){
MQTTSnConnect* msg = new MQTTSnConnect();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
clnode->setAddress16(resp->getRemoteAddress16());
ev->setClientRecvEvent(clnode);
}else if(resp->getPayloadPtr()[1] == MQTTSN_TYPE_PUBLISH){
MQTTSnPublish* msg = new MQTTSnPublish();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(resp->getPayloadPtr()[1] == MQTTSN_TYPE_PUBACK){
MQTTSnPubAck* msg = new MQTTSnPubAck();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_CONNECT){
MQTTSnConnect* msg = new MQTTSnConnect();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_PINGREQ){
MQTTSnPingReq* msg = new MQTTSnPingReq();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_DISCONNECT){
MQTTSnDisconnect* msg = new MQTTSnDisconnect();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_REGISTER){
MQTTSnRegister* msg = new MQTTSnRegister();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_REGACK){
MQTTSnRegAck* msg = new MQTTSnRegAck();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_UNSUBSCRIBE){
MQTTSnUnsubscribe* msg = new MQTTSnUnsubscribe();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_SUBSCRIBE){
MQTTSnSubscribe* msg = new MQTTSnSubscribe();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_WILLTOPIC){
MQTTSnWillTopic* msg = new MQTTSnWillTopic();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (resp->getPayloadPtr()[1] == MQTTSN_TYPE_WILLMSG){
MQTTSnWillMsg* msg = new MQTTSnWillMsg();
msg->absorb(resp);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(resp->getPayloadPtr()[1] == MQTTSN_TYPE_SEARCHGW){
MQTTSnSearchGw* msg = new MQTTSnSearchGw();
msg->absorb(resp);
ev->setEvent(msg);
}else{
eventSetFlg = false;
}
}
if(eventSetFlg){
_res->getGatewayEventQue()->post(ev);
}else{
delete ev;
}
}
delete resp;
}
}
void ClientRecvTask::run(){
NETWORK_CONFIG config;
char param[TOMYFRAME_PARAM_MAX];
bool secure = false; // TCP
#ifdef NETWORK_XBEE
if(_res->getParam("BaudRate",param) == 0){
int val = atoi(param);
switch(val){
case 9600:
config.baudrate = B9600;
break;
case 19200:
config.baudrate =B19200;
break;
case 38400:
config.baudrate =B38400;
break;
case 57600:
config.baudrate =B57600;
break;
case 115200:
config.baudrate = B115200;
break;
default:
THROW_EXCEPTION(ExFatal, ERRNO_APL_01, "Invalid baud rate!"); // ABORT
}
}else{
config.baudrate = B57600;
}
config.flag = O_RDONLY;
if(_res->getParam("SerialDevice",param) == 0){
config.device = strdup(param);
}
if(_res->getParam("SecureConnection",param) == 0){
if(!strcasecmp(param, "YES")){
secure = true; // TLS
}
}
_res->getClientList()->authorize(FILE_NAME_CLIENT_LIST, secure);
_network = new Network();
#endif
#ifdef NETWORK_UDP
if(_res->getParam("BroadcastIP", param) == 0){
config.ipAddress = strdup(param);
}
if(_res->getParam("BroadcastPortNo",param) == 0){
config.gPortNo = atoi(param);
}
if(_res->getParam("GatewayPortNo",param) == 0){
config.uPortNo = atoi(param);
}
_network = _res->getNetwork();
#endif
#ifdef NETWORK_XXXXX
_network = _res->getNetwork();
#endif
if(_network->initialize(config) < 0){
THROW_EXCEPTION(ExFatal, ERRNO_APL_01, "can't open the client port."); // ABORT
}
uint8_t* recvMsg;
int len;
while(true){
bool eventSetFlg = true;
recvMsg = _network->Network::getResponce(&len);
if (recvMsg != 0){
uint8_t offset = 0;
if (recvMsg[0] == 0x01){
offset = 3;
}else{
offset = 1;
}
Event* ev = new Event();
ClientNode* clnode = _res->getClientList()->getClient(_network->getAddrMsb(),_network->getAddrLsb(),
_network->getAddr16());
if(!clnode){
if(*(recvMsg + offset) == MQTTSN_TYPE_CONNECT){
#ifdef NETWORK_XBEE
ClientNode* node = _res->getClientList()->createNode(secure, _network->getAddrMsb(),_network->getAddrLsb(),0);
#endif
#ifdef NETWORK_UDP
ClientNode* node = _res->getClientList()->createNode(secure, _network->getAddrMsb(),_network->getAddrLsb(),
_network->getAddr16());
#endif
#ifdef NETWORK_XXXXX
ClientNode* node = _res->getClientList()->createNode(secure, _network->getAddrMsb(),_network->getAddrLsb(),
_network->getAddr16());
#endif
if(!node){
delete ev;
LOGWRITE("Client is not authorized.\n");
continue;
}
MQTTSnConnect* msg = new MQTTSnConnect();
msg->absorb(recvMsg);
node->setClientAddress16(_network->getAddr16());
if(msg->getClientId()->size() > 0){
node->setNodeId(msg->getClientId());
}
node->setClientRecvMessage(msg);
ev->setClientRecvEvent(node);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_SEARCHGW){
MQTTSnSearchGw* msg = new MQTTSnSearchGw();
msg->absorb(recvMsg);
ev->setEvent(msg);
}else{
eventSetFlg = false;
}
}else{
if (*(recvMsg + offset) == MQTTSN_TYPE_CONNECT){
MQTTSnConnect* msg = new MQTTSnConnect();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
clnode->setClientAddress16(_network->getAddr16());
ev->setClientRecvEvent(clnode);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_PUBLISH){
MQTTSnPublish* msg = new MQTTSnPublish();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_PUBACK){
MQTTSnPubAck* msg = new MQTTSnPubAck();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_PUBREC){
MQTTSnPubRec* msg = new MQTTSnPubRec();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_PUBREL){
MQTTSnPubRel* msg = new MQTTSnPubRel();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_PUBCOMP){
MQTTSnPubComp* msg = new MQTTSnPubComp();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_CONNECT){
MQTTSnConnect* msg = new MQTTSnConnect();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_PINGREQ){
MQTTSnPingReq* msg = new MQTTSnPingReq();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_DISCONNECT){
MQTTSnDisconnect* msg = new MQTTSnDisconnect();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_REGISTER){
MQTTSnRegister* msg = new MQTTSnRegister();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_REGACK){
MQTTSnRegAck* msg = new MQTTSnRegAck();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_UNSUBSCRIBE){
MQTTSnUnsubscribe* msg = new MQTTSnUnsubscribe();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_SUBSCRIBE){
MQTTSnSubscribe* msg = new MQTTSnSubscribe();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_WILLTOPIC){
MQTTSnWillTopic* msg = new MQTTSnWillTopic();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if (*(recvMsg + offset) == MQTTSN_TYPE_WILLMSG){
MQTTSnWillMsg* msg = new MQTTSnWillMsg();
msg->absorb(recvMsg);
clnode->setClientRecvMessage(msg);
ev->setClientRecvEvent(clnode);
}else if(*(recvMsg + offset) == MQTTSN_TYPE_SEARCHGW){
MQTTSnSearchGw* msg = new MQTTSnSearchGw();
clnode->disconnected();
msg->absorb(recvMsg);
ev->setEvent(msg);
}else{
eventSetFlg = false;
}
}
if(eventSetFlg){
_res->getGatewayEventQue()->post(ev);
}else{
delete ev;
}
}
}
}
