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