00001
00020 #ifndef TcpSockServer_h
00021 #define TcpSockServer_h
00022
00023 #define RAWTCP_DEFAULT_BUFFER_SIZE 128
00024
00025 #include <ace/Reactor.h>
00026 #include <ace/SOCK_Acceptor.h>
00027 #include <ace/Event_Handler.h>
00028 #include <ace/INET_Addr.h>
00029 #include <ace/SOCK_Stream.h>
00030 #include <coil/Task.h>
00031 #include <ace/OS.h>
00032 #include <iostream>
00033 #include <rtm/BufferBase.h>
00034 #include <rtm/StringUtil.h>
00035 #include <rtm/Properties.h>
00036
00037 namespace RTC
00038 {
00039
00040
00041
00042
00043 template <class DataType> class TcpHandler;
00044
00065 template <class DataType>
00066 class TcpAcceptor
00067 : public ACE_Event_Handler
00068 {
00069 friend class TcpHandler<DataType>;
00070
00071 public:
00091 TcpAcceptor(BufferBase<DataType>& buffer, Properties& prop)
00092 : m_buffer(buffer), m_prop(prop)
00093 {
00094 }
00095
00107 virtual ~TcpAcceptor(void)
00108 {
00109 }
00110
00138 int open(const ACE_INET_Addr& addr, ACE_Reactor* reactor)
00139 {
00140 if (this->m_peerAcceptor.open(addr, 1) == -1)
00141 {
00142 return -1;
00143 }
00144 m_reactor = reactor;
00145
00146
00147 this->m_peerAcceptor.get_local_addr(m_addr);
00148
00149
00150 int ret;
00151 ret = m_reactor->register_handler(this, ACE_Event_Handler::ACCEPT_MASK);
00152 return ret;
00153 }
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00196 unsigned short get_port_number(void) const
00197 {
00198 return m_addr.get_port_number();
00199 }
00200
00201 private:
00221 ACE_HANDLE get_handle(void) const
00222 {
00223 return m_peerAcceptor.get_handle();
00224 }
00225
00245 int handle_input(ACE_HANDLE)
00246 {
00247 std::cout << "handle_input" << std::endl;
00248 m_svcHandler = new TcpHandler<DataType>(m_buffer, m_prop);
00249 if (m_peerAcceptor.accept(*m_svcHandler, &m_remoteAddr) == -1)
00250 {
00251
00252 return -1;
00253 }
00254
00255
00256 if (m_svcHandler->open(m_reactor) == -1)
00257 {
00258
00259 return -1;
00260 }
00261 return 0;
00262 }
00263
00264 protected:
00272 BufferBase<DataType>& m_buffer;
00273
00281 Properties& m_prop;
00282
00290 ACE_INET_Addr m_addr;
00291
00299 ACE_INET_Addr m_remoteAddr;
00300
00308 ACE_SOCK_Acceptor m_peerAcceptor;
00309
00317 ACE_Reactor* m_reactor;
00318
00326 TcpHandler<DataType>* m_svcHandler;
00327
00335 unsigned short m_port;
00336 };
00337
00338
00339
00340
00360 template <class DataType>
00361 class TcpServer
00362 : public coil::Task
00363 {
00364 public:
00384 TcpServer(BufferBase<DataType>& buffer, Properties& prop)
00385 : m_acceptor(buffer, prop), m_buffer(buffer), m_prop(prop),
00386 m_running(true)
00387 {
00388 if (m_prop["inport_addr"] != "")
00389 {
00390 m_addr.set(m_prop["inport_addr"].c_str());
00391 }
00392 std::cout << "hostname: " << m_addr.get_host_name() << std::endl;
00393 }
00394
00406 virtual ~TcpServer(void)
00407 {
00408 }
00409
00410
00411
00412
00413
00414
00415
00416
00436 int start(void)
00437 {
00438
00439 if (m_acceptor.open(m_addr, &m_reactor) == -1)
00440 {
00441
00442 return -1;
00443 }
00444
00445
00446 m_port = m_acceptor.get_port_number();
00447
00448 return 0;
00449 }
00450
00474 virtual int open(void *args)
00475 {
00476 start();
00477 activate();
00478 return 0;
00479 }
00480
00502 virtual int svc(void)
00503 {
00504 m_reactor.owner(ACE_OS::thr_self());
00505 while (m_running)
00506 {
00507 std::cout << "handle_event" << std::endl;
00508 m_reactor.handle_events();
00509 }
00510 std::cout << "handle_event done" << std::endl;
00511 return 0;
00512 }
00513
00533 void run(void)
00534 {
00535 while (m_running)
00536 {
00537 std::cout << "handle_event run" << std::endl;
00538 m_reactor.handle_events();
00539 }
00540 std::cout << "handle_event run done" << std::endl;
00541 }
00542
00562 unsigned short getPortNumber(void)
00563 {
00564 return m_port;
00565 }
00566
00586 const char* getHostName(void)
00587 {
00588 return m_addr.get_host_name();
00589 }
00590
00591 private:
00592 TcpAcceptor<DataType> m_acceptor;
00593
00594 BufferBase<DataType>& m_buffer;
00595 Properties& m_prop;
00596
00597 bool m_running;
00598
00599 unsigned short m_port;
00600 ACE_INET_Addr m_addr;
00601
00602 ACE_Reactor m_reactor;
00603 };
00604
00605
00606
00607
00627 template <class DataType>
00628 class TcpHandler
00629 : public ACE_Event_Handler
00630 {
00631 public:
00651 TcpHandler(BufferBase<DataType>& buffer, Properties& prop)
00652 : m_buffer(buffer), m_prop(prop), m_pRecvBuffer(0),
00653 m_recvBufSize(1024), m_byteswap(true)
00654 {
00655 m_recvBufSize = atoi(m_prop.getProperty("buffer_size", "1024").c_str());
00656 std::cout << "m_recvBufSize: " << m_recvBufSize << std::endl;
00657 m_byteswap = toBool(m_prop["byteswap"], "YES", "NO", true);
00658 std::cout << "m_byteswap: " << m_prop["byteswap"] << std::endl;
00659 m_pRecvBuffer = new char[m_recvBufSize];
00660 }
00661
00673 virtual ~TcpHandler(void)
00674 {
00675 if (!m_pRecvBuffer)
00676 delete[] m_pRecvBuffer;
00677 }
00678
00704 int open(ACE_Reactor* reactor)
00705 {
00706
00707 m_reactor = reactor;
00708
00709 if (m_reactor->register_handler(this, ACE_Event_Handler::READ_MASK) == -1)
00710 {
00711
00712 return -1;
00713 }
00714 return 0;
00715 }
00716
00736 int close (void)
00737 {
00738 return this->handle_close(ACE_INVALID_HANDLE,
00739 ACE_Event_Handler::RWE_MASK);
00740 }
00741
00761 operator ACE_SOCK_Stream &(void)
00762 {
00763 return this->m_clientStream;
00764 }
00765
00766 protected:
00786 ACE_HANDLE get_handle (void) const
00787 {
00788 return this->m_clientStream.get_handle();
00789 }
00790
00818 int handle_input(ACE_HANDLE)
00819 {
00820
00821
00822
00823
00824
00825 long int len(0);
00826 char tmpbuf[sizeof(CORBA::ULong)];
00827 CORBA::ULong datasize;
00828 len = this->m_clientStream.recv(tmpbuf, sizeof(CORBA::ULong));
00829
00830 if (len > 0)
00831 {
00832 cdrMemoryStream cdrSize(tmpbuf);
00833 cdrSize.setByteSwapFlag(m_byteswap);
00834 datasize <<= cdrSize;
00835 datasize -= sizeof(CORBA::ULong);
00836 if ((long int)datasize > m_recvBufSize)
00837 {
00838 std::cout << "recv buffer reallocated" << std::endl;
00839 delete[] m_pRecvBuffer;
00840 m_recvBufSize = datasize;
00841 m_pRecvBuffer = new char[m_recvBufSize];
00842 std::cout << "new buffer size " << m_recvBufSize << std::endl;
00843 }
00844
00845 int recvd(0);
00846 do
00847 {
00848 recvd += this->m_clientStream.recv(m_pRecvBuffer + recvd,
00849 datasize);
00850 }
00851 while (recvd < (int)datasize);
00852
00853 if (recvd == (int)datasize)
00854 {
00855 cdrMemoryStream cdr(m_pRecvBuffer);
00856 cdr.setByteSwapFlag(m_byteswap);
00857 m_data <<= cdr;
00858 m_buffer.write(m_data);
00859 }
00860 else
00861 {
00862 std::cout << "invalid data length" << std::endl;
00863 std::cout << "recvs: " << recvd << std::endl;
00864 std::cout << "cdrlen: " << datasize << std::endl;
00865 return -1;
00866 }
00867 }
00868 else return -1;
00869
00870 return 0;
00871 }
00872
00900 int handle_close(ACE_HANDLE, ACE_Reactor_Mask mask)
00901 {
00902 m_reactor->remove_handler(this, mask|ACE_Event_Handler::DONT_CALL);
00903 m_clientStream.close();
00904 delete this;
00905 return 0;
00906 }
00907
00908 protected:
00916 BufferBase<DataType>& m_buffer;
00917
00925 Properties& m_prop;
00926
00934 char* m_pRecvBuffer;
00935
00943 long int m_recvBufSize;
00951 bool m_byteswap;
00952
00960 ACE_SOCK_Stream m_clientStream;
00968 ACE_Reactor* m_reactor;
00976 DataType m_data;
00977 };
00978 };
00979 #endif // TcpSockServer_h