TcpSockServer.h

説明を見る。
00001 // -*- C++ -*-
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   // TCP Server classes
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       // Getting real acceptor's address and port number.
00147       this->m_peerAcceptor.get_local_addr(m_addr);
00148       
00149       // Set handler
00150       int ret;
00151       ret = m_reactor->register_handler(this, ACE_Event_Handler::ACCEPT_MASK);
00152       return ret;
00153     }
00154     
00155     /***
00156      * @if jp
00157      *
00158      * @brief アドレスの取得
00159      * 
00160      * オープン時に設定したアドレスを返す
00161      *
00162      * @else
00163      *
00164      * @brief Get the address
00165      *
00166      * Return the address set at the time of opening.
00167      *
00168      * @endif
00169      */
00170     /*
00171       ACE_INET_Addr get_addr() const
00172       {
00173       return m_addr;
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           // accept failed
00252           return -1;
00253         }
00254       
00255       // start service handler
00256       if (m_svcHandler->open(m_reactor) == -1)
00257         {
00258           // connection closed
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   // TCP Server class
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         void setAddr(const char* addr)
00412         {
00413         m_addr.set(addr);
00414         }
00415     */
00416     
00436     int start(void)
00437     {
00438       // open socket and acceptor
00439       if (m_acceptor.open(m_addr, &m_reactor) == -1)
00440         {
00441           // opening acceptor fail
00442           return -1;
00443         }
00444       
00445       // get real port number
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   // TCP handler class
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       //      std::cout << "Tcphandler::open()" << std::endl;
00707       m_reactor = reactor;
00708       
00709       if (m_reactor->register_handler(this, ACE_Event_Handler::READ_MASK) == -1)
00710         {
00711           // can't register with reactor 
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       // data format
00821       // [length][client data]
00822       // length = sizeof ULong + client data length
00823       
00824       // get CDR data size
00825       long int len(0);
00826       char tmpbuf[sizeof(CORBA::ULong)];
00827       CORBA::ULong datasize; // actual data size except header
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 }; // namespace RTC
00979 #endif // TcpSockServer_h

OpenRTMに対してSun May 24 14:08:25 2009に生成されました。  doxygen 1.5.3