/*-------------------------------------------------------
Upstream MQTTSnRegister
-------------------------------------------------------*/
void GatewayControlTask::handleSnRegister(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT2, currentDateTime(), "REGISTER", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnRegister* snMsg = new MQTTSnRegister();
MQTTSnRegAck* respMsg = new MQTTSnRegAck();
snMsg->absorb(msg);
respMsg->setMsgId(snMsg->getMsgId());
uint16_t tpId = clnode->getTopics()->createTopic(snMsg->getTopicName());
respMsg->setTopicId(tpId);
respMsg->setReturnCode(MQTTSN_RC_ACCEPTED);
clnode->setClientSendMessage(respMsg);
Event* evrg = new Event();
evrg->setClientSendEvent(clnode);
printf(FORMAT1, currentDateTime(), "REGACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(respMsg));
_res->getClientSendQue()->post(evrg);
delete snMsg;
}
/*-------------------------------------------------------
Downstream MQTTPubAck
-------------------------------------------------------*/
void GatewayControlTask::handlePuback(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTPubAck* mqMsg = static_cast<MQTTPubAck*>(msg);
MQTTSnPubAck* snMsg = clnode->getWaitedPubAck();
if(snMsg){
printf(BLUE_FORMAT1, currentDateTime(), "PUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
if(snMsg->getMsgId() == mqMsg->getMessageId()){
clnode->setWaitedPubAck(0);
clnode->setClientSendMessage(snMsg);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
}
}
void BrokerSendTask::run(){
Event* ev = NULL;
MQTTMessage* srcMsg = NULL;
ClientNode* clnode = NULL;
uint8_t buffer[SOCKET_MAXBUFFER_LENGTH];
string host = BROKER_HOST_NAME;
int port = BROKER_PORT;
if(_res->getArgc() > ARGV_BROKER_ADDR){
host = _res->getArgv()[ARGV_BROKER_ADDR];
}
if(_res->getArgc() > ARGV_BROKER_PORT){
port = atoi(_res->getArgv()[ARGV_BROKER_PORT]);
}
while(true){
uint16_t length = 0;
memset(buffer, 0, SOCKET_MAXBUFFER_LENGTH);
ev = _res->getBrokerSendQue()->wait();
clnode = ev->getClientNode();
srcMsg = clnode->getBrokerSendMessage();
if(srcMsg->getType() == MQTT_TYPE_PUBLISH){
MQTTPublish* msg = static_cast<MQTTPublish*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s PUBLISH ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
else if(srcMsg->getType() == MQTT_TYPE_PUBACK){
MQTTPubAck* msg = static_cast<MQTTPubAck*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s PUBACK ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
else if(srcMsg->getType() == MQTT_TYPE_PINGREQ){
MQTTPingReq* msg = static_cast<MQTTPingReq*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s PINGREQ ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
else if(srcMsg->getType() == MQTT_TYPE_SUBSCRIBE){
MQTTSubscribe* msg = static_cast<MQTTSubscribe*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s SUBSCRIBE ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
else if(srcMsg->getType() == MQTT_TYPE_UNSUBSCRIBE){
MQTTUnsubscribe* msg = static_cast<MQTTUnsubscribe*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s UNSUBSCRIBE ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
else if(srcMsg->getType() == MQTT_TYPE_CONNECT){
MQTTConnect* msg = static_cast<MQTTConnect*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s CONNECT ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
else if(srcMsg->getType() == MQTT_TYPE_DISCONNECT){
MQTTDisconnect* msg = static_cast<MQTTDisconnect*>(srcMsg);
length = msg->serialize(buffer);
D_MQTT("%s DISCONNECT ---> Broker %s\n", currentDateTime(), msgPrint(buffer,msg));
}
int rc = 0;
if(length > 0){
if( clnode->getSocket()->isValid()){
rc = clnode->getSocket()->send(buffer, length);
if(rc == -1){
clnode->getSocket()->disconnect();
D_MQTT(" Socket is valid. but can't send Client:%s\n", clnode->getNodeId()->c_str());
}
}else{
if(clnode->getSocket()->create()){
if(clnode->getSocket()->connect(host, port)){
rc = clnode->getSocket()->send(buffer, length);
if(rc == -1){
clnode->getSocket()->disconnect();
D_MQTT(" Socket is created. but can't send, Client:%s\n", clnode->getNodeId()->c_str());
}
}else{
D_MQTT("%s Can't connect socket Client:%s\n",
currentDateTime(), clnode->getNodeId()->c_str());
}
}else{
D_MQTT("%s Can't create socket Client:%s\n",
currentDateTime(), clnode->getNodeId()->c_str());
}
}
}
delete ev;
}
}
/*-------------------------------------------------------
Upstream MQTTSnDisconnect
-------------------------------------------------------*/
void GatewayControlTask::handleSnDisconnect(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT2, currentDateTime(), "DISCONNECT", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnDisconnect* snMsg = new MQTTSnDisconnect();
MQTTDisconnect* mqMsg = new MQTTDisconnect();
snMsg->absorb(msg);
clnode->setBrokerSendMessage(mqMsg);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
delete snMsg;
}
/*-------------------------------------------------------
Downstream MQTTConnAck
-------------------------------------------------------*/
void GatewayControlTask::handleConnack(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTConnAck* mqMsg = static_cast<MQTTConnAck*>(msg);
MQTTSnConnack* snMsg = new MQTTSnConnack();
if(mqMsg->getReturnCd() == 0){
snMsg->setReturnCode(MQTTSN_RC_ACCEPTED);
}else if(mqMsg->getReturnCd() == MQTT_RC_REFUSED_PROTOCOL_VERSION){
snMsg->setReturnCode(MQTTSN_RC_REJECTED_NOT_SUPPORTED);
_protocol = (_protocol == MQTT_PROTOCOL_VER4) ? MQTT_PROTOCOL_VER3 : MQTT_PROTOCOL_VER4;
}else if(mqMsg->getReturnCd() == MQTT_RC_REFUSED_SERVER_UNAVAILABLE){
snMsg->setReturnCode(MQTTSN_RC_REJECTED_CONGESTION);
}else{
snMsg->setReturnCode(MQTTSN_RC_REJECTED_INVALID_TOPIC_ID);
}
printf(CYAN_FORMAT1, currentDateTime(), "CONNACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
clnode->setClientSendMessage(snMsg);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
/*-------------------------------------------------------
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);
}
/*-------------------------------------------------------
Upstream MQTTSnPubComp
-------------------------------------------------------*/
void GatewayControlTask::handleSnPubComp(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(GREEN_FORMAT1, currentDateTime(), "PUBREL", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnPubComp* sPubComp= new MQTTSnPubComp();
MQTTPubComp* pubComp = new MQTTPubComp();
sPubComp->absorb(msg);
pubComp->setMessageId(sPubComp->getMsgId());
clnode->setBrokerSendMessage(pubComp);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
delete sPubComp;
}
/*-------------------------------------------------------
Downstream MQTTSubAck
-------------------------------------------------------*/
void GatewayControlTask::handleSuback(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTSubAck* mqMsg = static_cast<MQTTSubAck*>(msg);
MQTTSnSubAck* snMsg = clnode->getWaitedSubAck();
if(snMsg){
if(snMsg->getMsgId() == mqMsg->getMessageId()){
clnode->setWaitedSubAck(0);
if(mqMsg->getGrantedQos() == 0x80){
snMsg->setReturnCode(MQTTSN_RC_REJECTED_INVALID_TOPIC_ID);
}else{
snMsg->setReturnCode(MQTTSN_RC_ACCEPTED);
snMsg->setQos(mqMsg->getGrantedQos());
}
printf(FORMAT1, currentDateTime(), "SUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
clnode->setClientSendMessage(snMsg);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
}
}
/*-------------------------------------------------------
Upstream MQTTSnUnsubscribe
-------------------------------------------------------*/
void GatewayControlTask::handleSnUnsubscribe(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT2, currentDateTime(), "UNSUBSCRIBE", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnUnsubscribe* sUnsubscribe = new MQTTSnUnsubscribe();
MQTTUnsubscribe* unsubscribe = new MQTTUnsubscribe();
sUnsubscribe->absorb(msg);
uint8_t topicIdType = sUnsubscribe->getFlags() & 0x03;
unsubscribe->setMessageId(sUnsubscribe->getMsgId());
if(topicIdType != MQTTSN_FLAG_TOPICID_TYPE_RESV){
if(topicIdType == MQTTSN_FLAG_TOPICID_TYPE_SHORT){
unsubscribe->setTopicName(sUnsubscribe->getTopicName()); // TopicName
}else if(clnode->getTopics()->getTopic(sUnsubscribe->getTopicId())){
if(topicIdType == MQTTSN_FLAG_TOPICID_TYPE_PREDEFINED) goto uslbl1;
unsubscribe->setTopicName(sUnsubscribe->getTopicName());
}
clnode->setBrokerSendMessage(unsubscribe);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1); // UNSUBSCRIBE to Broker
delete sUnsubscribe;
return;
}
/*-- Irregular TopicIdType or MQTTSN_FLAG_TOPICID_TYPE_PREDEFINED --*/
uslbl1:
if(sUnsubscribe->getMsgId()){
MQTTSnUnsubAck* sUnsuback = new MQTTSnUnsubAck();
sUnsuback->setMsgId(sUnsubscribe->getMsgId());
clnode->setClientSendMessage(sUnsuback);
Event* evun = new Event();
evun->setClientSendEvent(clnode);
printf(FORMAT1, currentDateTime(), "UNSUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(sUnsuback));
_res->getClientSendQue()->post(evun); // Send UNSUBACK to Client
}
delete sUnsubscribe;
}
/*-------------------------------------------------------
Upstream MQTTSnPingReq
-------------------------------------------------------*/
void GatewayControlTask::handleSnPingReq(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT2, currentDateTime(), "PINGREQ", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTPingReq* pingReq = new MQTTPingReq();
clnode->setBrokerSendMessage(pingReq);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
}
/*-------------------------------------------------------
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;
}
enum Result CrocPack(const char *dirname, const char *fsname, const char *outputpath, const char *list, enum ENDIAN endian, bool align)
{
FILE *fDir, *fArc, *fList;
if (!OpenFile(&fDir, dirname, OPENFILECREATE))
return FILENOTCREATED;
if (!OpenFile(&fArc, fsname, OPENFILECREATE))
return FILENOTCREATED;
if (!OpenFile(&fList, list, OPENFILEREAD))
return FILENOTFOUND;
if (endian == ENOTSET)
{
msgPrint(MsgLv_Warning, "Endian not specified.\n");
msgPrint(MsgLv_Info, "Endian set to %s.\n", "LITTLE (PS1 ver.)");
endian = ELITTLE;
}
unsigned int entries = 0;
fseek(fDir, 4, SEEK_SET);
unsigned int pos = 0;
char name[0x0D];
char path[MAX_PATH];
struct CrocFsEntry CrocFsEntry;
while(fscanf(fList, "%s", name) != EOF)
{
int i;
FILE *f;
sprintf(path, "%s\\%s", outputpath, name);
msgPrint(MsgLv_Message, "Packing %s\n", name);
if (!OpenFile(&f, name, OPENFILECREATE))
return FILENOTCREATED;
for (i = 0; i < 0xC && name[i] != '\0'; i++)
CrocFsEntry.name[i] = name[i];
for(; i < 0xC; i++)
CrocFsEntry.name[i] = 0;
CrocFsEntry.size = GetFileSize(f);
CrocFsEntry.pos = pos;
CrocFsEntry.dummy = 0;
void *data = malloc(CrocFsEntry.size);
fread(data, 1, CrocFsEntry.size, f);
fclose(f);
fwrite(data, 1, CrocFsEntry.size, fArc);
free(data);
if (align)
{
pos += (CrocFsEntry.size & 0x7FF) != 0 ? CrocFsEntry.size + (0x800 - (CrocFsEntry.size%0x800)) : CrocFsEntry.size;
fseek(fArc, pos, SEEK_SET);
}
else
pos += CrocFsEntry.size;
if (endian == EBIG)
{
CrocFsEntry.size = EndianSwap(CrocFsEntry.size);
CrocFsEntry.size = EndianSwap(CrocFsEntry.pos);
}
fwrite(&CrocFsEntry, 1, sizeof(struct CrocFsEntry), fDir);
entries++;
}
unsigned int unknowvalue = 0;
fclose(fList);
fclose(fArc);
if (endian == EBIG)
entries = EndianSwap(entries);
fwrite(&unknowvalue, 1, sizeof(unknowvalue), fDir);
fseek(fDir, 0, SEEK_SET);
fwrite(&entries, 1, sizeof(entries), fDir);
fclose(fDir);
return NOERRORS;
}
/*-------------------------------------------------------
Downstream MQTTPubComp
-------------------------------------------------------*/
void GatewayControlTask::handlePubComp(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTSnPubComp* snMsg = new MQTTSnPubComp();
MQTTPubComp* mqMsg = static_cast<MQTTPubComp*>(msg);
snMsg->setMsgId(mqMsg->getMessageId());
printf(BLUE_FORMAT1, currentDateTime(), "PUBCOMP", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
clnode->setClientSendMessage(snMsg);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
/*-------------------------------------------------------
Upstream MQTTSnConnect
-------------------------------------------------------*/
void GatewayControlTask::handleSnConnect(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT2, currentDateTime(), "CONNECT", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
Topics* topics = clnode->getTopics();
MQTTSnConnect* sConnect = new MQTTSnConnect();
MQTTConnect* mqMsg = new MQTTConnect();
mqMsg->setProtocol(_protocol);
sConnect->absorb(msg);
mqMsg->setClientId(clnode->getNodeId());
mqMsg->setKeepAliveTime(sConnect->getDuration());
if(_loginId != "" && _password != ""){
mqMsg->setUserName(&_loginId);
mqMsg->setPassword(&_password);
}
clnode->setConnectMessage(mqMsg);
if(sConnect->isCleanSession()){
if(topics){
delete topics;
}
topics = new Topics();
clnode->setTopics(topics);
mqMsg->setCleanSessionFlg();
}
if(sConnect->isWillRequired()){
MQTTSnWillTopicReq* reqTopic = new MQTTSnWillTopicReq();
Event* evwr = new Event();
clnode->setClientSendMessage(reqTopic);
evwr->setClientSendEvent(clnode);
printf(FORMAT1, currentDateTime(), "WILLTOPICREQ", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(reqTopic));
_res->getClientSendQue()->post(evwr); // Send WILLTOPICREQ to Client
}else{
Event* ev1 = new Event();
clnode->setBrokerSendMessage(clnode->getConnectMessage());
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
}
delete sConnect;
}
/*-------------------------------------------------------
Downstream MQTTPingResp
-------------------------------------------------------*/
void GatewayControlTask::handlePingresp(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTSnPingResp* snMsg = new MQTTSnPingResp();
//MQTTPingResp* mqMsg = static_cast<MQTTPingResp*>(msg);
printf(FORMAT1, currentDateTime(), "PINGRESP", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
clnode->setClientSendMessage(snMsg);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
/*-------------------------------------------------------
Upstream MQTTSnWillTopic
-------------------------------------------------------*/
void GatewayControlTask::handleSnWillTopic(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT1, currentDateTime(), "WILLTOPIC", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnWillTopic* snMsg = new MQTTSnWillTopic();
MQTTSnWillMsgReq* reqMsg = new MQTTSnWillMsgReq();
snMsg->absorb(msg);
if(clnode->getConnectMessage()){
clnode->getConnectMessage()->setWillTopic(snMsg->getWillTopic());
clnode->getConnectMessage()->setWillQos(snMsg->getQos());
clnode->setClientSendMessage(reqMsg);
Event* evt = new Event();
evt->setClientSendEvent(clnode);
printf(FORMAT1, currentDateTime(), "WILLMSGREQ", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(reqMsg));
_res->getClientSendQue()->post(evt); // Send WILLMSGREQ to Client
}
delete snMsg;
}
/*-------------------------------------------------------
Downstream MQTTUnsubAck
-------------------------------------------------------*/
void GatewayControlTask::handleUnsuback(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTUnsubAck* mqMsg = static_cast<MQTTUnsubAck*>(msg);
MQTTSnUnsubAck* snMsg = new MQTTSnUnsubAck();
snMsg->setMsgId(mqMsg->getMessageId());
printf(FORMAT1, currentDateTime(), "UNSUBACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(snMsg));
clnode->setClientSendMessage(snMsg);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
_res->getClientSendQue()->post(ev1);
}
/*-------------------------------------------------------
Upstream MQTTSnWillMsg
-------------------------------------------------------*/
void GatewayControlTask::handleSnWillMsg(Event* ev, ClientNode* clnode, MQTTSnMessage* msg){
printf(FORMAT1, currentDateTime(), "WILLMSG", LEFTARROW, clnode->getNodeId()->c_str(), msgPrint(msg));
MQTTSnWillMsg* snMsg = new MQTTSnWillMsg();
snMsg->absorb(msg);
if(clnode->getConnectMessage()){
clnode->getConnectMessage()->setWillMessage(snMsg->getWillMsg());
clnode->setBrokerSendMessage(clnode->getConnectMessage());
clnode->setConnectMessage(0);
Event* ev1 = new Event();
ev1->setBrokerSendEvent(clnode);
_res->getBrokerSendQue()->post(ev1);
}else{
MQTTSnConnack* connack = new MQTTSnConnack();
connack->setReturnCode(MQTTSN_RC_REJECTED_CONGESTION);
clnode->setClientSendMessage(connack);
Event* ev1 = new Event();
ev1->setClientSendEvent(clnode);
printf(RED_FORMAT1, currentDateTime(), "*CONNACK", RIGHTARROW, clnode->getNodeId()->c_str(), msgPrint(connack));
_res->getClientSendQue()->post(ev1); // Send CONNACK REJECTED CONGESTION to Client
}
delete snMsg;
}
/*-------------------------------------------------------
Downstream MQTTDisconnect
-------------------------------------------------------*/
void GatewayControlTask::handleDisconnect(Event* ev, ClientNode* clnode, MQTTMessage* msg){
MQTTSnDisconnect* snMsg = new MQTTSnDisconnect();
//MQTTDisconnect* mqMsg = static_cast<MQTTDisconnect*>(msg);
clnode->setClientSendMessage(snMsg);
printf(FORMAT1, currentDateTime(), "DISCONNECT", 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;
}
}
void BrokerSendTask::run(){
Event* ev = 0;
MQTTMessage* srcMsg = 0;
ClientNode* clnode = 0;
char param[TOMYFRAME_PARAM_MAX];
if(_res->getParam("BrokerName",param) == 0){
_host = strdup(param);
}
if(_res->getParam("BrokerPortNo",param) == 0){
_service =strdup( param);
}
_light = _res->getLightIndicator();
while(true){
uint16_t length = 0;
memset(_buffer, 0, SOCKET_MAXBUFFER_LENGTH);
ev = _res->getBrokerSendQue()->wait();
clnode = ev->getClientNode();
srcMsg = clnode->getBrokerSendMessage();
if(srcMsg->getType() == MQTT_TYPE_PUBLISH){
MQTTPublish* msg = static_cast<MQTTPublish*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(BLUE_FORMAT, currentDateTime(), "PUBLISH", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_PUBACK){
MQTTPubAck* msg = static_cast<MQTTPubAck*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(GREEN_FORMAT, currentDateTime(), "PUBACK", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_PUBREL){
MQTTPubRel* msg = static_cast<MQTTPubRel*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(GREEN_FORMAT, currentDateTime(), "PUBREL", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_PINGREQ){
MQTTPingReq* msg = static_cast<MQTTPingReq*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(FORMAT, currentDateTime(), "PINGREQ", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_SUBSCRIBE){
MQTTSubscribe* msg = static_cast<MQTTSubscribe*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(FORMAT, currentDateTime(), "SUBSCRIBE", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_UNSUBSCRIBE){
MQTTUnsubscribe* msg = static_cast<MQTTUnsubscribe*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(FORMAT, currentDateTime(), "UNSUBSCRIBE", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_CONNECT){
MQTTConnect* msg = static_cast<MQTTConnect*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(FORMAT, currentDateTime(), "CONNECT", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
clnode->connectSended();
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
}else if(srcMsg->getType() == MQTT_TYPE_DISCONNECT){
MQTTDisconnect* msg = static_cast<MQTTDisconnect*>(srcMsg);
length = msg->serialize(_buffer);
LOGWRITE(FORMAT, currentDateTime(), "DISCONNECT", RIGHTARROW, GREEN_BROKER, msgPrint(msg));
if(send(clnode, length) == 0){
LOGWRITE(SEND_COMPLETE);
}
clnode->getStack()->disconnect();
}
delete ev;
}
}
enum Result CrocUnpack(const char *dirname, const char *fsname, const char *outputpath, const char *listname, enum ENDIAN endian)
{
FILE *fDir, *fArc, *fList, *fOut;
if (!OpenFile(&fDir, dirname, OPENFILEREAD))
return FILENOTFOUND;
if (!OpenFile(&fArc, fsname, OPENFILEREAD))
return FILENOTFOUND;
size_t fSize = GetFileSize(fDir);
if (fSize < 4 || EndianSwap(fSize) < 4)
return FILECORRUPTED;
unsigned int entries;
fread(&entries, 1, sizeof(entries), fDir);
if (endian == ENOTSET)
{
msgPrint(MsgLv_Warning, "Endian not specified.\n");
if (entries > 0x7FFFF)
{
msgPrint(MsgLv_Info, "Endian set to %s.\n", "BIG (Saturn ver.)");
endian = EBIG;
}
else
{
msgPrint(MsgLv_Info, "Endian set to %s.\n", "LITTLE (PS1 ver.)");
endian = ELITTLE;
}
}
if (endian == EBIG)
entries = EndianSwap(entries);
size_t expectedSize = sizeof(struct CrocFsEntry) * entries + 8;
if (fSize != expectedSize)
{
if (fSize != entries + 8)
{
msgPrint(MsgLv_Error, "%s seems to be corrupted.");
return FILECORRUPTED;
}
else
{
msgPrint(MsgLv_Info, "Found Croc v0.12 format.\n");
entries /= sizeof(struct CrocFsEntry);
msgPrint(MsgLv_Warning, "Format not yet supported. Extraction aborted.\n");
return FILECORRUPTED;
}
}
if (!OpenFile(&fList, listname, OPENFILECREATE))
return FILENOTCREATED;
char outpath[MAX_PATH];
char tmp[MAX_PATH];
tmp[0xC] = '\0';
_mkdir(outputpath);
size_t fsLen = GetFileSize(fArc);
for(unsigned int i = 0; i < entries; i++)
{
struct CrocFsEntry entry;
fread(&entry, sizeof(struct CrocFsEntry), 1, fDir);
memcpy(tmp, entry.name, 0xC);
msgPrint(MsgLv_Message, "Unpacking %s\n", tmp);
sprintf(outpath, "%s\\%s", outputpath, tmp);
if (endian == EBIG)
{
entry.pos = EndianSwap(entry.pos);
entry.size = EndianSwap(entry.size);
}
if (entry.pos + entry.size > fsLen)
{
msgPrint(MsgLv_Warning, "%s position exceed file system's length; it will not be extracted.\n", tmp);
continue;
}
if (!OpenFile(&fOut, outpath, OPENFILECREATE))
return FILENOTCREATED;
if (entry.size > 0x7FFFFF)
msgPrint(MsgLv_Warning, "%s file size %iKB?\n", entry.size);
fseek(fArc, entry.pos, SEEK_SET);
FileCopy(fOut, fArc, entry.size);
fclose(fOut);
fprintf(fList, "%s\n", tmp);
}
fclose(fList);
return NOERRORS;
}
