Blinker

1) /* Blinker

2)    Copyright 2011-2014 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 BLINKER_PHONE_IMPL_H
7) #define BLINKER_PHONE_IMPL_H
8) 

9) #include <map>

10) #include <sstream>

11) #include <string>

12) #include <vector>

13) 
14) #include "Directory.h"
15) #include "File.h"
16) #include "IoCallee.h"

17) #include "ListTracker.h"
18) #include "ListTracker_impl.h"

19) #include "Mgrs.h"
20) #include "Module.h"

21) #include "OpConn.h"
22) #include "OpConnIf.h"
23) #include "OpMgr.h"

24) #include "Phone.h"

25) #include "PhoneExtension.h"
26) #include "PhoneExtension_impl.h"

27) #include "SettingFile.h"

28) #include "StringParser.h"

29) #include "Time.h"
30) #include "TimeCallee.h"
31) 
32) namespace Blinker {
33) 
34) /**
35)  * @brief constructor

36)  * @param[in] name module name

37)  * @param[in] mgrs managers
38)  * @param[in] dirBase base directory
39)  */
40) template<typename ADDR, typename SOCK>

41) Phone<ADDR, SOCK>::Phone(const std::string &name, Mgrs &mgrs,
42)                          const Directory &dirBase):
43)   Module(name, mgrs, dirBase),

44)   m_fileBind(dirBase.getFile("bind")),
45)   m_fileServer(dirBase.getFile("server")),

46)   m_extListTracker(*this, dirBase.getSubdir("extensions")),

47)   m_pSock(NULL)
48) {
49)   // read server address
50)   readServer();
51) 
52)   // create and bind socket
53)   createSock();

54) 
55)   // load extensions
56)   m_extListTracker.init();

57) }
58) 
59) /// virtual destructor
60) template<typename ADDR, typename SOCK>
61) Phone<ADDR, SOCK>::~Phone()
62) {

63)   // unload extensions
64)   m_extListTracker.clear();
65) 

66)   // close all connections
67)   while (!m_connLineMap.empty()) {
68)     ConnLineMap::iterator it = m_connLineMap.begin();
69)     it->first->close();
70)     sendHangup(it->second);
71)     m_connLineMap.erase(it);
72)   }
73) 

74)   // destroy socket
75)   destroySock();
76) 
77)   // cancel time callback
78)   m_mgrs.m_callMgr.cancelTimeCall(this);
79) }
80) 
81) /// check for update of configuration
82) template<typename ADDR, typename SOCK>
83) void Phone<ADDR, SOCK>::updateConfig()
84) {
85)   // bind address file was modified -> re-create socket
86)   if (m_fileBind.checkModified()) {
87)     destroySock();
88)     createSock();
89)   }
90) 
91)   // server address file was modified -> re-read server address
92)   if (m_fileServer.checkModified())
93)     readServer();

94) 
95)   // extensions update
96)   m_extListTracker.updateConfig();

97) }
98) 
99) /// callback when requested time reached
100) template<typename ADDR, typename SOCK>
101) void Phone<ADDR, SOCK>::timeCall()
102) {
103)   Time now = Time::now();
104) 
105)   // server timeout -> re-register
106)   if (m_timeRegister <= now)
107)     sendRegister();
108) 
109)   // send heartbeat
110)   if (m_timeHeartbeat <= now)
111)     sendHeartbeat();
112) }
113) 
114) /**
115)  * @brief callback when I/O object is readable
116)  * @param[in] io I/O object that is readable
117)  */
118) template<typename ADDR, typename SOCK>
119) void Phone<ADDR, SOCK>::ioReadCall(Io *io)
120) {
121)   // reception on socket
122)   if (io == m_pSock)
123)     receiveFromSock();
124) }
125) 
126) /**
127)  * @brief callback when I/O object is writable
128)  * @param[in] io I/O object that is writable
129)  */
130) template<typename ADDR, typename SOCK>
131) void Phone<ADDR, SOCK>::ioWriteCall(Io *io)
132) {
133)   (void)io; // unused
134) }
135) 

136) /**
137)  * @brief key command received on operator connection
138)  * @param[in] pConn operator connection object
139)  * @param[in] key key that was pressed
140)  */
141) template<typename ADDR, typename SOCK>
142) void Phone<ADDR, SOCK>::opConnRecvKey(OpConn *pConn, char key)
143) {
144)   // the key command does not make sense in this direction, ignore it
145)   (void)pConn; // unused
146)   (void)key; // unused
147) }
148) 
149) /**
150)  * @brief play command received on operator connection
151)  * @param[in] pConn operator connection object
152)  * @param[in] sound name of sound to play
153)  */
154) template<typename ADDR, typename SOCK>
155) void Phone<ADDR, SOCK>::opConnRecvPlay(OpConn *pConn, const std::string &sound)
156) {
157)   // get phone line of connection
158)   unsigned int line;
159)   if (!conn2line(pConn, line))
160)     return;
161) 
162)   // send play message
163)   sendPlay(line, sound);
164) }
165) 

166) /**
167)  * @brief operator connection is closed
168)  * @param[in] pConn operator connection object

169)  *
170)  * The connection may not be used for sending any more in this callback.

171)  */
172) template<typename ADDR, typename SOCK>
173) void Phone<ADDR, SOCK>::opConnClose(OpConn *pConn)
174) {
175)   // get phone line of connection

176)   unsigned int line;
177)   if (!conn2line(pConn, line))

178)     return;
179) 
180)   // send hangup message
181)   sendHangup(line);
182) 
183)   // remove connection from maps

184)   m_connLineMap.erase(pConn);

185)   m_lineConnMap.erase(line);

186) 
187)   // remove command buffer for this line
188)   m_cmdBufMap.erase(line);

189) }
190) 

191) /// (re-)read server address
192) template<typename ADDR, typename SOCK>
193) void Phone<ADDR, SOCK>::readServer()
194) {
195)   m_fileServer.update();
196) 
197)   // register with new server
198)   sendRegister();
199) }
200) 
201) /// create socket and bind it
202) template<typename ADDR, typename SOCK>
203) void Phone<ADDR, SOCK>::createSock()
204) {
205)   // create socket
206)   if (!m_pSock) {
207)     m_pSock = new SOCK();
208)     if (!m_pSock)
209)       return;
210)   }
211) 
212)   // get bind address from bind address setting file
213)   m_fileBind.update();
214)   if (!m_fileBind.m_valid) {
215)     delete m_pSock;
216)     m_pSock = NULL;
217)     return;
218)   }
219) 
220)   // bind socket
221)   if (!m_pSock->bind(m_fileBind.m_obj)) {
222)     delete m_pSock;
223)     m_pSock = NULL;
224)     return;
225)   }
226) 
227)   // request callback on recepetion
228)   m_mgrs.m_callMgr.requestIoReadCall(this, m_pSock);
229) 
230)   // register with server
231)   sendRegister();
232) }
233) 
234) /// destroy socket
235) template<typename ADDR, typename SOCK>
236) void Phone<ADDR, SOCK>::destroySock()
237) {
238)   // cancel callback request
239)   m_mgrs.m_callMgr.cancelIoReadCall(this, m_pSock);
240) 
241)   // destroy socket
242)   if (m_pSock) {
243)     delete m_pSock;
244)     m_pSock = NULL;
245)   }
246) }
247) 
248) /// register with server
249) template<typename ADDR, typename SOCK>
250) void Phone<ADDR, SOCK>::sendRegister()
251) {

252)   ADDR addr;
253)   if (m_pSock)
254)     m_pSock->getAddr(addr);
255)   std::stringstream strm;
256)   strm << "register:" << addr.getPort();
257)   sendNow(0, strm.str());

258) 
259)   // set time for next register message and next heartbeat

260)   Time now = Time::now();
261)   m_timeRegister = now + m_serverTimeout;
262)   m_timeHeartbeat = now + m_heartbeatInterval;

263)   updateTimeCallback();
264) }
265) 
266) /// send heartbeat to server
267) template<typename ADDR, typename SOCK>
268) void Phone<ADDR, SOCK>::sendHeartbeat()
269) {

270)   sendNow(0, "heartbeat");

271) 
272)   // set time for next heartbeat
273)   m_timeHeartbeat = Time::now() + m_heartbeatInterval;
274)   updateTimeCallback();
275) }
276) 

277) /**
278)  * @brief send play message
279)  * @param[in] line number of line to request play on
280)  * @param[in] sound name of sound to request
281)  */
282) template<typename ADDR, typename SOCK>
283) void Phone<ADDR, SOCK>::sendPlay(unsigned int line, const std::string &sound)
284) {
285)   std::stringstream strm;

286)   strm << "playbackground:" << sound;
287)   sendBuf(line, strm.str());

288) }
289) 

290) /**
291)  * @brief send hangup message
292)  * @param[in] line number of line to hangup
293)  */
294) template<typename ADDR, typename SOCK>
295) void Phone<ADDR, SOCK>::sendHangup(unsigned int line)
296) {

297)   sendNow(line, "hangup:18"); // nobody knows what the 18 meanas

298) }
299) 

300) /**
301)  * @brief send accept message
302)  * @param[in] line number of line accept on
303)  */
304) template<typename ADDR, typename SOCK>
305) void Phone<ADDR, SOCK>::sendAccept(unsigned int line)

306) {
307)   sendNow(line, "accept");
308) }
309) 
310) /**
311)  * @brief send message buffered to server
312)  * @param[in] line number of line to hangup
313)  * @param[in] msg message to send
314)  */
315) template<typename ADDR, typename SOCK>
316) void Phone<ADDR, SOCK>::sendBuf(unsigned int line, const std::string &msg)
317) {
318)   CmdBufMap::iterator itCmdBuf = m_cmdBufMap.find(line);
319)   // line not yet connected -> buffer command
320)   if (itCmdBuf != m_cmdBufMap.end())
321)     // buffer command
322)     itCmdBuf->second.push_back(msg);
323)   // line is connected -> send now
324)   else
325)     sendNow(line, msg);
326) }
327) 
328) /**
329)  * @brief send message to server now
330)  * @param[in] line number of line to hangup
331)  * @param[in] msg message to send
332)  */
333) template<typename ADDR, typename SOCK>
334) void Phone<ADDR, SOCK>::sendNow(unsigned int line, const std::string &msg)

335) {
336)   std::stringstream strm;

337)   strm << line << ":" << msg;
338)   sendSock(strm.str());

339) }
340) 

341) /**

342)  * @brief send message to socket

343)  * @param[in] msg message to send
344)  */
345) template<typename ADDR, typename SOCK>

346) void Phone<ADDR, SOCK>::sendSock(const std::string &msg)

347) {
348)   // check that there is a socket and a server address
349)   if (!m_pSock || !m_fileServer.m_valid)
350)     return;
351) 
352)   // send message
353)   m_pSock->send(msg, m_fileServer.m_obj);
354) }
355) 
356) /// receive data from socket
357) template<typename ADDR, typename SOCK>
358) void Phone<ADDR, SOCK>::receiveFromSock()
359) {
360)   std::string msg;
361)   ADDR addr;
362) 
363)   // make sure socket exists
364)   if (!m_pSock)
365)     return;
366) 
367)   // receive (leave if no reception)
368)   if (!m_pSock->recv(msg, addr))
369)     return;
370) 

371)   // check that packet came from server address (but ignore port)
372)   if (!m_fileServer.m_valid)
373)     return; // no server configured
374)   addr.setPort(m_fileServer.m_obj.getPort());
375)   if (addr != m_fileServer.m_obj)

376)     return; // mismatch
377) 
378)   // reset server timeout
379)   m_timeRegister = Time::now() + m_serverTimeout;
380)   updateTimeCallback();
381) 

382)   // process message
383)   serverMsg(msg);
384) }
385) 
386) /**
387)  * @brief process message from server
388)  * @param[in] msg message from server
389)  */
390) template<typename ADDR, typename SOCK>
391) void Phone<ADDR, SOCK>::serverMsg(const std::string &msg)
392) {
393)   // get line number and command

394)   StringParser parser(msg);

395)   unsigned int line;
396)   std::string cmd;
397)   if (!parser.uintNo(line) || !parser.fixChr(':') ||
398)       !parser.untilDelim(":", false, cmd))
399)     return;

400)   if (line < 1) // we are only interested in real lines here
401)     return;

402) 
403)   // incoming call
404)   if (cmd == "setup") {
405)     std::string caller, extension;
406)     if (!parser.fixChr(':') || !parser.untilDelim(":", true, caller) ||
407)         !parser.fixChr(':') || !parser.untilDelim(":", false, extension))
408)       return;

409)     incomingCall(line, extension);

410)   }
411) 

412)   // call connected
413)   else if (cmd == "connected") {
414)     connected(line);
415)   }
416) 

417)   // hangup
418)   else if (cmd == "onhook") {

419)     hangup(line);

420)   }
421) 
422)   // DTMF symbol (i.e. key pressed)
423)   else if (cmd == "dtmf") {
424)     char key;
425)     if (!parser.fixChr(':') || !parser.oneChrOf("0123456789*#", key))
426)       return;

427)     keyPressed(line, key);

428)   }

429) }
430) 

431) /**
432)  * @brief process incoming call
433)  * @param[in] line number of phone line
434)  * @param[in] extension extenstion called (i.e. phone number)
435)  */
436) template<typename ADDR, typename SOCK>
437) void Phone<ADDR, SOCK>::incomingCall(unsigned int line,
438)                                      const std::string &extension)
439) {
440)   // hangup old call on this line (to be on the safe side)
441)   hangup(line);
442) 

443)   // buffer further commands to be sent to this line until it is connected
444)   // -> create command buffer for this line
445)   m_cmdBufMap[line];
446) 

447)   // lookup extension
448)   ExtMap::iterator itExt = m_extMap.find(extension);
449)   if (itExt == m_extMap.end())
450)     return; // unknown extension -> ignore
451) 
452)   // try to open operator connection to module
453)   OpConn *pConn = m_mgrs.m_opMgr.connect(itExt->second, this);
454)   if (!pConn) // module is not ready for connection
455)     return;
456) 
457)   // add connection to maps
458)   m_lineConnMap[line] = pConn;
459)   m_connLineMap[pConn] = line;

460) 
461)   // send accept message
462)   sendAccept(line);

463) }
464) 

465) /**
466)  * @brief phone line connected
467)  * @param[in] line number of phone line
468)  */
469) template<typename ADDR, typename SOCK>
470) void Phone<ADDR, SOCK>::connected(unsigned int line)
471) {
472)   // get buffered commands for this line
473)   CmdBuf &cmdBuf = m_cmdBufMap[line];
474) 
475)   // send buffered commands now
476)   for (CmdBuf::const_iterator cmd = cmdBuf.begin();
477)        cmd != cmdBuf.end(); ++cmd) {
478)     std::stringstream strm;
479)     strm << line << ":" << *cmd;
480)     sendSock(strm.str());
481)   }
482) 
483)   // delete command buffer for this line
484)   m_cmdBufMap.erase(line);
485) }
486) 

487) /**
488)  * @brief hangup on phone line
489)  * @param[in] line number of phone line
490)  */
491) template<typename ADDR, typename SOCK>
492) void Phone<ADDR, SOCK>::hangup(unsigned int line)
493) {
494)   // get connection

495)   OpConn *pConn;
496)   if (!line2conn(line, pConn))

497)     return; // no connection on this line
498) 
499)   // close connection
500)   pConn->close();
501) 
502)   // remove connection from maps

503)   m_lineConnMap.erase(line);

504)   m_connLineMap.erase(pConn);

505) 
506)   // remove command buffer for this line
507)   m_cmdBufMap.erase(line);

508) }
509) 
510) /**
511)  * @brief key pressed on phone line
512)  * @param[in] line number of phone line
513)  * @param[in] key key that has been pressed
514)  */
515) template<typename ADDR, typename SOCK>
516) void Phone<ADDR, SOCK>::keyPressed(unsigned int line, char key)
517) {
518)   // get connection

519)   OpConn *pConn;
520)   if (!line2conn(line, pConn))

521)     return; // no connection on this line
522) 

523)   // send key press event over connection
524)   pConn->sendKey(key);
525) }
526) 
527) /**
528)  * @brief get phone line number from operator connection
529)  * @param[in] pConn operator connection object
530)  * @param[out] line phone line number
531)  * @return if phone line was found
532)  */
533) template<typename ADDR, typename SOCK>
534) bool Phone<ADDR, SOCK>::conn2line(OpConn *pConn, unsigned int &line) const
535) {
536)   ConnLineMap::const_iterator itConn = m_connLineMap.find(pConn);
537)   if (itConn == m_connLineMap.end())
538)     return false;
539)   line = itConn->second;
540)   return true;
541) }
542) 
543) /**
544)  * @brief get operator connection from phone line number
545)  * @param[in] line phone line number
546)  * @param[out] pConn operator connection object
547)  * @return if phone line was found
548)  */
549) template<typename ADDR, typename SOCK>
550) bool Phone<ADDR, SOCK>::line2conn(unsigned int line, OpConn *&pConn) const
551) {
552)   LineConnMap::const_iterator itLine = m_lineConnMap.find(line);
553)   if (itLine == m_lineConnMap.end())
554)     return false;
555)   pConn = itLine->second;
556)   return true;

557) }
558) 

559) /// update time callback
560) template<typename ADDR, typename SOCK>
561) void Phone<ADDR, SOCK>::updateTimeCallback()
562) {
563)   m_mgrs.m_callMgr.requestTimeCall(this, m_timeRegister < m_timeHeartbeat
564)                                          ? m_timeRegister : m_timeHeartbeat);
565) }
566) 
567) template<typename ADDR, typename SOCK>

568) const Time Phone<ADDR, SOCK>::m_serverTimeout(60);