MQTTSNGWForwarder.cpp

00001 /**************************************************************************************
00002  * Copyright (c) 2018, Tomoaki Yamaguchi
00003  *
00004  * All rights reserved. This program and the accompanying materials
00005  * are made available under the terms of the Eclipse Public License v1.0
00006  * and Eclipse Distribution License v1.0 which accompany this distribution.
00007  *
00008  * The Eclipse Public License is available at
00009  *    http://www.eclipse.org/legal/epl-v10.html
00010  * and the Eclipse Distribution License is available at
00011  *   http://www.eclipse.org/org/documents/edl-v10.php.
00012  *
00013  * Contributors:
00014  *    Tomoaki Yamaguchi - initial API and implementation and/or initial documentation
00015  **************************************************************************************/
00016 #include "MQTTSNGWForwarder.h"
00017 #include "SensorNetwork.h"
00018 
00019 #include <string.h>
00020 
00021 using namespace MQTTSNGW;
00022 using namespace std;
00023 
00024 /*=====================================
00025      Class ForwarderList
00026  =====================================*/
00027 
00028 ForwarderList::ForwarderList()
00029 {
00030     _head = nullptr;
00031 }
00032 
00033 ForwarderList::~ForwarderList()
00034 {
00035     if ( _head )
00036     {
00037         Forwarder* p = _head;
00038         while ( p )
00039         {
00040             Forwarder* next = p->_next;
00041             delete p;
00042             p = next;
00043         }
00044     }
00045 }
00046 
00047 
00048 void ForwarderList::initialize(Gateway* gw)
00049 {
00050     char param[MQTTSNGW_PARAM_MAX];
00051     string fileName;
00052 
00053     if (gw->getParam("Forwarder", param) == 0 )
00054     {
00055         if (!strcasecmp(param, "YES") )
00056         {
00057             gw->getClientList()->setClientList(FORWARDER_TYPE);
00058         }
00059     }
00060 }
00061 
00062 
00063 Forwarder* ForwarderList::getForwarder(SensorNetAddress* addr)
00064 {
00065     Forwarder* p = _head;
00066     while ( p )
00067     {
00068         if ( p->_sensorNetAddr.isMatch(addr) )
00069         {
00070             break;
00071         }
00072         p = p->_next;
00073     }
00074     return p;
00075 }
00076 
00077 Forwarder* ForwarderList::addForwarder(SensorNetAddress* addr,  MQTTSNString* forwarderId)
00078 {
00079     Forwarder* fdr = new Forwarder(addr, forwarderId);
00080     if ( _head == nullptr )
00081     {
00082         _head = fdr;
00083     }
00084     else
00085     {
00086         Forwarder* p = _head;
00087         while ( p )
00088         {
00089             if ( p->_next == nullptr )
00090             {
00091                 p->_next = fdr;
00092                 break;
00093             }
00094             else
00095             {
00096                 p = p->_next;
00097             }
00098         }
00099     }
00100     return fdr;
00101 }
00102 
00103 Forwarder::Forwarder()
00104 {
00105     _headClient = nullptr;
00106     _next = nullptr;
00107 }
00108 
00109 /*=====================================
00110      Class ForwarderList
00111  =====================================*/
00112 
00113 Forwarder::Forwarder(SensorNetAddress* addr,  MQTTSNString* forwarderId)
00114 {
00115     _forwarderName = string(forwarderId->cstring);
00116     _sensorNetAddr = *addr;
00117     _headClient = nullptr;
00118     _next = nullptr;
00119 }
00120 
00121 Forwarder::~Forwarder(void)
00122 {
00123     if ( _headClient )
00124     {
00125         ForwarderElement* p = _headClient;
00126         while ( p )
00127         {
00128             ForwarderElement* next = p->_next;
00129             delete p;
00130             p = next;
00131         }
00132     }
00133 }
00134 
00135 const char* Forwarder::getId(void)
00136 {
00137     return _forwarderName.c_str();
00138 }
00139 
00140 void Forwarder::addClient(Client* client, WirelessNodeId* id)
00141 {
00142     ForwarderElement* p = _headClient;
00143     ForwarderElement* prev = nullptr;
00144 
00145     client->setForwarder(this);
00146 
00147     if ( p != nullptr )
00148     {
00149         while ( p )
00150         {
00151             if ( p->_client == client )
00152             {
00153                 client->setForwarder(this);
00154                 return;
00155             }
00156             prev = p;
00157             p = p->_next;
00158         }
00159     }
00160 
00161     ForwarderElement* fclient = new ForwarderElement();
00162 
00163     fclient->setClient(client);
00164     fclient->setWirelessNodeId(id);
00165 
00166     if ( prev )
00167     {
00168         prev->_next = fclient;
00169     }
00170     else
00171     {
00172         _headClient = fclient;
00173     }
00174 }
00175 
00176 Client* Forwarder::getClient(WirelessNodeId* id)
00177 {
00178     Client* cl = nullptr;
00179     _mutex.lock();
00180     ForwarderElement* p = _headClient;
00181     while ( p )
00182     {
00183         if ( *(p->_wirelessNodeId) == *id )
00184         {
00185             cl = p->_client;
00186             break;
00187         }
00188         else
00189         {
00190             p = p->_next;
00191         }
00192     }
00193     _mutex.unlock();
00194     return cl;
00195 }
00196 
00197 const char* Forwarder::getName(void)
00198 {
00199     return _forwarderName.c_str();
00200 }
00201 
00202 WirelessNodeId* Forwarder::getWirelessNodeId(Client* client)
00203 {
00204     WirelessNodeId* nodeId = nullptr;
00205     _mutex.lock();
00206     ForwarderElement* p = _headClient;
00207     while ( p )
00208     {
00209         if ( p->_client == client )
00210         {
00211             nodeId = p->_wirelessNodeId;
00212             break;
00213         }
00214         else
00215         {
00216             p = p->_next;
00217         }
00218     }
00219     _mutex.unlock();
00220     return nodeId;
00221 }
00222 
00223 void Forwarder::eraseClient(Client* client)
00224 {
00225     ForwarderElement* prev = nullptr;
00226     _mutex.lock();
00227     ForwarderElement* p = _headClient;
00228 
00229     while ( p )
00230     {
00231         if ( p->_client == client )
00232         {
00233             if ( prev )
00234             {
00235                 prev->_next = p->_next;
00236             }
00237             else
00238             {
00239                 _headClient = p->_next;
00240             }
00241             delete p;
00242             break;
00243         }
00244         else
00245         {
00246             p = p->_next;
00247         }
00248     }
00249     _mutex.unlock();
00250 }
00251 
00252 SensorNetAddress* Forwarder::getSensorNetAddr(void)
00253 {
00254     return &_sensorNetAddr;
00255 }
00256 
00257 /*
00258  *    Class ForwardedClient
00259  */
00260 
00261 ForwarderElement::ForwarderElement()
00262     : _client{0}
00263     , _wirelessNodeId{0}
00264     , _next{0}
00265 {
00266 }
00267 
00268 ForwarderElement::~ForwarderElement()
00269 {
00270     if (_wirelessNodeId)
00271     {
00272         delete _wirelessNodeId;
00273     }
00274 }
00275 
00276 void ForwarderElement::setClient(Client* client)
00277 {
00278     _client = client;
00279 }
00280 
00281 void ForwarderElement::setWirelessNodeId(WirelessNodeId* id)
00282 {
00283     if ( _wirelessNodeId == nullptr )
00284     {
00285         _wirelessNodeId = new WirelessNodeId();
00286     }
00287     _wirelessNodeId->setId(id);
00288 }