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] stream stream name

76)    * @param[in] pFrame current frame
77)    */

78)   virtual void setFrame(const std::string &stream, stBlinkenFrame *pFrame);

79) 

80)   /**
81)    * @brief set current frame to none
82)    * @param[in] stream stream name
83)    */
84)   virtual void setNoFrame(const std::string &stream);

85) 

86)   /// callback when requsted time reached
87)   virtual void timeCall();
88) 

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

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

117)    * @param[in] dests static destinations for protocol
118)    * @param[in] proto Blinken protocol identifier

119)    */

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

121) 
122)   /**
123)    * @brief full update of static destinations,
124)    *        i.e. scan files in playlist directory

125)    * @param[in] dirDests static destinations directory for protocol
126)    * @param[in] dests static destinations for protocol
127)    * @param[in] proto Blinken protocol identifier

128)    */

129)   void updateDestsFull(Directory &dirDests, Dests &dests,
130)                        etBlinkenProto proto);

131) 

132)   /// remove timed-out dynamic destinations
133)   void removeTimedOutDynDests();
134) 

135)   /**
136)    * @brief send frame to all destinations
137)    * @param[in] pFrame frame to send
138)    */
139)   void sendAllFrame(stBlinkenFrame *pFrame);
140) 
141)   /// send "no frame" to all destinations
142)   void sendAllNoFrame();
143) 
144)   /**
145)    * @brief send data to static/dynamic destinations
146)    * @param[in] data data to send
147)    * @param[in] dests static destinations
148)    * @param[in] dynDests dynamic destinations
149)    */
150)   void sendDests(const std::string &data, const Dests dests,
151)                  const DynDests dynDests);
152) 

153)   /**
154)    * @brief send current frame to address
155)    * @param[in] addr address to send to

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

157)    */

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

159) 
160)   /**

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

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

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

164)    */

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

166) 
167)   /**

168)    * @brief send frame to address
169)    * @param[in] data protcol data of frame

170)    * @param[in] addr address to send to
171)    */

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

173) 
174)   /**

175)    * @brief convert frame to protocol data

176)    * @param[in] pFrame frame

177)    * @param[in] proto Blinken protocol identifier
178)    * @param[out] data protcol data

179)    */

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

182) 
183)   /**
184)    * @brief get "no frame" protocol data
185)    * @param[in] proto Blinken protocol identifier
186)    * @param[out] data protcol data
187)    */

188)   static void noFrame2data(etBlinkenProto proto, std::string &data);
189) 
190)   /// receive data from socket
191)   void receiveFromSock();

192) 
193) protected:
194)   SettingFile m_fileInStream; ///< input stream name file
195)   SettingFile m_fileBind;     ///< bind address file

196)   Directory   m_dirDestsBlp;  ///< static BLP destinations directory
197)   Directory   m_dirDestsEblp; ///< static EBLP destinations directory

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

199)   std::string m_nameInStream; ///< name of input stream
200)   Stream      *m_pInStream;   ///< input stream
201)   SOCK        *m_pSock;       ///< socket to use for sending streams

202)   Dests       m_destsBlp;     ///< static BLP destinations
203)   Dests       m_destsEblp;    ///< static EBLP destinations
204)   Dests       m_destsMcuf;    ///< static MCUF destinations
205)   DynDests    m_dynDestsBlp;  ///< dynamic BLP destinations
206)   DynDests    m_dynDestsEblp; ///< dynamic EBLP destinations
207)   DynDests    m_dynDestsMcuf; ///< dynamic MCUF destinations

208) }; // class Sender
209) 
210) /* ##########
211)    # Sender #
212)    ########## */
213) 
214) /**
215)  * @brief constructor
216)  * @param[in] callMgr callback manager
217)  * @param[in] streamMgr stream manager
218)  * @param[in] dirBase base directory
219)  */
220) template<typename ADDR, typename SOCK>
221) Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,
222)                            const Directory &dirBase):
223)   Module(callMgr, streamMgr, dirBase),
224)   m_fileInStream(dirBase.getFile("instream")),
225)   m_fileBind(dirBase.getFile("bind")),

226)   m_dirDestsBlp(dirBase.getSubdir("blp")),
227)   m_dirDestsEblp(dirBase.getSubdir("eblp")),

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

229)   m_pInStream(NULL),
230)   m_pSock(NULL)
231) {
232)   // get input stream and attach to it
233)   getInStream();
234)   // create and bind socket
235)   createSock();
236) 
237)   // load static destinations

238)   updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);
239)   updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);

240)   updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

241) }
242) 
243) /// virtual destructor
244) template<typename ADDR, typename SOCK>
245) Sender<ADDR, SOCK>::~Sender()
246) {

247)   // send "no frame" to all destinations
248)   sendAllNoFrame();

249) 
250)   // destroy socket
251)   destroySock();
252)   // detach from input stream and release it
253)   releaseInStream();

254)   // cancel time callback
255)   m_callMgr.cancelTimeCall(this);

256) }
257) 
258) /// check for update of configuration
259) template<typename ADDR, typename SOCK>
260) void Sender<ADDR, SOCK>::updateConfig()
261) {
262)   // input stream name file was modified -> re-get input stream
263)   if (m_fileInStream.checkModified()) {
264)     releaseInStream();
265)     getInStream();
266)   }
267) 
268)   // bind address file was modified -> re-create socket
269)   if (m_fileBind.checkModified()) {
270)     destroySock();
271)     createSock();
272)   }
273) 
274)   // static destinations update
275)   // (directory modified -> full, otherwise -> light)

276)   if (m_dirDestsBlp.checkModified())
277)     updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);
278)   else
279)     updateDestsLight(m_destsBlp, BlinkenProtoBlp);
280)   if (m_dirDestsEblp.checkModified())
281)     updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);
282)   else
283)     updateDestsLight(m_destsEblp, BlinkenProtoEblp);

284)   if (m_dirDestsMcuf.checkModified())
285)     updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

286)   else

287)     updateDestsLight(m_destsMcuf, BlinkenProtoMcuf);

288) }
289) 
290) /**
291)  * @brief set current frame

292)  * @param[in] stream stream name

293)  * @param[in] pFrame current frame
294)  */
295) template<typename ADDR, typename SOCK>

296) void Sender<ADDR, SOCK>::setFrame(const std::string &stream,
297)                                   stBlinkenFrame *pFrame)

298) {

299)   // send frame to all destinations
300)   sendAllFrame(pFrame);

301) 

302)   (void)stream; // unused

303) }
304) 

305) /**
306)  * @brief set current frame to none
307)  * @param[in] stream stream name
308)  */

309) template<typename ADDR, typename SOCK>

310) void Sender<ADDR, SOCK>::setNoFrame(const std::string &stream)

311) {

312)   // send "no frame" to all destinations
313)   sendAllNoFrame();

314) 

315)   (void)stream; // unused

316) }
317) 
318) /// callback when requsted time reached
319) template<typename ADDR, typename SOCK>
320) void Sender<ADDR, SOCK>::timeCall()
321) {
322)   stBlinkenFrame *pFrame;
323)   std::string data;
324) 
325)   // get current frame from stream
326)   if (m_pInStream && m_pInStream->getCurFrame(pFrame))

327)     // repeat frame to all destinations
328)     sendAllFrame(pFrame);

329) 
330)   // no stream of no current frame
331)   else

332)     // repeat "no frame" to all destinations
333)     sendAllNoFrame();

334) }
335) 

336) /**
337)  * @brief callback when I/O object is readable
338)  * @param[in] io I/O object that is readable
339)  */
340) template<typename ADDR, typename SOCK>
341) void Sender<ADDR, SOCK>::ioReadCall(Io *io)
342) {
343)   // reception on socket
344)   if (io == m_pSock)
345)     receiveFromSock();
346) }
347) 
348) /**
349)  * @brief callback when I/O object is writable
350)  * @param[in] io I/O object that is writable
351)  */
352) template<typename ADDR, typename SOCK>
353) void Sender<ADDR, SOCK>::ioWriteCall(Io *io)
354) {
355)   (void)io; // unused
356) }
357) 

358) /// get input stream and attach to it
359) template<typename ADDR, typename SOCK>
360) void Sender<ADDR, SOCK>::getInStream()
361) {
362)   // get input stream
363)   m_fileInStream.getStr(m_nameInStream);
364)   m_pInStream = &m_streamMgr.refStream(m_nameInStream);
365) 
366)   // attach to input stream
367)   if (m_pInStream)
368)     m_pInStream->attach(this);
369) }
370) 
371) /// detach from input stream and release it
372) template<typename ADDR, typename SOCK>
373) void Sender<ADDR, SOCK>::releaseInStream()
374) {
375)   // detach from input stream
376)   if (m_pInStream)
377)     m_pInStream->detach(this);
378) 
379)   // unreference stream
380)   m_pInStream = NULL;
381)   m_streamMgr.unrefStream(m_nameInStream);
382) }
383) 
384) /// create socket and bind it
385) template<typename ADDR, typename SOCK>
386) void Sender<ADDR, SOCK>::createSock()
387) {
388)   std::string strAddr;
389)   ADDR addr;
390) 
391)   // create socket
392)   if (!m_pSock) {
393)     m_pSock = new SOCK();
394)     if (!m_pSock)
395)       return;
396)   }
397) 
398)   // get bind address from bind address setting file
399)   if (!m_fileBind.getStr(strAddr) || !addr.fromStr(strAddr)) {
400)     delete m_pSock;
401)     m_pSock = NULL;
402)     return;
403)   }
404) 
405)   // bind socket
406)   if (!m_pSock->bind(addr)) {
407)     delete m_pSock;
408)     m_pSock = NULL;
409)     return;
410)   }

411) 
412)   // request callback on recpetion
413)   m_callMgr.requestIoReadCall(this, m_pSock);

414) }
415) 
416) /// destroy socket
417) template<typename ADDR, typename SOCK>
418) void Sender<ADDR, SOCK>::destroySock()
419) {

420)   // send "no frame" to all destinations

421)   // (stream from this socket will stop now)

422)   sendAllNoFrame();

423) 
424)   // clear dynamic destinations
425)   // (they registered with this socket adn this socket is gone)
426)   m_dynDestsBlp.clear();
427)   m_dynDestsEblp.clear();
428)   m_dynDestsMcuf.clear();
429) 
430)   // cancel callback request
431)   m_callMgr.cancelIoReadCall(this, m_pSock);
432) 

433)   // destroy socket
434)   if (m_pSock) {
435)     delete m_pSock;
436)     m_pSock = NULL;
437)   }
438) }
439) 
440) /**
441)  * @brief light update of static destinations,
442)  *        i.e. stat all files in current static destination directory

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

445)  */
446) template<typename ADDR, typename SOCK>

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

448) {
449)   // walk through all files in static dest dir and check for modification

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

452) 
453)     // address changed
454)     if (itDest->m_file.checkModified()) {
455)       // send "no frame" to old address

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

457)       // re-load address
458)       if (!itDest->parse()) {
459)         // parsing address failed -> remove destination

460)         itDest = dests.erase(itDest);

461)         // do not advance to next destination
462)         continue;
463)       }
464)       // send current frame to new address

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

466)     }
467) 
468)     // advance to next destination
469)     ++itDest;
470) 
471)   } // while itDest
472) }
473) 
474) /**
475)  * @brief full update of static destinations,
476)  *        i.e. scan files in playlist directory

477)  * @param[in] dirDests static destinations directory for protocol
478)  * @param[in] dests static destinations for protocol
479)  * @param[in] proto Blinken protocol identifier

480)  */
481) template<typename ADDR, typename SOCK>

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

484) {
485)   // get list of files in static destinations directory
486)   typedef std::list<std::string> Filelist;
487)   Filelist curFiles;

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

489) 
490)   // walk through current static destinations and file list simultaneously
491)   Filelist::const_iterator itFile = curFiles.begin();

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

494) 
495)     // new static destination inserted

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

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

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

500)       if (dest.parse()) {
501)         // insert new static destination

502)         dests.insert(itDest, dest);

503)         // send current frame to new static destination

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

505)       }
506)       // advance to next file
507)       ++itFile;
508)     }
509) 
510)     // static destination removed
511)     // static destination changed (=> remove and re-insert in next iteration)
512)     else if (itFile == curFiles.end() || *itFile > itDest->m_name ||
513)              itDest->m_file.checkModified()) {
514)       // send "no frame" to old static destination

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

516)       // remove static destination

517)       itDest = dests.erase(itDest);

518)       // do not advance to next file
519)     }
520) 
521)     // static destination stayed in playlist and did not change
522)     else {
523)       // advance to next file and next static destination
524)       ++itFile;
525)       ++itDest;
526)     }
527) 
528)   } // while itFile itDest
529) }
530) 

531) /// remove timed-out dynamic destinations
532) template<typename ADDR, typename SOCK>
533) void Sender<ADDR, SOCK>::removeTimedOutDynDests()
534) {
535)   Time now, timeout;
536)   typename DynDests::iterator itDyn;
537) 
538)   now = Time::now();
539)   timeout = Time(30);
540) 
541)   for (itDyn = m_dynDestsBlp.begin(); itDyn != m_dynDestsBlp.end(); )
542)     if (itDyn->second + timeout < now)
543)       m_dynDestsBlp.erase(itDyn++);
544)     else
545)       ++itDyn;
546)   for (itDyn = m_dynDestsEblp.begin(); itDyn != m_dynDestsEblp.end(); )
547)     if (itDyn->second + timeout < now)
548)       m_dynDestsEblp.erase(itDyn++);
549)     else
550)       ++itDyn;
551)   for (itDyn = m_dynDestsMcuf.begin(); itDyn != m_dynDestsMcuf.end(); )
552)     if (itDyn->second + timeout < now)
553)       m_dynDestsMcuf.erase(itDyn++);
554)     else
555)       ++itDyn;
556) }
557) 

558) /**
559)  * @brief send frame to all destinations
560)  * @param[in] pFrame frame to send
561)  */
562) template<typename ADDR, typename SOCK>
563) void Sender<ADDR, SOCK>::sendAllFrame(stBlinkenFrame *pFrame)
564) {
565)   std::string data;
566) 
567)   // remove timed-out dynamic destinations
568)   removeTimedOutDynDests();
569) 
570)   // convert frame to protocol data and send to all static/dynamic destinations
571)   if (!m_destsBlp.empty() || !m_dynDestsBlp.empty()) {
572)     frame2data(pFrame, BlinkenProtoBlp, data);
573)     sendDests(data, m_destsBlp, m_dynDestsBlp);
574)   }
575)   if (!m_destsEblp.empty() || !m_dynDestsEblp.empty()) {
576)     frame2data(pFrame, BlinkenProtoEblp, data);
577)     sendDests(data, m_destsEblp, m_dynDestsEblp);
578)   }
579)   if (!m_destsMcuf.empty() || !m_dynDestsMcuf.empty()) {
580)     frame2data(pFrame, BlinkenProtoMcuf, data);
581)     sendDests(data, m_destsMcuf, m_dynDestsMcuf);
582)   }
583) 
584)   // request time callback in one second
585)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));
586) }
587) 
588) /// send "no frame" to all destinations
589) template<typename ADDR, typename SOCK>
590) void Sender<ADDR, SOCK>::sendAllNoFrame()
591) {
592)   std::string data;
593) 
594)   // remove timed-out dynamic destinations
595)   removeTimedOutDynDests();
596) 
597)   // get "no frame" protocol data and send to all static/dynamic destinations
598)   if (!m_destsBlp.empty() || !m_dynDestsBlp.empty()) {
599)     noFrame2data(BlinkenProtoBlp, data);
600)     sendDests(data, m_destsBlp, m_dynDestsBlp);
601)   }
602)   if (!m_destsEblp.empty() || !m_dynDestsEblp.empty()) {
603)     noFrame2data(BlinkenProtoEblp, data);
604)     sendDests(data, m_destsEblp, m_dynDestsEblp);
605)   }
606)   if (!m_destsMcuf.empty() || !m_dynDestsMcuf.empty()) {
607)     noFrame2data(BlinkenProtoMcuf, data);
608)     sendDests(data, m_destsMcuf, m_dynDestsMcuf);
609)   }
610) 
611)   // request time callback in one second
612)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));
613) }
614) 
615) /**
616)  * @brief send data to static/dynamic destinations
617)  * @param[in] data data to send
618)  * @param[in] dests static destinations
619)  * @param[in] dynDests dynamic destinations
620)  */
621) template<typename ADDR, typename SOCK>
622) void Sender<ADDR, SOCK>::sendDests(const std::string &data, const Dests dests,
623)                                    const DynDests dynDests)
624) {
625)   // send data to static destinations
626)   typename Dests::const_iterator itDest;
627)   for (itDest = dests.begin(); itDest != dests.end(); ++itDest)
628)     sendFrame(data, itDest->m_addr);
629) 
630)   // send data to all dynamic destinations
631)   typename DynDests::const_iterator itDyn;
632)   for (itDyn = dynDests.begin(); itDyn != dynDests.end(); ++itDyn)
633)     sendFrame(data, itDyn->first);
634) }
635) 

636) /**
637)  * @brief send current frame to address
638)  * @param[in] addr address to send to

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

640)  */
641) template<typename ADDR, typename SOCK>

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

644) {
645)   stBlinkenFrame *pFrame;

646)   std::string data;

647) 
648)   // get current frame from stream
649)   if (m_pInStream && m_pInStream->getCurFrame(pFrame)) {

650)     // convert frame to protocal data
651)     frame2data(pFrame, proto, data);

652)     // send frame to address

653)     sendFrame(data, addr);

654)   }
655) 
656)   // no stream of no current frame
657)   else {

658)     // get "no frame" ad protocal data
659)     noFrame2data(proto, data);

660)     // send "no frame" to address

661)     sendFrame(data, addr);

662)   }
663) }
664) 
665) /**

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

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

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

669)  */
670) template<typename ADDR, typename SOCK>

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

673) {

674)   std::string data;
675) 
676)   // get "no frame" ad protocal data
677)   noFrame2data(proto, data);
678) 
679)   // send "no frame" to address
680)   sendFrame(data, addr);

681) }
682) 
683) /**

684)  * @brief send frame to address
685)  * @param[in] data protocol data of frame

686)  * @param[in] addr address to send to
687)  */
688) template<typename ADDR, typename SOCK>

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

691) {
692)   if (m_pSock) {

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

694)   }
695) }
696) 
697) /**

698)  * @brief convert frame to protocol data

699)  * @param[in] pFrame frame

700)  * @param[in] proto Blinken protocol identifier
701)  * @param[out] data protocol data

702)  */
703) template<typename ADDR, typename SOCK>

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

706) {
707)   char buf[65536];
708)   int len;
709) 

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

712)   if (len < 0)
713)     len = 0;

714)   data.assign(buf, len);
715) }
716) 
717) /**
718)  * @brief get "no frame" protocol data
719)  * @param[in] proto Blinken protocol identifier
720)  * @param[out] data protcol data
721)  */
722) template<typename ADDR, typename SOCK>
723) void Sender<ADDR, SOCK>::noFrame2data(etBlinkenProto proto, std::string &data)
724) {

725)   char buf[16];
726)   int len;
727) 

728)   // obtain "no frame" protcol data

729)   len = BlinkenProtoMakePacket(proto, BlinkenPacketStreamEnd,
730)         buf, sizeof(buf));
731)   if (len < 0)
732)     len = 0;
733)   data.assign(buf, len);
734) }
735) 
736) /// receive data from socket
737) template<typename ADDR, typename SOCK>
738) void Sender<ADDR, SOCK>::receiveFromSock()
739) {
740)   etBlinkenProto proto;
741)   etBlinkenPacket packet;
742)   std::string data;
743)   ADDR addr;
744) 
745)   // make sure socket exists
746)   if (!m_pSock)
747)     return;
748) 
749)   // receive (leave if no reception)
750)   if (!m_pSock->recv(data, addr))
751)     return;
752) 
753)   // detect packet type and protocol
754)   BlinkenProtoDetectPacket(data.c_str(), data.size(), &proto, &packet);
755) 
756)   switch (packet) {
757) 
758)     // request -> add to dynamic destinations and send current frame
759)     case BlinkenPacketRequest:
760)       switch (proto) {
761)         case BlinkenProtoBlp:
762)           m_dynDestsBlp[addr] = Time::now();
763)           sendCurFrame(addr, BlinkenProtoBlp);
764)           break;
765)         case BlinkenProtoEblp:
766)           m_dynDestsEblp[addr] = Time::now();
767)           sendCurFrame(addr, BlinkenProtoEblp);
768)           break;
769)         case BlinkenProtoMcuf:
770)           m_dynDestsMcuf[addr] = Time::now();
771)           sendCurFrame(addr, BlinkenProtoMcuf);
772)           break;
773)         default:
774)           break;
775)       }
776)       break;
777) 
778)     // end request -> remove from dynamic destinations
779)     case BlinkenPacketEndRequest:
780)       switch (proto) {
781)         case BlinkenProtoBlp:
782)           m_dynDestsBlp.erase(addr);
783)           break;
784)         case BlinkenProtoEblp:
785)           m_dynDestsEblp.erase(addr);
786)           break;
787)         case BlinkenProtoMcuf:
788)           m_dynDestsMcuf.erase(addr);
789)           break;
790)         default:
791)           break;
792)       }
793)       break;
794) 
795)     default:
796)       break;
797) 
798)   } // switch (packet)
799)