ClientNode* ClientList::createNode(bool secure, NWAddress64* addr64, uint16_t addr16, string* nodeId){
if(_clientCnt < MAX_CLIENT_NODES && !_authorize){
_mutex.lock();
vector<ClientNode*>::iterator client = _clientVector->begin();
while( client != _clientVector->end()){
if(((*client)->getAddress64Ptr() == addr64) && ((*client)->getAddress16() == addr16)){
return 0;
}else{
++client;
}
}
ClientNode* node = new ClientNode(secure);
node->setClientAddress64(addr64);
node->setClientAddress16(addr16);
if (nodeId){
node->setNodeId(nodeId);
}
_clientVector->push_back(node);
_clientCnt++;
_mutex.unlock();
return node;
}else{
return getClient(addr64, addr16);
}
}
ClientNode* ClientList::createNode(NWAddress64* addr64, uint16_t addr16, string* nodeId){
if(_clientCnt < MAX_CLIENT_NODES && !_authorize){
_mutex.lock();
vector<ClientNode*>::iterator client = _clientVector->begin();
while( client != _clientVector->end())
{
//printf("\ngetAddress16(): %x\n",(*client)->getAddress16());
//printf("\naddr16\n: %x", addr16);
if( (*client)->getAddress16() == addr16 ){
return 0;
}else{
++client;
}
}
//printf("\r\nCreate client node");
ClientNode* node = new ClientNode();
node->setClientAddress64(addr64);
node->setClientAddress16(addr16);
if (nodeId){
node->setNodeId(nodeId);
}
_clientVector->push_back(node);
_clientCnt++;
_mutex.unlock();
return node;
}else{
return getClient(addr16);
}
}
/**
* 处理连接的释放
* \param socket 连接对象
*/
void DealClose::handleClose(Socket *socket)
{
ENTER_FUNCTION
_mutex.lock();
ClientNode * client = theClient.addRemoteClient("request");
if (client)
{
if (socket == client->getSocket())
{
printf("xxx");
}
}
_mutex.unlock();
}
void ClientSendTask::run(){
#ifdef NETWORK_XBEE
XBeeConfig config;
config.baudrate = B57600;
config.device = _res->getArgv('d');
config.flag = O_WRONLY;
_res->getClientList()->authorize(FILE_NAME_CLIENT_LIST);
_network = new Network();
if(_network->initialize(config) < 0){
THROW_EXCEPTION(ExFatal, ERRNO_SYS_02, "can't open the client port."); // ABORT
}
#endif
#ifdef NETWORK_UDP
_network = _res->getNetwork();
#endif
#ifdef NETWORK_XXXXX
_network = _res->getNetwork();
#endif
while(true){
Event* ev = _res->getClientSendQue()->wait();
if(ev->getEventType() == EtClientSend){
MQTTSnMessage msg = MQTTSnMessage();
ClientNode* clnode = ev->getClientNode();
msg.absorb( clnode->getClientSendMessage() );
_network->unicast(clnode->getAddress64Ptr(), clnode->getAddress16(),
msg.getMessagePtr(), msg.getMessageLength());
}else if(ev->getEventType() == EtBroadcast){
MQTTSnMessage msg = MQTTSnMessage();
msg.absorb( ev->getMqttSnMessage() );
_network->broadcast(msg.getMessagePtr(), msg.getMessageLength());
}
delete ev;
/*uint8_t a = 0x88;
printf("No to unicast");
_network->unicast(0, (uint16_t)0x1234, &a, 2);*/
}
}
ClientNode * ClientManager::addRemoteClient(const char *name)
{
for (CLIENTS_ITER iter = _clients.begin(); iter != _clients.end();++iter)
{
ClientNode *client = *iter;
if (client && client->name == name)
{
return client;
}
}
ClientNode *client = new ClientNode();
client->name = name;
client->getSocket()->setHandle(::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP));
_clients.push_back(client);
if (this->pool)
this->pool->addSocket(client->getSocket());
return client;
}
int NetLib::clientStart(ServerNode* stub,script::tixmlCodeNode * node)
{
if (!stub || !node) return 0;
int id = 0;
std::string ip = node->getAttr("ip");
WORD port = 0;
node->getAttr("id",id);
const char *name = node->getAttr("name");
node->getAttr("port",port);
std::string type = node->getAttr("type");
if (id == 0)
{
if (type == "local")
{
ClientNode * client = theClient.addLocalClient(name);
if (client)
{
client->useLocal();
}
return 1;
}
ClientNode * client = theClient.addRemoteClient(name);
if (client)
{
if (!client->connect(ip.c_str(),port))
{
//client->useLocal();
client->getSocket()->setInvalid();
printf("服务器连接失败 %s:%u \n",ip.c_str(),port);
return 0;
}
else
{
stTestCmd testCmd;
cmd::Stream ss = testCmd.toStream();
client->getSocket()->sendPacket(ss.content(),ss.size());
printf("服务器连接成功<%s:%u>\n",ip.c_str(),port);
return 1;
}
}
else
{
printf("该类型的连接不存在:%d\n",id);
}
}
return 0;
}
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;
}
}
void ClientSendTask::run(){
NETWORK_CONFIG config;
#ifdef NETWORK_XBEE
char param[TOMYFRAME_PARAM_MAX];
bool secure = true;
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_WRONLY;
if(_res->getParam("SerialDevice", param) == 0){
config.device = strdup(param);
}
if(_res->getParam("SecureConnection",param) == 0){
if(strcmp(param, "YES")){
secure = false; // TCP
}
}
_res->getClientList()->authorize(FILE_NAME_CLIENT_LIST, secure);
_network = new Network();
if(_network->initialize(config) < 0){
THROW_EXCEPTION(ExFatal, ERRNO_APL_01, "can't open the client port."); // ABORT
}
#endif
#ifdef NETWORK_UDP
_network = _res->getNetwork();
#endif
#ifdef NETWORK_XXXXX
_network = _res->getNetwork();
#endif
while(true){
Event* ev = _res->getClientSendQue()->wait();
if(ev->getEventType() == EtClientSend){
MQTTSnMessage msg = MQTTSnMessage();
ClientNode* clnode = ev->getClientNode();
msg.absorb( clnode->getClientSendMessage() );
_network->unicast(clnode->getAddress64Ptr(), clnode->getAddress16(),
msg.getMessagePtr(), msg.getMessageLength());
}else if(ev->getEventType() == EtBroadcast){
MQTTSnMessage msg = MQTTSnMessage();
msg.absorb( ev->getMqttSnMessage() );
_network->broadcast(msg.getMessagePtr(), msg.getMessageLength());
}
delete ev;
}
}
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 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;
}
}
int ServerNodePort::waitNodeConnection()
{
int sock = 0;
sock = NodeNetwork::setupServerSocket(this->mpOwner->mpServerAddress, this->mpOwner->mServerPort);
if (sock < 0)
{
LOGE("Server Socket Setup Failure\n");
return sock;
}
int loop = 1;
while (loop == 1)
{
ClientAddress_t addr;
char logFileName[LOG_FILE_NAME_LENGTH];
memset(logFileName, 0, LOG_FILE_NAME_LENGTH);
int client = NodeNetwork::acceptOnSocket(sock, &addr);
// Create IP string
char clientName[NODE_NAME_LENGTH+1];
sprintf(clientName, "%s", addr.ipstr);
#if (USE_IP_CHECKER == 1)
char IP_CHECK[NODE_NAME_LENGTH+1];
sprintf(IP_CHECK, "%s", addr.ipstr);
char *host = strtok(IP_CHECK, ".");
host = strtok(NULL, ".");
host = strtok(NULL, ".");
host = strtok(NULL, ".");
if (strcmp(host, "0") == 0)
{
LOGW("Illegal Connection: %s", clientName);
close(sock);
close(client);
sleep(2);
sock = NodeNetwork::setupServerSocket(this->mpOwner->mpServerAddress, this->mpOwner->mServerPort);
if (sock < 0)
{
LOGE("Server Socket Setup Failure\n");
return sock;
}
continue;
}
#endif
char dirPath[LOG_FILE_NAME_LENGTH];
memset(dirPath, 0, LOG_FILE_NAME_LENGTH);
sprintf(dirPath, "%s/%s", (char *)LOCK_DIR, clientName);
int fd = open(dirPath, O_RDWR, 0755);
if (fd < 0)
{
fd = creat(dirPath, 0755);
close(fd);
}
else
{
close(fd);
continue;
}
#if (USE_NODE_CREATION_THREAD == 1)
ClientNodeArgument *pArg = new ClientNodeArgument;
pArg->sock = client;
memset(pArg->clientName, 0, NODE_NAME_LENGTH+1);
strcpy(pArg->clientName, clientName);
pArg->pOwner = this->mpOwner;
pArg->gid = this->mpOwner->getGID()+1;
this->mpOwner->setGID(pArg->gid);
//pArg->gid = ++gGlobalClientID;
ThreadHelper::run(createClientNodeThread, pArg, TRUE);
#else
// Send IP string
NodeNetwork::sendToSocket(client, clientName, NODE_NAME_LENGTH);
// Receive Private IP_Public IP
NodeNetwork::receiveFromSocket(client, clientName, NODE_NAME_LENGTH);
sprintf(logFileName, "%s", clientName);
LOGI("New Client Node Accepted: %s", clientName);
// Register End.
ClientNode* pClientNode;
pClientNode = new ClientNode(client, clientName, this->mpOwner);
pClientNode->prepare(logFileName);
unlink(dirPath);
#endif
}
return sock;
}
void* createClientNodeThread(void *pArg)
{
int sent = 0;
ClientNodeArgument *pNodeArg = (ClientNodeArgument *)pArg;
char logFileName[LOG_FILE_NAME_LENGTH];
char dirPath[LOG_FILE_NAME_LENGTH];
memset(dirPath, 0, LOG_FILE_NAME_LENGTH);
sprintf(dirPath, "%s/%s", (char *)LOCK_DIR, pNodeArg->clientName);
memset(logFileName, 0, LOG_FILE_NAME_LENGTH);
// Send IP string
sent = NodeNetwork::sendToSocket(pNodeArg->sock, pNodeArg->clientName, NODE_NAME_LENGTH);
if (sent <= 0)
{
delete pNodeArg;
return NULL;
}
// Receive Private IP_Public IP
int tempLength = NODE_NAME_LENGTH + 1 + strlen(NBUS_PACKET_START_CODE);
char tempBuffer[tempLength];
sent = NodeNetwork::receiveFromSocket(pNodeArg->sock, tempBuffer, tempLength-1);
if (strncmp(NBUS_PACKET_START_CODE, tempBuffer, strlen(NBUS_PACKET_START_CODE)))
{
LOGE("Invalid Client Accepted");
delete pNodeArg;
return NULL;
}
//sent = NodeNetwork::receiveFromSocket(pNodeArg->sock, pNodeArg->clientName, NODE_NAME_LENGTH);
if (sent <= 0)
{
delete pNodeArg;
return NULL;
}
strncpy(pNodeArg->clientName, tempBuffer + strlen(NBUS_PACKET_START_CODE), NODE_NAME_LENGTH);
snprintf(logFileName, NODE_NAME_LENGTH, "%s", pNodeArg->clientName);
LOGI("New Client Node Accepted: %s", pNodeArg->clientName);
ClientNode* pClientNode;
pClientNode = new ClientNode(pNodeArg->sock, pNodeArg->clientName, pNodeArg->pOwner);
if (pClientNode->getGID() == 0)
{
pClientNode->setGID(pNodeArg->gid);
}
pClientNode->prepare(logFileName);
unlink(dirPath);
delete pNodeArg;
return NULL;
}
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;
}
}
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;
}
}
}
}
