Blinker

@@ -21,6 +21,12 @@

       read.

       The frames received from this stream are sent over the network.

     </p>

+    <h3>Protocol</h3>

+    <p>

+      The protcol to use is configured in the file <code>protocol</code>.

+      It can contain the string <code>blp</code>, <code>eblp</code> or

+      <code>mcuf</code> to select the BLP, EBLP or MCUF protocol respectively.

+    </p>

     <h3>Bind Address</h3>

     <p>

       The file <code>bind</code> contains the local address to bind to.

@@ -31,14 +37,13 @@

     </p>

     <h3>Static Destinations</h3>

     <p>

-      Static destinations to supply with a network stream in BLP, EBLP

-      or MCUF protocol can be configured in the subdirectories

-      <code>blp</code>, <code>eblp</code> and <code>mcuf</code> respectively.

+      Static destinations to supply with a network stream in the configured

+      protocol can be configured in the subdirectory <code>destinations</code>.

       Each static destination is configured in an own subdirectory.

-      E.g. the configurations for static MCUF destinations with name

+      E.g. the configuration for a static destination with name

       <code>local</code> resides in the subdirectory

-      <code>mcuf/local</code>.

+      <code>destinations/local</code>.

     </p>

     <p>

       The configuration inside a static destination consists of the following

@@ -0,0 +1 @@

+mcuf

@@ -0,0 +1 @@

+mcuf

@@ -0,0 +1 @@

+mcuf

@@ -0,0 +1,57 @@

+/* Blinker

+   Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>

+   Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html

+   a blinkenarea.org project */

+

+#include <sstream>

+#include <string>

+

+#include "Protocol.h"

+

+namespace Blinker {

+

+/// constructor

+Protocol::Protocol():

+  m_proto(BlinkenProtoNone)

+{

+}

+

+/**

+ * @brief parse from string format

+ * @param[in] str string format

+ * @return if parsing was successful

+ */

+bool Protocol::fromStr(const std::string &str)

+{

+  if (str == "blp") {

+    m_proto = BlinkenProtoBlp;

+    return true;

+  }

+  else if (str =="eblp") {

+    m_proto = BlinkenProtoEblp;

+    return true;

+  }

+  else if (str =="mcuf") {

+    m_proto = BlinkenProtoMcuf;

+    return true;

+  }

+  else

+    return false;

+}

+

+/**

+ * @brief convert to string format

+ * @return string format

+ */

+std::string Protocol::toStr() const

+{

+  switch (m_proto) {

+    case BlinkenProtoBlp: return "blp";

+    case BlinkenProtoEblp: return "eblp";

+    case BlinkenProtoMcuf: return "mcuf";

+    default: return "";

+  }

+}

+

+} // namespace Blinker

+

@@ -0,0 +1,43 @@

+/* Blinker

+   Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>

+   Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html

+   a blinkenarea.org project */

+

+#ifndef PROTOCOL_H

+#define PROTOCOL_H

+

+#include <string>

+

+#include <BlinkenLib/BlinkenProto.h>

+

+namespace Blinker {

+

+/// a Blinken protocol

+class Protocol

+{

+public:

+  /// constructor

+  Protocol();

+

+public:

+  /**

+   * @brief parse from string format

+   * @param[in] str string format

+   * @return if parsing was successful

+   */

+  bool fromStr(const std::string &str);

+

+  /**

+   * @brief convert to string format

+   * @return string format

+   */

+  std::string toStr() const;

+

+public:

+  etBlinkenProto m_proto; ///< protocol

+}; // class Protocol

+

+} // namespace Blinker

+

+#endif // #ifndef PROTOCOL_H

+

@@ -18,6 +18,7 @@

 #include "File.h"

 #include "IoCallee.h"

 #include "Module.h"

+#include "Protocol.h"

 #include "SettingFile.h"

 #include "StreamMgr.h"

 #include "StreamRecv.h"

@@ -94,11 +95,8 @@ public:

   virtual void ioWriteCall(Io *io);

 protected:

-  /**

-   * @brief free static destiation list

-   * @param[in] destList static destination list to free

-   */

-  void freeDestList(DestList &destList);

+  /// (re-)read protocol

+  void readProto();

   /// get input stream and attach to it

   void getInStream();

@@ -115,19 +113,14 @@ protected:

   /**

    * @brief light update of static destinations,

    *        i.e. stat all files in current static destination directory

-   * @param[in] destList static destinations for protocol

    */

-  void updateDestsLight(DestList &destList);

+  void updateDestsLight();

   /**

    * @brief full update of static destinations,

    *        i.e. scan files in playlist directory

-   * @param[in] dirDests static destinations directory for protocol

-   * @param[in] destList static destinations for protocol

-   * @param[in] pNoFrameData "no frame" protocol data

    */

-  void updateDestsFull(Directory &dirDests, DestList &destList,

-                       const std::string *pNoFrameData);

+  void updateDestsFull();

   /// remove timed-out dynamic destinations

   void removeTimedOutDynDests();

@@ -141,15 +134,12 @@ protected:

   /**

    * @brief send data to static/dynamic destinations

    * @param[in] data *pData protocol data to send

-   * @param[in] destList static destinations

-   * @param[in] dynDests dynamic destinations

    */

-  void sendDests(const std::string *pData, const DestList destList,

-                 const DynDests dynDests);

+  void sendDests(const std::string *pData);

   /**

    * @brief send protocol data to address

-   * @param[in] data protcol data of frame

+   * @param[in] data protcol data of frame (empty if unknown)

    * @param[in] addr address to send to

    */

   void sendProto(const std::string &data, const ADDR &addr) const;

@@ -157,11 +147,9 @@ protected:

   /**

    * @brief convert frame to protocol data

    * @param[in] pFrame frame (NULL for none)

-   * @param[in] proto Blinken protocol identifier

    * @param[out] data protcol data

    */

-  static void frame2data(stBlinkenFrame *pFrame, etBlinkenProto proto,

-                         std::string &data);

+  void frame2data(stBlinkenFrame *pFrame, std::string &data) const;

   /// receive data from socket

   void receiveFromSock();

@@ -169,24 +157,17 @@ protected:

 protected:

   SettingFile m_fileInStream; ///< input stream name file

   SettingFile m_fileBind;     ///< bind address file

-  Directory   m_dirDestsBlp;     ///< static BLP destinations directory

-  Directory   m_dirDestsEblp;    ///< static EBLP destinations directory

-  Directory   m_dirDestsMcuf;    ///< static MCUF destinations directory

+  SettingFile m_fileProtocol; ///< protocol file

+  Directory   m_dirDests;     ///< static destinations directory

   std::string m_nameInStream; ///< name of input stream

   Stream      *m_pInStream;   ///< input stream

   SOCK        *m_pSock;       ///< socket to use for sending streams

-  DestList    m_destListBlp;     ///< static BLP destinations

-  DestList    m_destListEblp;    ///< static EBLP destinations

-  DestList    m_destListMcuf;    ///< static MCUF destinations

-  DynDests    m_dynDestsBlp;     ///< dynamic BLP destinations

-  DynDests    m_dynDestsEblp;    ///< dynamic EBLP destinations

-  DynDests    m_dynDestsMcuf;    ///< dynamic MCUF destinations

-  std::string m_noFrameDataBlp;  ///< "no frame" BLP protocol data

-  std::string m_noFrameDataEblp; ///< "no frame" EBLP protocol data

-  std::string m_noFrameDataMcuf; ///< "no frame" MCUF protocol data

-  std::string m_dataBlp;         ///< current BLP protocol data

-  std::string m_dataEblp;        ///< current BLP protocol data

-  std::string m_dataMcuf;        ///< current BLP protocol data

+  Protocol    m_protocol;     ///< protocol

+  bool        m_haveProtocol; ///< if protocol is known

+  DestList    m_destList;     ///< static destinations

+  DynDests    m_dynDests;     ///< dynamic destinations

+  std::string m_noFrameData;  ///< "no frame" protocol data (empty if unknown)

+  std::string m_data;         ///< current protocol data (empty if unknown)

 }; // class Sender

 } // namespace Blinker

@@ -26,6 +26,7 @@ public:

    * @param[in] sender owning sender object

    * @param[in] dirBase base directory

    * @param[in] pNoFrameData protocol data for "no frame" packet

+   *                         (empty if unknown)

    */

   Dest(Sender &sender, const Directory &dirBase,

        const std::string *pNoFrameData);

@@ -46,7 +47,7 @@ public:

   /**

    * @brief set current protocol data

-   * @param[in] pData protocol data to send to address

+   * @param[in] pData protocol data to send to address (empty if unkown)

    */

   void setProtoData(const std::string *pData);

@@ -56,7 +57,7 @@ protected:

   /**

    * @brief send protocol data to address

-   * @param[in] pData protocol data to send to address

+   * @param[in] pData protocol data to send to address (empty if unknown)

    */

   void send(const std::string *pData);

@@ -22,6 +22,7 @@ namespace Blinker {

  * @param[in] sender owning sender object

  * @param[in] dirBase base directory

  * @param[in] pNoFrameData protocol data for "no frame" packet

+ *                         (empty if unknown)

  */

 template<typename ADDR, typename SOCK>

 Sender<ADDR, SOCK>::Dest::Dest(Sender &sender, const Directory &dirBase,

@@ -55,7 +56,7 @@ void Sender<ADDR, SOCK>::Dest::updateConfig()

 /**

  * @brief set current protocol data

- * @param[in] pData protocol data to send to address

+ * @param[in] pData protocol data to send to address (empty if unknown)

  */

 template<typename ADDR, typename SOCK>

 void Sender<ADDR, SOCK>::Dest::setProtoData(const std::string *pData)

@@ -85,12 +86,12 @@ void Sender<ADDR, SOCK>::Dest::getAddr()

 /**

  * @brief send protocol data to address

- * @param[in] pData protocol data to send to address

+ * @param[in] pData protocol data to send to address (empty if unknown)

  */

 template<typename ADDR, typename SOCK>

 void Sender<ADDR, SOCK>::Dest::send(const std::string *pData)

 {

-  if (m_sender.m_pSock && m_haveAddr && pData)

+  if (m_sender.m_pSock && m_haveAddr && !pData->empty())

     m_sender.m_pSock->send(*pData, m_addr);

 }

@@ -18,6 +18,7 @@

 #include "File.h"

 #include "IoCallee.h"

 #include "Module.h"

+#include "Protocol.h"

 #include "Sender.h"

 #include "SenderDest.h"

 #include "SenderDest_impl.h"

@@ -41,19 +42,14 @@ Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,

   Module(callMgr, streamMgr, dirBase),

   m_fileInStream(dirBase.getFile("instream")),

   m_fileBind(dirBase.getFile("bind")),

-  m_dirDestsBlp(dirBase.getSubdir("blp")),

-  m_dirDestsEblp(dirBase.getSubdir("eblp")),

-  m_dirDestsMcuf(dirBase.getSubdir("mcuf")),

+  m_fileProtocol(dirBase.getFile("protocol")),

+  m_dirDests(dirBase.getSubdir("destinations")),

   m_pInStream(NULL),

-  m_pSock(NULL)

+  m_pSock(NULL),

+  m_haveProtocol(false)

 {

-  // initialize protocol data buffers

-  frame2data(NULL, BlinkenProtoBlp, m_noFrameDataBlp);

-  frame2data(NULL, BlinkenProtoEblp, m_noFrameDataEblp);

-  frame2data(NULL, BlinkenProtoMcuf, m_noFrameDataMcuf);

-  m_dataBlp = m_noFrameDataBlp;

-  m_dataEblp = m_noFrameDataEblp;

-  m_dataMcuf = m_noFrameDataMcuf;

+  // read protocol

+  readProto();

   // get input stream and attach to it

   getInStream();

@@ -61,9 +57,7 @@ Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,

   createSock();

   // load static destinations

-  updateDestsFull(m_dirDestsBlp, m_destListBlp, &m_noFrameDataBlp);

-  updateDestsFull(m_dirDestsEblp, m_destListEblp, &m_noFrameDataEblp);

-  updateDestsFull(m_dirDestsMcuf, m_destListMcuf, &m_noFrameDataMcuf);

+  updateDestsFull();

 }

 /// virtual destructor

@@ -74,9 +68,10 @@ Sender<ADDR, SOCK>::~Sender()

   sendAllNoFrame();

   // free static destination lists

-  freeDestList(m_destListBlp);

-  freeDestList(m_destListEblp);

-  freeDestList(m_destListMcuf);

+  while (!m_destList.empty()) {

+    delete m_destList.back().m_pDest;

+    m_destList.pop_back();

+  }

   // destroy socket

   destroySock();

@@ -102,20 +97,16 @@ void Sender<ADDR, SOCK>::updateConfig()

     createSock();

   }

+  // protocol file was modified -> re-read protocol

+  if (m_fileProtocol.checkModified())

+    readProto();

+

   // static destinations update

   // (directory modified -> full, otherwise -> light)

-  if (m_dirDestsBlp.checkModified())

-    updateDestsFull(m_dirDestsBlp, m_destListBlp, &m_noFrameDataBlp);

-  else

-    updateDestsLight(m_destListBlp);

-  if (m_dirDestsEblp.checkModified())

-    updateDestsFull(m_dirDestsEblp, m_destListEblp, &m_noFrameDataEblp);

+  if (m_dirDests.checkModified())

+    updateDestsFull();

   else

-    updateDestsLight(m_destListEblp);

-  if (m_dirDestsMcuf.checkModified())

-    updateDestsFull(m_dirDestsMcuf, m_destListMcuf, &m_noFrameDataMcuf);

-  else

-    updateDestsLight(m_destListMcuf);

+    updateDestsLight();

 }

 /**

@@ -128,9 +119,7 @@ void Sender<ADDR, SOCK>::setFrame(const std::string &stream,

                                   stBlinkenFrame *pFrame)

 {

   // convert new frame to protocol data

-  frame2data(pFrame, BlinkenProtoBlp, m_dataBlp);

-  frame2data(pFrame, BlinkenProtoEblp, m_dataEblp);

-  frame2data(pFrame, BlinkenProtoMcuf, m_dataMcuf);

+  frame2data(pFrame, m_data);

   // send new protocol data to all destinations

   sendAllProto();

@@ -168,17 +157,40 @@ void Sender<ADDR, SOCK>::ioWriteCall(Io *io)

   (void)io; // unused

 }

-/**

- * @brief free static destiation list

- * @param[in] destList static destination list to free

- */

+/// (re-)read protocol

 template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::freeDestList(DestList &destList)

+void Sender<ADDR, SOCK>::readProto()

 {

-  while (!destList.empty()) {

-    delete destList.back().m_pDest;

-    destList.pop_back();

+  std::string strProto;

+  stBlinkenFrame *pFrame;

+

+  // send "no frame" to all destinations

+  // (stream with old protocol will stop now)

+  sendAllNoFrame();

+

+  // clear dynamic destinations

+  // (they registered with old protocol, which is out of service now)

+  m_dynDests.clear();

+

+  // clear old frame data and old no frame data

+  m_noFrameData.clear();

+  m_data.clear();

+

+  // read new protocol from file

+  m_haveProtocol = m_fileProtocol.getStr(strProto) &&

+                   m_protocol.fromStr(strProto);

+

+  // create new no frame protocol data and new protocol data

+  if (m_haveProtocol) {

+    frame2data(NULL, m_noFrameData);

+    pFrame = NULL;

+    if (m_pInStream)

+      m_pInStream->getCurFrame(pFrame);

+    frame2data(pFrame, m_data);

   }

+

+  // send current protocol data to all destinations

+  sendAllProto();

 }

 /// get input stream and attach to it

@@ -235,8 +247,11 @@ void Sender<ADDR, SOCK>::createSock()

     return;

   }

-  // request callback on recpetion

+  // request callback on recepetion

   m_callMgr.requestIoReadCall(this, m_pSock);

+

+  // send current protocol data to all destinations

+  sendAllProto();

 }

 /// destroy socket

@@ -249,9 +264,7 @@ void Sender<ADDR, SOCK>::destroySock()

   // clear dynamic destinations

   // (they registered with this socket and this socket is gone)

-  m_dynDestsBlp.clear();

-  m_dynDestsEblp.clear();

-  m_dynDestsMcuf.clear();

+  m_dynDests.clear();

   // cancel callback request

   m_callMgr.cancelIoReadCall(this, m_pSock);

@@ -266,49 +279,43 @@ void Sender<ADDR, SOCK>::destroySock()

 /**

  * @brief light update of static destinations,

  *        i.e. stat all files in current static destination directory

- * @param[in] destList static destinations for one protocol

  */

 template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::updateDestsLight(DestList &destList)

+void Sender<ADDR, SOCK>::updateDestsLight()

 {

   // walk through all files in static dest dir and check for modification

   typename DestList::iterator itDest;

-  for (itDest = destList.begin(); itDest != destList.end(); ++itDest)

+  for (itDest = m_destList.begin(); itDest != m_destList.end(); ++itDest)

     itDest->m_pDest->updateConfig();

 }

 /**

  * @brief full update of static destinations,

  *        i.e. scan files in playlist directory

- * @param[in] dirDests static destinations directory for protocol

- * @param[in] destList static destinations for protocol

- * @param[in] pNoFrameData "no frame" protocaol data

  */

 template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::updateDestsFull(Directory &dirDests,

-                                         DestList &destList,

-                                         const std::string *pNoFrameData)

+void Sender<ADDR, SOCK>::updateDestsFull()

 {

   // get list of subdirs in input directory

   typedef std::list<std::string> Subdirlist;

   Subdirlist curSubdirs;

-  dirDests.getEntries(Directory::TypeSubdir, curSubdirs);

+  m_dirDests.getEntries(Directory::TypeSubdir, curSubdirs);

   // walk through current static destinations and subdir list simultaneously

   Subdirlist::const_iterator  itSubdir = curSubdirs.begin();

-  typename DestList::iterator itDest   = destList.begin();

-  while (itSubdir != curSubdirs.end() || itDest != destList.end()) {

+  typename DestList::iterator itDest   = m_destList.begin();

+  while (itSubdir != curSubdirs.end() || itDest != m_destList.end()) {

     // new static destination inserted

-    if (itDest == destList.end() ||

+    if (itDest == m_destList.end() ||

         (itSubdir != curSubdirs.end() && *itSubdir < itDest->m_name)) {

       // create static destination object

       DestEntry destEntry(*itSubdir);

-      destEntry.m_pDest = new Dest(*this, dirDests.getSubdir(*itSubdir),

-                                   pNoFrameData);

+      destEntry.m_pDest = new Dest(*this, m_dirDests.getSubdir(*itSubdir),

+                                   &m_noFrameData);

       if (destEntry.m_pDest)

         // insert static destination entry

-        destList.insert(itDest, destEntry);

+        m_destList.insert(itDest, destEntry);

       // advance to next subdir

       ++itSubdir;

     }

@@ -317,7 +324,7 @@ void Sender<ADDR, SOCK>::updateDestsFull(Directory &dirDests,

     else if (itSubdir == curSubdirs.end() || *itSubdir > itDest->m_name) {

       // remove static destination

       delete itDest->m_pDest;

-      itDest = destList.erase(itDest);

+      itDest = m_destList.erase(itDest);

       // do not advance to next subdir

     }

@@ -343,19 +350,9 @@ void Sender<ADDR, SOCK>::removeTimedOutDynDests()

   now = Time::now();

   timeout = Time(30);

-  for (itDyn = m_dynDestsBlp.begin(); itDyn != m_dynDestsBlp.end(); )

-    if (itDyn->second + timeout < now)

-      m_dynDestsBlp.erase(itDyn++);

-    else

-      ++itDyn;

-  for (itDyn = m_dynDestsEblp.begin(); itDyn != m_dynDestsEblp.end(); )

-    if (itDyn->second + timeout < now)

-      m_dynDestsEblp.erase(itDyn++);

-    else

-      ++itDyn;

-  for (itDyn = m_dynDestsMcuf.begin(); itDyn != m_dynDestsMcuf.end(); )

+  for (itDyn = m_dynDests.begin(); itDyn != m_dynDests.end(); )

     if (itDyn->second + timeout < now)

-      m_dynDestsMcuf.erase(itDyn++);

+      m_dynDests.erase(itDyn++);

     else

       ++itDyn;

 }

@@ -368,9 +365,7 @@ void Sender<ADDR, SOCK>::sendAllProto()

   removeTimedOutDynDests();

   // send current protocol data to all static/dynamic destinations

-  sendDests(&m_dataBlp, m_destListBlp, m_dynDestsBlp);

-  sendDests(&m_dataEblp, m_destListEblp, m_dynDestsEblp);

-  sendDests(&m_dataMcuf, m_destListMcuf, m_dynDestsMcuf);

+  sendDests(&m_data);

   // request time callback in one second

   m_callMgr.requestTimeCall(this, Time::now() + Time(1));

@@ -384,9 +379,7 @@ void Sender<ADDR, SOCK>::sendAllNoFrame()

   removeTimedOutDynDests();

   // get "no frame" protocol data and send to all static/dynamic destinations

-  sendDests(&m_noFrameDataBlp, m_destListBlp, m_dynDestsBlp);

-  sendDests(&m_noFrameDataEblp, m_destListEblp, m_dynDestsEblp);

-  sendDests(&m_noFrameDataMcuf, m_destListMcuf, m_dynDestsMcuf);

+  sendDests(&m_noFrameData);

   // request time callback in one second

   m_callMgr.requestTimeCall(this, Time::now() + Time(1));

@@ -395,57 +388,57 @@ void Sender<ADDR, SOCK>::sendAllNoFrame()

 /**

  * @brief send data to static/dynamic destinations

  * @param[in] data *pData protocol data to send

- * @param[in] destList static destinations

- * @param[in] dynDests dynamic destinations

  */

 template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendDests(const std::string *pData,

-                                   const DestList destList,

-                                   const DynDests dynDests)

+void Sender<ADDR, SOCK>::sendDests(const std::string *pData)

 {

   // send data to static destinations

   typename DestList::const_iterator itDest;

-  for (itDest = destList.begin(); itDest != destList.end(); ++itDest)

+  for (itDest = m_destList.begin(); itDest != m_destList.end(); ++itDest)

     itDest->m_pDest->setProtoData(pData);

   // send data to all dynamic destinations

   typename DynDests::const_iterator itDyn;

-  for (itDyn = dynDests.begin(); itDyn != dynDests.end(); ++itDyn)

+  for (itDyn = m_dynDests.begin(); itDyn != m_dynDests.end(); ++itDyn)

     sendProto(*pData, itDyn->first);

 }

 /**

  * @brief send protocol data to address

- * @param[in] data protocol data of frame

+ * @param[in] data protocol data of frame (empty if unknown)

  * @param[in] addr address to send to

  */

 template<typename ADDR, typename SOCK>

 void Sender<ADDR, SOCK>::sendProto(const std::string &data,

                                    const ADDR &addr) const

 {

-  if (m_pSock) {

+  if (m_pSock && !data.empty())

     m_pSock->send(data, addr);

 }

-}

 /**

  * @brief convert frame to protocol data

  * @param[in] pFrame frame (NULL for none)

- * @param[in] proto Blinken protocol identifier

  * @param[out] data protocol data

  */

 template<typename ADDR, typename SOCK>

 void Sender<ADDR, SOCK>::frame2data(stBlinkenFrame *pFrame,

-                                    etBlinkenProto proto, std::string &data)

+                                    std::string &data) const

 {

   char buf[65536];

   int len;

+  // no protocol -> leave with empty data

+  if (!m_haveProtocol) {

+    data.clear();

+    return;

+  }

+

   // convert frame to protcol data

   if (pFrame)

-    len = BlinkenFrameToNetwork(pFrame, proto, buf, sizeof(buf));

+    len = BlinkenFrameToNetwork(pFrame, m_protocol.m_proto, buf, sizeof(buf));

   else

-    len = BlinkenProtoMakePacket(proto, BlinkenPacketStreamEnd,

+    len = BlinkenProtoMakePacket(m_protocol.m_proto, BlinkenPacketStreamEnd,

                                  buf, sizeof(buf));

   if (len < 0)

     len = 0;

@@ -472,49 +465,25 @@ void Sender<ADDR, SOCK>::receiveFromSock()

   // detect packet type and protocol

   BlinkenProtoDetectPacket(data.c_str(), data.size(), &proto, &packet);

+  if (m_haveProtocol && proto == m_protocol.m_proto) {

     switch (packet) {

       // request -> add to dynamic destinations and send current frame

       case BlinkenPacketRequest:

-      switch (proto) {

-        case BlinkenProtoBlp:

-          m_dynDestsBlp[addr] = Time::now();

-          sendProto(m_dataBlp, addr);

-          break;

-        case BlinkenProtoEblp:

-          m_dynDestsEblp[addr] = Time::now();

-          sendProto(m_dataEblp, addr);

-          break;

-        case BlinkenProtoMcuf:

-          m_dynDestsMcuf[addr] = Time::now();

-          sendProto(m_dataMcuf, addr);

-          break;

-        default:

-          break;

-      }

+        m_dynDests[addr] = Time::now();

+        sendProto(m_data, addr);

         break;

       // end request -> remove from dynamic destinations

       case BlinkenPacketEndRequest:

-      switch (proto) {

-        case BlinkenProtoBlp:

-          m_dynDestsBlp.erase(addr);

-          break;

-        case BlinkenProtoEblp:

-          m_dynDestsEblp.erase(addr);

-          break;

-        case BlinkenProtoMcuf:

-          m_dynDestsMcuf.erase(addr);

-          break;

-        default:

-          break;

-      }

+        m_dynDests.erase(addr);

         break;

       default:

         break;

     } // switch (packet)

+  } // if (m_haveProtocol ...

 }