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

OpenRTMに対してWed May 21 05:17:25 2008に生成されました。  doxygen 1.5.3