Blinker

1) /* Blinker
2)    Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>
3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #ifndef SENDER_H
7) #define SENDER_H
8) 
9) #include <list>

10) #include <map>

11) #include <string>
12) 

13) #include <BlinkenLib/BlinkenProto.h>

14) #include <BlinkenLib/BlinkenFrame.h>
15) 
16) #include "CallMgr.h"
17) #include "Directory.h"
18) #include "File.h"

19) #include "IoCallee.h"

20) #include "Module.h"
21) #include "SettingFile.h"
22) #include "StreamMgr.h"
23) #include "StreamRecv.h"

24) #include "Time.h"

25) #include "TimeCallee.h"

26) 
27) namespace Blinker {
28) 
29) /// stream sender
30) template<typename ADDR, typename SOCK>

31) class Sender: public IoCallee, public Module, public StreamRecv,
32)               public TimeCallee

33) {
34) protected:
35)   /// static destination
36)   struct Dest {
37)     std::string m_name; ///< name of static destination
38)     SettingFile m_file; ///< setting file object
39)     ADDR        m_addr; ///< parsed address
40)     Dest(const std::string &name, const File &file); ///< constructor
41)     bool parse();       ///< parse address from current file
42)   };
43) 
44)   /// static destinations
45)   typedef std::list<Dest> Dests;
46) 

47)   /// dynamic destinations: address -> time of last request
48)   typedef std::map<ADDR, Time> DynDests;
49) 

50) public:
51)   /**
52)    * @brief constructor
53)    * @param[in] callMgr callback manager
54)    * @param[in] streamMgr stream manager
55)    * @param[in] dirBase base directory
56)    */
57)   Sender(CallMgr &callMgr, StreamMgr &streamMgr, const Directory &dirBase);
58) 
59)   /// virtual destructor
60)   virtual ~Sender();
61) 
62) private:
63)   /// copy constructor disabled
64)   Sender(const Sender &that);
65) 
66)   /// assignment operator disabled
67)   const Sender & operator=(const Sender &that);
68) 
69) public:
70)   /// check for update of configuration
71)   virtual void updateConfig();
72) 
73)   /**
74)    * @brief set current frame
75)    * @param[in] pFrame current frame
76)    */
77)   virtual void setFrame(stBlinkenFrame *pFrame);
78) 
79)   /// set current frame to none
80)   virtual void setNoFrame();
81) 

82)   /// callback when requsted time reached
83)   virtual void timeCall();
84) 

85)   /**
86)    * @brief callback when I/O object is readable
87)    * @param[in] io I/O object that is readable
88)    */
89)   virtual void ioReadCall(Io *io);
90) 
91)   /**
92)    * @brief callback when I/O object is writable
93)    * @param[in] io I/O object that is writable
94)    */
95)   virtual void ioWriteCall(Io *io);
96) 

97) protected:
98)   /// get input stream and attach to it
99)   void getInStream();
100) 
101)   /// detach from input stream and release it
102)   void releaseInStream();
103) 
104)   /// create socket and bind it
105)   void createSock();
106) 
107)   /// destroy socket
108)   void destroySock();
109) 
110)   /**
111)    * @brief light update of static destinations,
112)    *        i.e. stat all files in current static destination directory

113)    * @param[in] dests static destinations for protocol
114)    * @param[in] proto Blinken protocol identifier

115)    */

116)   void updateDestsLight(Dests &dests, etBlinkenProto proto);

117) 
118)   /**
119)    * @brief full update of static destinations,
120)    *        i.e. scan files in playlist directory

121)    * @param[in] dirDests static destinations directory for protocol
122)    * @param[in] dests static destinations for protocol
123)    * @param[in] proto Blinken protocol identifier

124)    */

125)   void updateDestsFull(Directory &dirDests, Dests &dests,
126)                        etBlinkenProto proto);

127) 

128)   /// remove timed-out dynamic destinations
129)   void removeTimedOutDynDests();
130) 

131)   /**
132)    * @brief send current frame to address
133)    * @param[in] addr address to send to

134)    * @param[in] proto Blinken protocol identifier

135)    */

136)   void sendCurFrame(const ADDR &addr, etBlinkenProto proto) const;

137) 
138)   /**

139)    * @brief send "no frame" to address

140)    * @param[in] addr address to send to

141)    * @param[in] proto Blinken protocol identifier

142)    */

143)   void sendNoFrame(const ADDR &addr, etBlinkenProto proto) const;

144) 
145)   /**

146)    * @brief send frame to address
147)    * @param[in] data protcol data of frame

148)    * @param[in] addr address to send to
149)    */

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

151) 
152)   /**

153)    * @brief convert frame to protocol data

154)    * @param[in] pFrame frame

155)    * @param[in] proto Blinken protocol identifier
156)    * @param[out] data protcol data

157)    */

158)   static void frame2data(stBlinkenFrame *pFrame, etBlinkenProto proto,
159)                          std::string &data);

160) 
161)   /**
162)    * @brief get "no frame" protocol data
163)    * @param[in] proto Blinken protocol identifier
164)    * @param[out] data protcol data
165)    */

166)   static void noFrame2data(etBlinkenProto proto, std::string &data);
167) 
168)   /// receive data from socket
169)   void receiveFromSock();

170) 
171) protected:
172)   SettingFile m_fileInStream; ///< input stream name file
173)   SettingFile m_fileBind;     ///< bind address file

174)   Directory   m_dirDestsBlp;  ///< static BLP destinations directory
175)   Directory   m_dirDestsEblp; ///< static EBLP destinations directory

176)   Directory   m_dirDestsMcuf; ///< static MCUF destinations directory

177)   std::string m_nameInStream; ///< name of input stream
178)   Stream      *m_pInStream;   ///< input stream
179)   SOCK        *m_pSock;       ///< socket to use for sending streams

180)   Dests       m_destsBlp;     ///< static BLP destinations
181)   Dests       m_destsEblp;    ///< static EBLP destinations
182)   Dests       m_destsMcuf;    ///< static MCUF destinations
183)   DynDests    m_dynDestsBlp;  ///< dynamic BLP destinations
184)   DynDests    m_dynDestsEblp; ///< dynamic EBLP destinations
185)   DynDests    m_dynDestsMcuf; ///< dynamic MCUF destinations

186) }; // class Sender
187) 
188) /* ##########
189)    # Sender #
190)    ########## */
191) 
192) /**
193)  * @brief constructor
194)  * @param[in] callMgr callback manager
195)  * @param[in] streamMgr stream manager
196)  * @param[in] dirBase base directory
197)  */
198) template<typename ADDR, typename SOCK>
199) Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,
200)                            const Directory &dirBase):
201)   Module(callMgr, streamMgr, dirBase),
202)   m_fileInStream(dirBase.getFile("instream")),
203)   m_fileBind(dirBase.getFile("bind")),

204)   m_dirDestsBlp(dirBase.getSubdir("blp")),
205)   m_dirDestsEblp(dirBase.getSubdir("eblp")),

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

207)   m_pInStream(NULL),
208)   m_pSock(NULL)
209) {
210)   // get input stream and attach to it
211)   getInStream();
212)   // create and bind socket
213)   createSock();
214) 
215)   // load static destinations

216)   updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);
217)   updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);

218)   updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

219) }
220) 
221) /// virtual destructor
222) template<typename ADDR, typename SOCK>
223) Sender<ADDR, SOCK>::~Sender()
224) {

225)   // send no frame to all destinations
226)   setNoFrame();

227) 
228)   // destroy socket
229)   destroySock();
230)   // detach from input stream and release it
231)   releaseInStream();

232)   // cancel time callback
233)   m_callMgr.cancelTimeCall(this);

234) }
235) 
236) /// check for update of configuration
237) template<typename ADDR, typename SOCK>
238) void Sender<ADDR, SOCK>::updateConfig()
239) {
240)   // input stream name file was modified -> re-get input stream
241)   if (m_fileInStream.checkModified()) {
242)     releaseInStream();
243)     getInStream();
244)   }
245) 
246)   // bind address file was modified -> re-create socket
247)   if (m_fileBind.checkModified()) {
248)     destroySock();
249)     createSock();
250)   }
251) 
252)   // static destinations update
253)   // (directory modified -> full, otherwise -> light)

254)   if (m_dirDestsBlp.checkModified())
255)     updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);
256)   else
257)     updateDestsLight(m_destsBlp, BlinkenProtoBlp);
258)   if (m_dirDestsEblp.checkModified())
259)     updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);
260)   else
261)     updateDestsLight(m_destsEblp, BlinkenProtoEblp);

262)   if (m_dirDestsMcuf.checkModified())
263)     updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

264)   else

265)     updateDestsLight(m_destsMcuf, BlinkenProtoMcuf);

266) }
267) 
268) /**
269)  * @brief set current frame
270)  * @param[in] pFrame current frame
271)  */
272) template<typename ADDR, typename SOCK>
273) void Sender<ADDR, SOCK>::setFrame(stBlinkenFrame *pFrame)
274) {

275)   std::string blp, eblp, mcuf;

276) 

277)   // remove timed-out dynamic destinations
278)   removeTimedOutDynDests();
279) 

280)   // convert frame to protocol data

281)   if (!m_destsBlp.empty() || !m_dynDestsBlp.empty())

282)     frame2data(pFrame, BlinkenProtoBlp, blp);

283)   if (!m_destsEblp.empty() || !m_dynDestsEblp.empty())

284)     frame2data(pFrame, BlinkenProtoEblp, eblp);

285)   if (!m_destsMcuf.empty() || !m_dynDestsMcuf.empty())

286)     frame2data(pFrame, BlinkenProtoMcuf, mcuf);

287) 

288)   // send frame to all static destinations

289)   typename Dests::const_iterator itDest;

290)   for (itDest = m_destsBlp.begin(); itDest != m_destsBlp.end(); ++itDest)
291)     sendFrame(blp, itDest->m_addr);
292)   for (itDest = m_destsEblp.begin(); itDest != m_destsEblp.end(); ++itDest)
293)     sendFrame(eblp, itDest->m_addr);

294)   for (itDest = m_destsMcuf.begin(); itDest != m_destsMcuf.end(); ++itDest)

295)     sendFrame(mcuf, itDest->m_addr);

296) 

297)   // send frame to all dynamic destinations
298)   typename DynDests::const_iterator itDyn;
299)   for (itDyn = m_dynDestsBlp.begin(); itDyn != m_dynDestsBlp.end(); ++itDyn)
300)     sendFrame(blp, itDyn->first);
301)   for (itDyn = m_dynDestsEblp.begin(); itDyn != m_dynDestsEblp.end(); ++itDyn)
302)     sendFrame(eblp, itDyn->first);
303)   for (itDyn = m_dynDestsMcuf.begin(); itDyn != m_dynDestsMcuf.end(); ++itDyn)
304)     sendFrame(mcuf, itDyn->first);
305) 

306)   // request time callback in one second
307)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));

308) }
309) 
310) /// set current frame to none
311) template<typename ADDR, typename SOCK>
312) void Sender<ADDR, SOCK>::setNoFrame()
313) {

314)   std::string blp, eblp, mcuf;

315) 

316)   // remove timed-out dynamic destinations
317)   removeTimedOutDynDests();
318) 

319)   // get "no frame" protocol data

320)   if (!m_destsBlp.empty() || !m_dynDestsBlp.empty())

321)     noFrame2data(BlinkenProtoBlp, blp);

322)   if (!m_destsEblp.empty() || !m_dynDestsEblp.empty())

323)     noFrame2data(BlinkenProtoEblp, eblp);

324)   if (!m_destsMcuf.empty() || !m_dynDestsMcuf.empty())

325)     noFrame2data(BlinkenProtoMcuf, mcuf);
326) 

327)   // send "no frame" to all staticdestinations

328)   typename Dests::const_iterator itDest;

329)   for (itDest = m_destsBlp.begin(); itDest != m_destsBlp.end(); ++itDest)
330)     sendFrame(blp, itDest->m_addr);
331)   for (itDest = m_destsEblp.begin(); itDest != m_destsEblp.end(); ++itDest)
332)     sendFrame(eblp, itDest->m_addr);

333)   for (itDest = m_destsMcuf.begin(); itDest != m_destsMcuf.end(); ++itDest)
334)     sendFrame(mcuf, itDest->m_addr);
335) 

336)   // send frame to all dynamic destinations
337)   typename DynDests::const_iterator itDyn;
338)   for (itDyn = m_dynDestsBlp.begin(); itDyn != m_dynDestsBlp.end(); ++itDyn)
339)     sendFrame(blp, itDyn->first);
340)   for (itDyn = m_dynDestsEblp.begin(); itDyn != m_dynDestsEblp.end(); ++itDyn)
341)     sendFrame(eblp, itDyn->first);
342)   for (itDyn = m_dynDestsMcuf.begin(); itDyn != m_dynDestsMcuf.end(); ++itDyn)
343)     sendFrame(mcuf, itDyn->first);
344) 

345)   // request time callback in one second
346)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));
347) }
348) 
349) /// callback when requsted time reached
350) template<typename ADDR, typename SOCK>
351) void Sender<ADDR, SOCK>::timeCall()
352) {
353)   stBlinkenFrame *pFrame;
354)   std::string data;
355) 
356)   // get current frame from stream
357)   if (m_pInStream && m_pInStream->getCurFrame(pFrame))
358)     // repeat frame - behave exactly like this frame had been set
359)     setFrame(pFrame);
360) 
361)   // no stream of no current frame
362)   else
363)     // repeat "no frame" - behave exactly like "no frame" had been set
364)     setNoFrame();

365) }
366) 

367) /**
368)  * @brief callback when I/O object is readable
369)  * @param[in] io I/O object that is readable
370)  */
371) template<typename ADDR, typename SOCK>
372) void Sender<ADDR, SOCK>::ioReadCall(Io *io)
373) {
374)   // reception on socket
375)   if (io == m_pSock)
376)     receiveFromSock();
377) }
378) 
379) /**
380)  * @brief callback when I/O object is writable
381)  * @param[in] io I/O object that is writable
382)  */
383) template<typename ADDR, typename SOCK>
384) void Sender<ADDR, SOCK>::ioWriteCall(Io *io)
385) {
386)   (void)io; // unused
387) }
388) 

389) /// get input stream and attach to it
390) template<typename ADDR, typename SOCK>
391) void Sender<ADDR, SOCK>::getInStream()
392) {
393)   // get input stream
394)   m_fileInStream.getStr(m_nameInStream);
395)   m_pInStream = &m_streamMgr.refStream(m_nameInStream);
396) 
397)   // attach to input stream
398)   if (m_pInStream)
399)     m_pInStream->attach(this);
400) }
401) 
402) /// detach from input stream and release it
403) template<typename ADDR, typename SOCK>
404) void Sender<ADDR, SOCK>::releaseInStream()
405) {
406)   // detach from input stream
407)   if (m_pInStream)
408)     m_pInStream->detach(this);
409) 
410)   // unreference stream
411)   m_pInStream = NULL;
412)   m_streamMgr.unrefStream(m_nameInStream);
413) }
414) 
415) /// create socket and bind it
416) template<typename ADDR, typename SOCK>
417) void Sender<ADDR, SOCK>::createSock()
418) {
419)   std::string strAddr;
420)   ADDR addr;
421) 
422)   // create socket
423)   if (!m_pSock) {
424)     m_pSock = new SOCK();
425)     if (!m_pSock)
426)       return;
427)   }
428) 
429)   // get bind address from bind address setting file
430)   if (!m_fileBind.getStr(strAddr) || !addr.fromStr(strAddr)) {
431)     delete m_pSock;
432)     m_pSock = NULL;
433)     return;
434)   }
435) 
436)   // bind socket
437)   if (!m_pSock->bind(addr)) {
438)     delete m_pSock;
439)     m_pSock = NULL;
440)     return;
441)   }

442) 
443)   // request callback on recpetion
444)   m_callMgr.requestIoReadCall(this, m_pSock);

445) }
446) 
447) /// destroy socket
448) template<typename ADDR, typename SOCK>
449) void Sender<ADDR, SOCK>::destroySock()
450) {

451)   // send no frame to all destinations
452)   // (stream from this socket will stop now)
453)   setNoFrame();
454) 
455)   // clear dynamic destinations
456)   // (they registered with this socket adn this socket is gone)
457)   m_dynDestsBlp.clear();
458)   m_dynDestsEblp.clear();
459)   m_dynDestsMcuf.clear();
460) 
461)   // cancel callback request
462)   m_callMgr.cancelIoReadCall(this, m_pSock);
463) 

464)   // destroy socket
465)   if (m_pSock) {
466)     delete m_pSock;
467)     m_pSock = NULL;
468)   }
469) }
470) 
471) /**
472)  * @brief light update of static destinations,
473)  *        i.e. stat all files in current static destination directory

474)  * @param[in] dests static destinations for one protocol
475)  * @param[in] proto Blinken protocol identifier

476)  */
477) template<typename ADDR, typename SOCK>

478) void Sender<ADDR, SOCK>::updateDestsLight(Dests &dests, etBlinkenProto proto)

479) {
480)   // walk through all files in static dest dir and check for modification

481)   typename Dests::iterator itDest = dests.begin();
482)   while (itDest != dests.end()) {

483) 
484)     // address changed
485)     if (itDest->m_file.checkModified()) {
486)       // send "no frame" to old address

487)       sendNoFrame(itDest->m_addr, proto);

488)       // re-load address
489)       if (!itDest->parse()) {
490)         // parsing address failed -> remove destination

491)         itDest = dests.erase(itDest);

492)         // do not advance to next destination
493)         continue;
494)       }
495)       // send current frame to new address

496)       sendCurFrame(itDest->m_addr, proto);

497)     }
498) 
499)     // advance to next destination
500)     ++itDest;
501) 
502)   } // while itDest
503) }
504) 
505) /**
506)  * @brief full update of static destinations,
507)  *        i.e. scan files in playlist directory

508)  * @param[in] dirDests static destinations directory for protocol
509)  * @param[in] dests static destinations for protocol
510)  * @param[in] proto Blinken protocol identifier

511)  */
512) template<typename ADDR, typename SOCK>

513) void Sender<ADDR, SOCK>::updateDestsFull(Directory &dirDests, Dests &dests,
514)                                          etBlinkenProto proto)

515) {
516)   // get list of files in static destinations directory
517)   typedef std::list<std::string> Filelist;
518)   Filelist curFiles;

519)   dirDests.getEntries(Directory::TypeFile, curFiles);

520) 
521)   // walk through current static destinations and file list simultaneously
522)   Filelist::const_iterator itFile = curFiles.begin();

523)   typename Dests::iterator itDest = dests.begin();
524)   while (itFile != curFiles.end() || itDest != dests.end()) {

525) 
526)     // new static destination inserted

527)     if (itDest == dests.end() ||

528)         (itFile != curFiles.end() && *itFile < itDest->m_name)) {
529)       // parse new address

530)       Dest dest(*itFile, dirDests.getFile(*itFile));

531)       if (dest.parse()) {
532)         // insert new static destination

533)         dests.insert(itDest, dest);

534)         // send current frame to new static destination

535)         sendCurFrame(itDest->m_addr, proto);

536)       }
537)       // advance to next file
538)       ++itFile;
539)     }
540) 
541)     // static destination removed
542)     // static destination changed (=> remove and re-insert in next iteration)
543)     else if (itFile == curFiles.end() || *itFile > itDest->m_name ||
544)              itDest->m_file.checkModified()) {
545)       // send "no frame" to old static destination

546)       sendNoFrame(itDest->m_addr, proto);

547)       // remove static destination

548)       itDest = dests.erase(itDest);

549)       // do not advance to next file
550)     }
551) 
552)     // static destination stayed in playlist and did not change
553)     else {
554)       // advance to next file and next static destination
555)       ++itFile;
556)       ++itDest;
557)     }
558) 
559)   } // while itFile itDest
560) }
561) 

562) /// remove timed-out dynamic destinations
563) template<typename ADDR, typename SOCK>
564) void Sender<ADDR, SOCK>::removeTimedOutDynDests()
565) {
566)   Time now, timeout;
567)   typename DynDests::iterator itDyn;
568) 
569)   now = Time::now();
570)   timeout = Time(30);
571) 
572)   for (itDyn = m_dynDestsBlp.begin(); itDyn != m_dynDestsBlp.end(); )
573)     if (itDyn->second + timeout < now)
574)       m_dynDestsBlp.erase(itDyn++);
575)     else
576)       ++itDyn;
577)   for (itDyn = m_dynDestsEblp.begin(); itDyn != m_dynDestsEblp.end(); )
578)     if (itDyn->second + timeout < now)
579)       m_dynDestsEblp.erase(itDyn++);
580)     else
581)       ++itDyn;
582)   for (itDyn = m_dynDestsMcuf.begin(); itDyn != m_dynDestsMcuf.end(); )
583)     if (itDyn->second + timeout < now)
584)       m_dynDestsMcuf.erase(itDyn++);
585)     else
586)       ++itDyn;
587) }
588) 

589) /**
590)  * @brief send current frame to address
591)  * @param[in] addr address to send to

592)  * @param[in] proto Blinken protocol identifier

593)  */
594) template<typename ADDR, typename SOCK>

595) void Sender<ADDR, SOCK>::sendCurFrame(const ADDR &addr,
596)                                       etBlinkenProto proto) const

597) {
598)   stBlinkenFrame *pFrame;

599)   std::string data;

600) 
601)   // get current frame from stream
602)   if (m_pInStream && m_pInStream->getCurFrame(pFrame)) {

603)     // convert frame to protocal data
604)     frame2data(pFrame, proto, data);

605)     // send frame to address

606)     sendFrame(data, addr);

607)   }
608) 
609)   // no stream of no current frame
610)   else {

611)     // get "no frame" ad protocal data
612)     noFrame2data(proto, data);

613)     // send "no frame" to address

614)     sendFrame(data, addr);

615)   }
616) }
617) 
618) /**

619)  * @brief send "no frame" to address

620)  * @param[in] addr address to send to

621)  * @param[in] proto Blinken protocol identifier

622)  */
623) template<typename ADDR, typename SOCK>

624) void Sender<ADDR, SOCK>::sendNoFrame(const ADDR &addr,
625)                                      etBlinkenProto proto) const

626) {

627)   std::string data;
628) 
629)   // get "no frame" ad protocal data
630)   noFrame2data(proto, data);
631) 
632)   // send "no frame" to address
633)   sendFrame(data, addr);

634) }
635) 
636) /**

637)  * @brief send frame to address
638)  * @param[in] data protocol data of frame

639)  * @param[in] addr address to send to
640)  */
641) template<typename ADDR, typename SOCK>

642) void Sender<ADDR, SOCK>::sendFrame(const std::string &data,
643)                                    const ADDR &addr) const

644) {
645)   if (m_pSock) {

646)     m_pSock->send(data, addr);

647)   }
648) }
649) 
650) /**

651)  * @brief convert frame to protocol data

652)  * @param[in] pFrame frame

653)  * @param[in] proto Blinken protocol identifier
654)  * @param[out] data protocol data

655)  */
656) template<typename ADDR, typename SOCK>

657) void Sender<ADDR, SOCK>::frame2data(stBlinkenFrame *pFrame,
658)                                     etBlinkenProto proto, std::string &data)

659) {
660)   char buf[65536];
661)   int len;
662) 

663)   // convert frame to protcol data
664)   len = BlinkenFrameToNetwork(pFrame, proto, buf, sizeof(buf));

665)   if (len < 0)
666)     len = 0;

667)   data.assign(buf, len);
668) }
669) 
670) /**
671)  * @brief get "no frame" protocol data
672)  * @param[in] proto Blinken protocol identifier
673)  * @param[out] data protcol data
674)  */
675) template<typename ADDR, typename SOCK>
676) void Sender<ADDR, SOCK>::noFrame2data(etBlinkenProto proto, std::string &data)
677) {

678)   char buf[16];
679)   int len;
680) 

681)   // obtain "no frame" protcol data

682)   len = BlinkenProtoMakePacket(proto, BlinkenPacketStreamEnd,
683)         buf, sizeof(buf));
684)   if (len < 0)
685)     len = 0;
686)   data.assign(buf, len);
687) }
688) 
689) /// receive data from socket
690) template<typename ADDR, typename SOCK>
691) void Sender<ADDR, SOCK>::receiveFromSock()
692) {
693)   etBlinkenProto proto;
694)   etBlinkenPacket packet;
695)   std::string data;
696)   ADDR addr;
697) 
698)   // make sure socket exists
699)   if (!m_pSock)
700)     return;
701) 
702)   // receive (leave if no reception)
703)   if (!m_pSock->recv(data, addr))
704)     return;
705) 
706)   // detect packet type and protocol
707)   BlinkenProtoDetectPacket(data.c_str(), data.size(), &proto, &packet);
708) 
709)   switch (packet) {
710) 
711)     // request -> add to dynamic destinations and send current frame
712)     case BlinkenPacketRequest:
713)       switch (proto) {
714)         case BlinkenProtoBlp:
715)           m_dynDestsBlp[addr] = Time::now();
716)           sendCurFrame(addr, BlinkenProtoBlp);
717)           break;
718)         case BlinkenProtoEblp:
719)           m_dynDestsEblp[addr] = Time::now();
720)           sendCurFrame(addr, BlinkenProtoEblp);
721)           break;
722)         case BlinkenProtoMcuf:
723)           m_dynDestsMcuf[addr] = Time::now();
724)           sendCurFrame(addr, BlinkenProtoMcuf);
725)           break;
726)         default:
727)           break;
728)       }
729)       break;
730) 
731)     // end request -> remove from dynamic destinations
732)     case BlinkenPacketEndRequest:
733)       switch (proto) {
734)         case BlinkenProtoBlp:
735)           m_dynDestsBlp.erase(addr);
736)           break;
737)         case BlinkenProtoEblp:
738)           m_dynDestsEblp.erase(addr);
739)           break;
740)         case BlinkenProtoMcuf:
741)           m_dynDestsMcuf.erase(addr);
742)           break;
743)         default:
744)           break;
745)       }
746)       break;
747) 
748)     default:
749)       break;
750) 
751)   } // switch (packet)
752)