l7vsd/unit_tests/session_test/tcp_session/dummyclass.h

   1 // Dummy Class define
   2
   3 #define VIRTUALSERVICE_H
   4 #define TCP_SOCKET_H
   5 #define TCP_SSL_SOCKET_H
   6 #define MODULE_BASE_H
   7 #define REALSERVER_H
   8
   9 #include <boost/asio/ssl.hpp>
  10
  11 namespace l7vs{
  12
  13     // Dummy module base class
  14     class  module_base{
  15         public:
  16             module_base( std::string in_modulename ){};
  17             ~module_base(){};
  18     };
  19
  20     // Dummy realserver class
  21     class  realserver{
  22         realserver(){};
  23         ~realserver(){};
  24     };
  25 }
  26
  27 #include "protocol_module_base.h"
  28 #include "tcp_socket_option.h"
  29 #include "virtualservice_element.h"
  30
  31 typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket>  ssl_socket;
  32
  33 namespace l7vs{
  34     class    tcp_session;
  35
  36     // test protocol module class
  37     class test_protocol_module : public protocol_module_base{
  38         public:
  39             test_protocol_module( std::string in_modulename ) : protocol_module_base(in_modulename ){
  40
  41             }
  42             ~test_protocol_module(){};
  43
  44             //! initialize function. called from module control. module loaded call
  45             //! @param[in]    realserver list iterator begin function object type
  46             //!    @param[in]    realserver list iterator end function object type
  47             //! @param[in]    realserver list iterator next function object type
  48             //! @param[in]    realserver list mutex lock function object type.
  49             //! @param[in]    realserver list mutex unlock function object type
  50             void    initialize(
  51                     rs_list_itr_func_type    inlist_begin,
  52                     rs_list_itr_func_type    inlist_end,
  53                     rs_list_itr_next_func_type    inlist_next,
  54                     boost::function< void( void ) >    inlist_lock,
  55                     boost::function< void( void ) >    inlist_unlock ){};
  56
  57             //! finalize called from module control. module unloaded call.
  58             void    finalize(){};
  59
  60             //! sorry support check
  61             //! @return true sorry mode is supported.
  62             //! @return false sorry mode is unsupported.
  63             bool    is_use_sorry(){
  64                 return true;
  65             };
  66
  67             void get_option_info(std::string&){};
  68
  69
  70             //! realserver list update event
  71             void    handle_rslist_update(){};
  72
  73             //! module parameter check.used by l7vsadm
  74             //! @param[in]    module paramter string list
  75             //! @return    result.flag true is parameter is noproblem.
  76             //! @return result.flag false is paramter is problem.
  77             protocol_module_base::check_message_result    check_parameter( const std::vector<std::string>& args ){
  78                 check_message_result res;
  79                 return res;
  80             };
  81
  82             //! parameter set
  83             //! @param[in] module paramter string list
  84             //! @return    result.flag true is parameter is noproblem.
  85             //! @return result.flag false is paramter is problem.
  86             protocol_module_base::check_message_result    set_parameter( const std::vector<std::string>& args ){
  87                 check_message_result res;
  88                 return res;
  89             };
  90
  91             //! parameter add
  92             //! @param[in] module paramter string list
  93             //! @return    result.flag true is parameter is noproblem.
  94             //! @return result.flag false is paramter is problem.
  95             protocol_module_base::check_message_result    add_parameter( const std::vector<std::string>& args )
  96             {
  97                 check_message_result res;
  98                 return res;
  99             };
 100
 101             //! TCP/IP scheduled function registation.
 102             //! @param[in] schedule module TCP/IP scheduled function object type
 103             void    register_schedule( protocol_module_base::tcp_schedule_func_type inschedule ){
 104             };
 105
 106             //! UDP scheduled function registation
 107             //! @param[in] schedule module UDP scheduled funtion object type
 108             void    register_schedule( protocol_module_base::udp_schedule_func_type inschedule ){
 109             };
 110
 111             //! called from session initialzie use in upstream_thread
 112             //! @param[in]    upstream thread id.
 113             //! @param[in]    downstream thread id
 114             //! @return        session use EVENT mode.
 115             protocol_module_base::EVENT_TAG    handle_session_initialize(
 116                     const boost::thread::id up_thread_id,
 117             const boost::thread::id down_thread_id,
 118             const boost::asio::ip::tcp::endpoint& client_endpoint_tcp,
 119             const boost::asio::ip::udp::endpoint& client_endpoint_udp ){
 120
 121                 handle_session_initialize_in_up_thread_id = up_thread_id;
 122                 handle_session_initialize_in_down_thread_id = down_thread_id;
 123                 handle_session_initialize_in_client_endpoint_tcp = client_endpoint_tcp;
 124                 handle_session_initialize_in_client_endpoint_udp = client_endpoint_udp;
 125
 126                 return handle_session_initialize_res_tag;
 127
 128             };
 129             protocol_module_base::EVENT_TAG handle_session_initialize_res_tag;
 130             boost::thread::id handle_session_initialize_in_up_thread_id;
 131             boost::thread::id handle_session_initialize_in_down_thread_id;
 132             boost::asio::ip::tcp::endpoint handle_session_initialize_in_client_endpoint_tcp;
 133             boost::asio::ip::udp::endpoint handle_session_initialize_in_client_endpoint_udp;
 134
 135             //! called from session finalize use in upstream thread.
 136             //! @param[in]    upstream thread id.
 137             //! @param[in]    downstream thread id
 138             //! @return        session use EVENT mode.
 139             protocol_module_base::EVENT_TAG    handle_session_finalize(
 140                     const boost::thread::id up_thread_id,
 141             const boost::thread::id down_thread_id ){
 142
 143                 handle_session_finalize_in_up_thread_id = up_thread_id;
 144                 handle_session_finalize_in_down_thread_id = down_thread_id;
 145                 return     handle_session_finalize_res_tag;
 146             };
 147             protocol_module_base::EVENT_TAG handle_session_finalize_res_tag;
 148             boost::thread::id handle_session_finalize_in_up_thread_id;
 149             boost::thread::id handle_session_finalize_in_down_thread_id;
 150
 151             //! called from after session accept.in client socket use in upstream thread.
 152             //! @param[in]    upstream thread id.
 153             //! @return        session use EVENT mode.
 154             protocol_module_base::EVENT_TAG    handle_accept( const boost::thread::id thread_id ){
 155                 handle_accept_in_thread_id = thread_id;
 156                 return handle_accept_res_tag;
 157             };
 158             protocol_module_base::EVENT_TAG handle_accept_res_tag;
 159             boost::thread::id handle_accept_in_thread_id;
 160
 161             //! called from after session recv in client socket. use in upstream thread.
 162             //! @param[in]    upstream thread id
 163             //! @param[in]    recive buffer refarence.
 164             //! @param[in]    recive length
 165             //! @return        session use EVENT mode.
 166             protocol_module_base::EVENT_TAG    handle_client_recv(
 167                     const boost::thread::id thread_id,
 168             const boost::array<char,MAX_BUFFER_SIZE>& recvbuffer,
 169             const size_t recvlen ){
 170
 171                 handle_client_recv_in_thread_id = thread_id;
 172                 handle_client_recv_in_recvbuffer = recvbuffer;
 173                 handle_client_recv_in_recvlen = recvlen;
 174                 return handle_client_recv_res_tag;
 175             };
 176             protocol_module_base::EVENT_TAG handle_client_recv_res_tag;
 177             boost::thread::id handle_client_recv_in_thread_id;
 178             boost::array<char,MAX_BUFFER_SIZE> handle_client_recv_in_recvbuffer;
 179             size_t handle_client_recv_in_recvlen;
 180
 181             //! called from after realserver select.use in upstream thread.
 182             //! @param[in]    upstream thread id
 183             //! @param[out]    realserver TCP endpoint
 184             //! @return        session use EVENT mode.
 185             protocol_module_base::EVENT_TAG    handle_realserver_select(
 186                     const boost::thread::id thread_id,
 187             boost::asio::ip::tcp::endpoint& rs_endpoint ){
 188
 189                 handle_realserver_select_in_thread_id = thread_id;
 190                 rs_endpoint = handle_realserver_select_out_rs_endpoint;
 191                 return handle_realserver_select_tcp_res_tag;
 192             };
 193             protocol_module_base::EVENT_TAG handle_realserver_select_tcp_res_tag;
 194             boost::thread::id handle_realserver_select_in_thread_id;
 195             boost::asio::ip::tcp::endpoint handle_realserver_select_out_rs_endpoint;
 196
 197             //! called from after realserver select
 198             //! @param[in]    upstream thread id
 199             //! @param[out]    realserver UDP endpoint
 200             //! @param[out]    sendbudffer reference
 201             //! @param[out]    send data length
 202             //! @return        session use EVENT mode.
 203             protocol_module_base::EVENT_TAG    handle_realserver_select(
 204                 const boost::thread::id thread_id,
 205                 boost::asio::ip::udp::endpoint& rs_endpoint,
 206                 boost::array<char,MAX_BUFFER_SIZE>& sendbuffer,
 207                 size_t& datalen ){
 208
 209                 handle_realserver_select_udp_thread_id = thread_id;
 210                 rs_endpoint = handle_realserver_select_udp_rs_endpoint;
 211                 sendbuffer = handle_realserver_select_udp_sendbuffer;
 212                 datalen = handle_realserver_select_udp_datalen;
 213                 return handle_realserver_select_udp_res_tag;
 214             };
 215             protocol_module_base::EVENT_TAG handle_realserver_select_udp_res_tag;
 216             boost::thread::id handle_realserver_select_udp_thread_id;
 217             boost::asio::ip::udp::endpoint handle_realserver_select_udp_rs_endpoint;
 218             boost::array<char,MAX_BUFFER_SIZE> handle_realserver_select_udp_sendbuffer;
 219             size_t  handle_realserver_select_udp_datalen;
 220
 221             //! called from after realserver connect
 222             //! @param[in]    upstream thread id
 223             //! @param[out]    sendbuffer reference
 224             //! @param[out]    send data length
 225             //! @return        session use EVENT mode.
 226             protocol_module_base::EVENT_TAG    handle_realserver_connect(
 227                 const boost::thread::id thread_id,
 228                 boost::array<char,MAX_BUFFER_SIZE>& sendbuffer,
 229                 size_t& datalen ){
 230
 231                 handle_realserver_connect_thread_id = thread_id;
 232                 sendbuffer = handle_realserver_connect_sendbuffer;
 233                 datalen = handle_realserver_connect_datalen;
 234                 return handle_realserver_connect_res_tag;
 235             };
 236             protocol_module_base::EVENT_TAG handle_realserver_connect_res_tag;
 237             boost::thread::id handle_realserver_connect_thread_id;
 238             boost::array<char,MAX_BUFFER_SIZE> handle_realserver_connect_sendbuffer;
 239             size_t  handle_realserver_connect_datalen;
 240
 241             //! called from after realserver connection fail
 242             //! @param[in]    upstream thread id
 243             //! @param[in]    fail realserver endpoint reference
 244             //! @return        session use EVENT mode.
 245             protocol_module_base::EVENT_TAG    handle_realserver_connection_fail(
 246                 const boost::thread::id thread_id,
 247                 const boost::asio::ip::tcp::endpoint& rs_endpoint ){
 248
 249                 handle_realserver_connection_fail_thread_id = thread_id;
 250                 handle_realserver_connection_fail_rs_endpoint = rs_endpoint;
 251                 return    handle_realserver_connection_fail_res_tag;
 252             };
 253             protocol_module_base::EVENT_TAG handle_realserver_connection_fail_res_tag;
 254             boost::thread::id handle_realserver_connection_fail_thread_id;
 255             boost::asio::ip::tcp::endpoint handle_realserver_connection_fail_rs_endpoint;
 256
 257             //! called from after realserver send.
 258             //! @param[in]    upstream thread id
 259             //! @return        session use EVENT mode.
 260             protocol_module_base::EVENT_TAG    handle_realserver_send(
 261                 const boost::thread::id thread_id ){
 262
 263                 handle_realserver_send_in_thread_id = thread_id;
 264                 return handle_realserver_send_res_tag;
 265             };
 266             protocol_module_base::EVENT_TAG handle_realserver_send_res_tag;
 267             boost::thread::id handle_realserver_send_in_thread_id;
 268
 269             //! called from after sorryserver select
 270             //! @param[in]    upstream thread id
 271             //! @param[in]    sorryserver endppiont reference
 272             //! @return        session use EVENT mode.
 273             protocol_module_base::EVENT_TAG    handle_sorryserver_select(
 274                 const boost::thread::id thread_id,
 275                 boost::asio::ip::tcp::endpoint& sorry_endpoint ){
 276
 277                 handle_sorryserver_select_in_thread_id = thread_id;
 278                 handle_sorryserver_select_in_sorry_endpoint = sorry_endpoint;
 279                 sorry_endpoint = handle_sorryserver_select_out_sorry_endpoint;
 280                 return handle_sorryserver_select_res_tag;
 281             };
 282             protocol_module_base::EVENT_TAG handle_sorryserver_select_res_tag;
 283             boost::thread::id handle_sorryserver_select_in_thread_id;
 284             boost::asio::ip::tcp::endpoint handle_sorryserver_select_out_sorry_endpoint;
 285             boost::asio::ip::tcp::endpoint handle_sorryserver_select_in_sorry_endpoint;
 286
 287             //! called from after sorryserver connect
 288             //!    @param[in]    upstream thread id
 289             //! @param[out]    send buffer reference.
 290             //! @param[out]    send length
 291             //! @return        session use EVENT mode.
 292             protocol_module_base::EVENT_TAG    handle_sorryserver_connect(
 293                 const boost::thread::id thread_id,
 294                 boost::array<char,MAX_BUFFER_SIZE>& sendbuffer,
 295                 size_t& datalen ){
 296
 297                 handle_sorryserver_connect_thread_id = thread_id;
 298                 sendbuffer = handle_sorryserver_connect_sendbuffer;
 299                 datalen = handle_sorryserver_connect_datalen;
 300                 return handle_sorryserver_connect_res_tag;
 301             };
 302             protocol_module_base::EVENT_TAG handle_sorryserver_connect_res_tag;
 303             boost::thread::id handle_sorryserver_connect_thread_id;
 304             boost::array<char,MAX_BUFFER_SIZE> handle_sorryserver_connect_sendbuffer;
 305             size_t  handle_sorryserver_connect_datalen;
 306
 307             //! called from after sorryserver connection fail
 308             //! @param[in]    upstream thread id
 309             //! @param[in]    sorryserver endpoint reference.
 310             //! @return        session use EVENT mode.
 311             protocol_module_base::EVENT_TAG    handle_sorryserver_connection_fail(
 312                 const boost::thread::id thread_id,
 313                 const boost::asio::ip::tcp::endpoint& sorry_endpoint ){
 314
 315                 handle_sorryserver_connection_fail_thread_id = thread_id;
 316                 handle_sorryserver_connection_fail_sorry_endpoint = sorry_endpoint;
 317                 return handle_sorryserver_connection_fail_res_tag;
 318             };
 319             protocol_module_base::EVENT_TAG handle_sorryserver_connection_fail_res_tag;
 320             boost::thread::id handle_sorryserver_connection_fail_thread_id;
 321             boost::asio::ip::tcp::endpoint handle_sorryserver_connection_fail_sorry_endpoint;
 322
 323             //! called from after sorryserver send
 324             //! @param[in]    upstream thread id
 325             //! @return        session use EVENT mode.
 326             protocol_module_base::EVENT_TAG    handle_sorryserver_send( const boost::thread::id thread_id ){
 327
 328                 handle_sorryserver_send_in_thread_id = thread_id;
 329                 return handle_sorryserver_send_res_tag;
 330             };
 331             protocol_module_base::EVENT_TAG handle_sorryserver_send_res_tag;
 332             boost::thread::id handle_sorryserver_send_in_thread_id;
 333
 334             //! called from after realserver recvive for TCP/IP
 335             //! @param[in]    downstream thread id
 336             //! @param[in]    realserver TCP/IP endpoint reference
 337             //! @param[in]    realserver recive buffer reference.
 338             //! @param[in]    recv data length
 339             //! @return        session use EVENT mode.
 340             protocol_module_base::EVENT_TAG    handle_realserver_recv(
 341                 const boost::thread::id thread_id,
 342                 const boost::asio::ip::tcp::endpoint& rs_endpoint,
 343                 const boost::array<char,MAX_BUFFER_SIZE>& recvbuffer,
 344                 const size_t recvlen ){
 345
 346                 handle_realserver_recv_tcp_in_thread_id = thread_id;
 347                 handle_realserver_recv_tcp_in_rs_endpoint = rs_endpoint;
 348                 handle_realserver_recv_tcp_in_recvbuffer = recvbuffer;
 349                 handle_realserver_recv_tcp_in_recvlen = recvlen;
 350                 return handle_realserver_recv_tcp_res_tag;
 351             };
 352             protocol_module_base::EVENT_TAG handle_realserver_recv_tcp_res_tag;
 353             boost::thread::id handle_realserver_recv_tcp_in_thread_id;
 354             boost::asio::ip::tcp::endpoint handle_realserver_recv_tcp_in_rs_endpoint;
 355             boost::array<char,MAX_BUFFER_SIZE> handle_realserver_recv_tcp_in_recvbuffer;
 356             size_t  handle_realserver_recv_tcp_in_recvlen;
 357
 358             //! called from after realserver recive.for UDP
 359             //! @param[in]    downstream thread id
 360             //! @param[in]    realserver UDP endpoint reference
 361             //! @param[in]    recive from realserver buffer reference
 362             //! @param[in]    recv data length
 363             //! @return        session use EVENT mode.
 364             protocol_module_base::EVENT_TAG    handle_realserver_recv(
 365                 const boost::thread::id thread_id,
 366                 const boost::asio::ip::udp::endpoint& rs_endpoint,
 367                 const boost::array<char,MAX_BUFFER_SIZE>& recvbuffer,
 368                 const size_t recvlen ){
 369
 370                 handle_realserver_recv_udp_thread_id = thread_id;
 371                 handle_realserver_recv_udp_rs_endpoint = rs_endpoint;
 372                 handle_realserver_recv_udp_recvbuffer = recvbuffer;
 373                 handle_realserver_recv_udp_recvlen = recvlen;
 374                 return     handle_realserver_recv_udp_res_tag;
 375             };
 376             protocol_module_base::EVENT_TAG handle_realserver_recv_udp_res_tag;
 377             boost::thread::id handle_realserver_recv_udp_thread_id;
 378             boost::asio::ip::udp::endpoint handle_realserver_recv_udp_rs_endpoint;
 379             boost::array<char,MAX_BUFFER_SIZE> handle_realserver_recv_udp_recvbuffer;
 380             size_t  handle_realserver_recv_udp_recvlen;
 381
 382             //! called from after sorryserver recive
 383             //! @param[in]    downstream thread id
 384             //! @param[in]    sorryserver endpoint reference
 385             //! @param[in]    recive from realserver buffer reference.
 386             //! @param[in]    recv data length
 387             //! @return     session use EVENT mode
 388             protocol_module_base::EVENT_TAG    handle_sorryserver_recv(
 389                 const boost::thread::id thread_id,
 390                 const boost::asio::ip::tcp::endpoint& sorry_endpoint,
 391                 const boost::array<char,MAX_BUFFER_SIZE>& recvbuffer,
 392                 const size_t recvlen ){
 393
 394                 handle_sorryserver_recv_in_thread_id = thread_id;
 395                 handle_sorryserver_recv_in_sorry_endpoint = sorry_endpoint;
 396                 handle_sorryserver_recv_in_recvbuffer = recvbuffer;
 397                 handle_sorryserver_recv_in_recvlen = recvlen;
 398                 return handle_sorryserver_recv_res_tag;
 399             };
 400             protocol_module_base::EVENT_TAG handle_sorryserver_recv_res_tag;
 401             boost::thread::id handle_sorryserver_recv_in_thread_id;
 402             boost::asio::ip::tcp::endpoint handle_sorryserver_recv_in_sorry_endpoint;
 403             boost::array<char,MAX_BUFFER_SIZE> handle_sorryserver_recv_in_recvbuffer;
 404             size_t  handle_sorryserver_recv_in_recvlen;
 405
 406             //! called from UPSTEEARM thread. make module original message.
 407             //! @param[in]    downstream thread id.
 408             //! @return         session use EVENT mode
 409             protocol_module_base::EVENT_TAG    handle_response_send_inform(
 410                 const boost::thread::id thread_id ){
 411
 412                 handle_response_send_inform_thread_id = thread_id;
 413                 return handle_response_send_inform_res_tag;
 414             };
 415             protocol_module_base::EVENT_TAG handle_response_send_inform_res_tag;
 416             boost::thread::id handle_response_send_inform_thread_id;
 417
 418             //! called from after client connection check. use TCP/IP only. create client send message.
 419             //! @param[in]    downstream thread id
 420             //! @param[out]    send budffer reference
 421             //! @param[out]    send data length
 422             //! @return     session use EVENT mode
 423             protocol_module_base::EVENT_TAG    handle_client_connection_check(
 424                 const boost::thread::id thread_id,
 425                 boost::array<char,MAX_BUFFER_SIZE>& sendbuffer,
 426                 size_t& datalen ){
 427
 428                 handle_client_connection_check_thread_id = thread_id;
 429                 sendbuffer = handle_client_connection_check_sendbuffer;
 430                 datalen = handle_client_connection_check_datalen;
 431                 return handle_client_connection_check_res_tag;
 432             };
 433             protocol_module_base::EVENT_TAG handle_client_connection_check_res_tag;
 434             boost::thread::id handle_client_connection_check_thread_id;
 435             boost::array<char,MAX_BUFFER_SIZE> handle_client_connection_check_sendbuffer;
 436             size_t  handle_client_connection_check_datalen;
 437
 438             //! called from after client select. use UDP only
 439             //! @param[in]    downstream thread id
 440             //!    @param[in]    client udp endpoint
 441             //! @param[out]    send buffer reference
 442             //! @param[out]    send data length
 443             //! @return     session use EVENT mode
 444             protocol_module_base::EVENT_TAG    handle_client_select(
 445                 const boost::thread::id thread_id,
 446                 boost::asio::ip::udp::endpoint& cl_endpoint,
 447                 boost::array<char,MAX_BUFFER_SIZE>& sendbuffer,
 448                 size_t& datalen ){
 449
 450                 handle_client_select_thread_id = thread_id;
 451                 handle_client_select_cl_endpoint = cl_endpoint;
 452                 sendbuffer = handle_client_select_sendbuffer;
 453                 datalen = handle_client_select_datalen;
 454                 return handle_client_select_res_tag;
 455             };
 456             protocol_module_base::EVENT_TAG handle_client_select_res_tag;
 457             boost::thread::id handle_client_select_thread_id;
 458             boost::asio::ip::udp::endpoint handle_client_select_cl_endpoint;
 459             boost::array<char,MAX_BUFFER_SIZE> handle_client_select_sendbuffer;
 460             size_t  handle_client_select_datalen;
 461             //!    called from after client send
 462             //!    @param[in]    downstream thread id
 463             //! @return     session use EVENT mode
 464             protocol_module_base::EVENT_TAG    handle_client_send( const boost::thread::id thread_id ){
 465
 466                 handle_client_send_in_thread_id = thread_id;
 467                 return handle_client_send_res_tag;
 468             };
 469             protocol_module_base::EVENT_TAG handle_client_send_res_tag;
 470             boost::thread::id handle_client_send_in_thread_id;
 471
 472             //! call from client disconnect event. use upstream thread and downstream thread.
 473             //! @param[in]    upstream and downstream thread id( check! one thread one event! )
 474             //! @return     session use EVENT mode
 475             protocol_module_base::EVENT_TAG    handle_client_disconnect(const boost::thread::id thread_id ){
 476
 477                 handle_client_disconnect_thread_id = thread_id;
 478                 return handle_client_disconnect_res_tag;
 479             };
 480             protocol_module_base::EVENT_TAG handle_client_disconnect_res_tag;
 481             boost::thread::id handle_client_disconnect_thread_id;
 482
 483             //! call from sorry mode event. use upstream thread and downstream thread
 484             //! @param[in]    upstream and downstream thread id( check! one thread one event and first time call pattern )
 485             //! @return     session use EVENT mode
 486             protocol_module_base::EVENT_TAG    handle_sorry_enable( const boost::thread::id thread_id ){
 487
 488                 handle_sorry_enable_thread_id = thread_id;
 489                 return handle_sorry_enable_res_tag;
 490             };
 491             protocol_module_base::EVENT_TAG handle_sorry_enable_res_tag;
 492             boost::thread::id handle_sorry_enable_thread_id;
 493
 494             //! call from sorry mode disable. use upstream thread and downstream thread.
 495             //! @param[in]    upstream and downstream thread id( check! one thread one event )
 496             //! @return     session use EVENT mode
 497             protocol_module_base::EVENT_TAG    handle_sorry_disable( const boost::thread::id thread_id ){
 498
 499                 handle_sorry_disable_thread_id = thread_id;
 500                 return handle_sorry_disable_res_tag;
 501             };
 502             protocol_module_base::EVENT_TAG handle_sorry_disable_res_tag;
 503             boost::thread::id handle_sorry_disable_thread_id;
 504
 505             //! call from realserver disconnect. use upstream thread and downstream thread
 506             //! @param[in]    upstream and downstream thread id( check! one thread one event )
 507             //! @param[in]    disconnected realserver endpoint.
 508             //! @return     session use EVENT mode
 509             protocol_module_base::EVENT_TAG    handle_realserver_disconnect(
 510                 const boost::thread::id thread_id,
 511                 const boost::asio::ip::tcp::endpoint& rs_endpoint ){
 512
 513                 handle_realserver_disconnect_thread_id = thread_id;
 514                 handle_realserver_disconnect_rs_endpoint = rs_endpoint;
 515                 handle_realserver_disconnect_rs_endpoint_list.push_back(rs_endpoint);
 516                 return handle_realserver_disconnect_res_tag;
 517             };
 518             protocol_module_base::EVENT_TAG handle_realserver_disconnect_res_tag;
 519             boost::thread::id handle_realserver_disconnect_thread_id;
 520             boost::asio::ip::tcp::endpoint handle_realserver_disconnect_rs_endpoint;
 521             std::list< boost::asio::ip::tcp::endpoint > handle_realserver_disconnect_rs_endpoint_list;
 522
 523             //! call from sorry server disconnect. use upstraem thread and downstream thread
 524             //! @param[in]    upstream and downstream thread id( check! one thread one event )
 525             //! @param[in]    disconnect sorryserver endpoint
 526             //! @return        session use EVENT mode
 527             protocol_module_base::EVENT_TAG    handle_sorryserver_disconnect(
 528                 const boost::thread::id thread_id,
 529                 const boost::asio::ip::tcp::endpoint& sorry_endpoint ){
 530
 531                 handle_sorryserver_disconnect_thread_id = thread_id;
 532                 handle_sorryserver_disconnect_rs_endpoint = sorry_endpoint;
 533                 return handle_sorryserver_disconnect_res_tag;
 534             };
 535             protocol_module_base::EVENT_TAG  handle_sorryserver_disconnect_res_tag;
 536             boost::thread::id handle_sorryserver_disconnect_thread_id;
 537             boost::asio::ip::tcp::endpoint handle_sorryserver_disconnect_rs_endpoint;
 538
 539             //! call from realserver disconnect. use upstream thread and downstream thread.
 540             //! @param[in]    upstream and downstream thread id( check! one thread one event )
 541             //! @param[in]    disconnect realserver endpoint
 542             //! @return        session use EVENT mode.
 543             protocol_module_base::EVENT_TAG    handle_realserver_close(
 544                 const boost::thread::id thread_id,
 545                 const boost::asio::ip::udp::endpoint& rs_endpoint ){
 546
 547                 handle_realserver_close_thread_id = thread_id;
 548                 handle_realserver_close_rs_endpoint = rs_endpoint;
 549                 return    handle_realserver_close_res_tag;
 550             };
 551             protocol_module_base::EVENT_TAG handle_realserver_close_res_tag;
 552             boost::thread::id handle_realserver_close_thread_id;
 553             boost::asio::ip::udp::endpoint handle_realserver_close_rs_endpoint;
 554
 555     };
 556
 557 /*
 558     class     virtualservice_element{
 559         public:
 560             virtualservice_element(){};
 561             ~virtualservice_element(){};
 562             boost::asio::ip::tcp::endpoint
 563                             sorry_endpoint;
 564     };
 565 */
 566
 567     // Dummy virtualservice_tcp Class
 568     class    virtualservice_tcp{
 569         public:
 570             virtualservice_tcp(){
 571                 get_protocol_module_res = NULL;
 572             };
 573             ~virtualservice_tcp(){};
 574
 575             virtualservice_element my_element;
 576
 577             virtualservice_element& get_element(){
 578                 return my_element;
 579             };
 580
 581             unsigned long long            get_qos_upstream(){
 582                 return get_qos_upstream_res;
 583             };
 584             unsigned long long get_qos_upstream_res;
 585             unsigned long long            get_qos_downstream(){
 586                 return get_qos_downstream_res;
 587             };
 588             unsigned long long get_qos_downstream_res;
 589             unsigned long long            get_throughput_upstream(){
 590                 return get_throughput_upstream_res;
 591             };
 592             unsigned long long get_throughput_upstream_res;
 593             unsigned long long            get_throughput_downstream(){
 594                 return get_throughput_downstream_res;
 595             };
 596             unsigned long long get_throughput_downstream_res;
 597             void update_up_recv_size( unsigned long long size){
 598                 update_up_recv_size_in = size;
 599             };
 600             unsigned long long update_up_recv_size_in;
 601             void update_up_send_size( unsigned long long size){
 602                 update_up_send_size_in = size;
 603             };
 604             unsigned long long update_up_send_size_in;
 605             void update_down_recv_size( unsigned long long size){
 606                 update_down_recv_size_in = size;
 607             };
 608             unsigned long long update_down_recv_size_in;
 609             void update_down_send_size( unsigned long long size){
 610                 update_down_send_size_in = size;
 611             };
 612             unsigned long long update_down_send_size_in;
 613
 614             protocol_module_base* get_protocol_module(){
 615                 return get_protocol_module_res;
 616             };
 617             protocol_module_base* get_protocol_module_res;
 618
 619             void    release_session( const tcp_session* session_ptr ){
 620                 release_session_ptr = const_cast<tcp_session*>(session_ptr);
 621             };
 622             tcp_session*        release_session_ptr;
 623
 624             void connection_active( const boost::asio::ip::tcp::endpoint& active_endpoint){
 625                 connection_active_list.push_back(active_endpoint);
 626             };
 627             std::list<boost::asio::ip::tcp::endpoint> connection_active_list;
 628
 629             void connection_inactive( const boost::asio::ip::tcp::endpoint& inactive_endpoint){
 630                 connection_inactive_list.push_back(inactive_endpoint);
 631             };
 632             std::list<boost::asio::ip::tcp::endpoint> connection_inactive_list;
 633
 634             unsigned long long get_wait_upstream(){
 635                 return get_wait_upstream_res;
 636             }
 637             unsigned long long get_wait_upstream_res;
 638
 639             unsigned long long get_wait_downstream(){
 640                 return get_wait_downstream_res;
 641             }
 642             unsigned long long get_wait_downstream_res;
 643
 644     };
 645
 646     // Dummy tcp_socket Class
 647     class    tcp_socket{
 648         public:
 649             static bool connect_res;
 650             static boost::asio::ip::tcp::endpoint connect_connect_endpoint;
 651             static boost::system::error_code* connect_ec;
 652             static bool connect_call_check;
 653             static bool set_non_blocking_mode_res;
 654             static boost::system::error_code set_non_blocking_mode_ec;
 655             static bool is_connect;
 656
 657
 658 //            //! tcp_socket_option
 659 //            struct tcp_socket_option_info{
 660 //                //! TCP_NODELAY   (false:not set,true:set option)
 661 //                bool nodelay_opt;
 662 //                //! TCP_NODELAY option value  (false:off,true:on)
 663 //                bool nodelay_val;
 664 //                //! TCP_CORK      (false:not set,true:set option)
 665 //                bool cork_opt;
 666 //                //! TCP_CORK option value     (false:off,true:on)
 667 //                bool cork_val;
 668 //                //! TCP_QUICKACK  (false:not set,true:set option)
 669 //                bool quickack_opt;
 670 //                //! TCP_QUICKACK option value (false:off,true:on)
 671 //                bool quickack_val;
 672 //            };
 673
 674             tcp_socket(boost::asio::io_service& io) :
 675                     my_socket(io){
 676                 opt_info.nodelay_opt = false;
 677                 opt_info.cork_opt = false;
 678                 opt_info.quickack_opt = false;
 679             };
 680
 681
 682             tcp_socket(boost::asio::io_service& io,const tcp_socket_option_info set_option) :
 683                 my_socket(io),
 684                 opt_info(set_option){
 685             };
 686             ~tcp_socket(){};
 687
 688             boost::asio::ip::tcp::socket& get_socket(){
 689                 return my_socket;
 690             };
 691
 692             boost::asio::ip::tcp::socket my_socket;
 693             tcp_socket_option_info opt_info;
 694
 695             //! accept
 696             void accept(){};
 697
 698             //! @param[in]        connect_endpoint is connection endpoint
 699             //! @param[out]        ec is reference error code object
 700             bool connect(const boost::asio::ip::tcp::endpoint connect_endpoint,boost::system::error_code& ec){
 701                 tcp_socket::connect_call_check = true;
 702                 tcp_socket::connect_connect_endpoint = connect_endpoint;
 703                 tcp_socket::connect_ec = &ec;
 704                 if(tcp_socket::is_connect){
 705                     my_socket.connect(connect_endpoint,ec);
 706                 }
 707                 return tcp_socket::connect_res;
 708             };
 709
 710
 711
 712             //! close socket
 713             //! @param[out]        ec is reference error code object
 714             //! @return         true is socket close
 715             //! @return         false is not open socket
 716             bool close(boost::system::error_code& ec){
 717                 close_call_check = true;
 718                 ec = close_out_ec;
 719                 return close_res;
 720             };
 721
 722             bool close_res;
 723             boost::system::error_code close_out_ec;
 724             bool close_call_check;
 725
 726             //! set non blocking mode of the socket
 727             //! @return            ec is reference error code object
 728             bool set_non_blocking_mode(boost::system::error_code& ec){
 729                 ec = tcp_socket::set_non_blocking_mode_ec;
 730                 return tcp_socket::set_non_blocking_mode_res;
 731             };
 732
 733             //! write socket
 734             //! @param[in]        buffers is wite data buffer
 735             //! @param[out]        ec is reference error code object
 736             //! @return            write data size
 737             std::size_t write_some(boost::asio::mutable_buffers_1 buffers, boost::system::error_code& ec){
 738                 write_some_call_check = true;
 739                 write_some_buffers_size_in = boost::asio::buffer_size(*buffers.begin());
 740                 write_some_buffers_in = boost::asio::detail::buffer_cast_helper(*buffers.begin());
 741                 ec = write_some_ec;
 742                 return write_some_res;
 743             };
 744
 745             std::size_t write_some_res;
 746             boost::system::error_code write_some_ec;
 747             void* write_some_buffers_in;
 748             std::size_t write_some_buffers_size_in;
 749             bool write_some_call_check;
 750
 751             //! read socket
 752             //! @param[out]        buffers is read data buffer
 753             //! @param[out]        ec is reference error code object
 754             //! @return            read data size
 755             std::size_t read_some(boost::asio::mutable_buffers_1 buffers, boost::system::error_code& ec){
 756                 read_some_call_check = true;
 757                 read_some_buffers_size_in = boost::asio::buffer_size(*buffers.begin());
 758                 boost::array<char,MAX_BUFFER_SIZE>* pBuf = (boost::array<char,MAX_BUFFER_SIZE>*)boost::asio::detail::buffer_cast_helper(*buffers.begin());
 759                 for(int i = 0 ; i < (int)read_some_buffers_size_in ;i++){
 760                     if(i >= MAX_BUFFER_SIZE) break;
 761                     (*pBuf)[i] = read_some_buffers_out[i];
 762                 }
 763                 ec = read_some_ec;
 764                 return read_some_res;
 765             };
 766
 767             std::size_t read_some_res;
 768             boost::system::error_code read_some_ec;
 769             boost::array<char,MAX_BUFFER_SIZE> read_some_buffers_out;
 770             std::size_t read_some_buffers_size_in;
 771             bool read_some_call_check;
 772
 773             bool is_open(){
 774                 return is_open_res;
 775             };
 776             bool is_open_res;
 777     };
 778
 779     bool tcp_socket::connect_res;
 780     boost::asio::ip::tcp::endpoint tcp_socket::connect_connect_endpoint;
 781     boost::system::error_code* tcp_socket::connect_ec;
 782     bool tcp_socket::connect_call_check;
 783     bool tcp_socket::set_non_blocking_mode_res = true;;
 784     boost::system::error_code tcp_socket::set_non_blocking_mode_ec;
 785     bool tcp_socket::is_connect = false;
 786
 787     // Dummy tcp_ssl_socket Class
 788     class    tcp_ssl_socket{
 789         public:
 790             static bool set_non_blocking_mode_res;
 791             static boost::system::error_code set_non_blocking_mode_ec;
 792             static bool is_connect;
 793
 794             boost::asio::ssl::stream<boost::asio::ip::tcp::socket> my_socket;
 795             tcp_socket_option_info opt_info;
 796
 797             tcp_ssl_socket(boost::asio::io_service& io,boost::asio::ssl::context& context,const tcp_socket_option_info set_option) :
 798                 my_socket(io,context),
 799                 opt_info(set_option){
 800             };
 801             ~tcp_ssl_socket(){};
 802
 803             boost::asio::ssl::stream<boost::asio::ip::tcp::socket>& get_socket(){
 804                 return my_socket;
 805             };
 806
 807             //! close socket
 808             //! @param[out]        ec is reference error code object
 809             //! @return         true is socket close
 810             //! @return         false is not open socket
 811             bool close(boost::system::error_code& ec){
 812                 close_call_check = true;
 813                 ec = close_out_ec;
 814                 return close_res;
 815             };
 816
 817             bool close_res;
 818             boost::system::error_code close_out_ec;
 819             bool close_call_check;
 820
 821             //! set non blocking mode of the socket
 822             //! @return            ec is reference error code object
 823             bool set_non_blocking_mode(boost::system::error_code& ec){
 824                 ec = tcp_socket::set_non_blocking_mode_ec;
 825                 return tcp_socket::set_non_blocking_mode_res;
 826             };
 827
 828
 829             //! accept
 830             bool accept(){
 831                 tcp_ssl_socket::accept_call_check = true;
 832                 return tcp_ssl_socket::accept_res;
 833             };
 834             bool accept_res;
 835             bool accept_call_check;
 836
 837
 838             //! write socket
 839             //! @param[in]        buffers is wite data buffer
 840             //! @param[out]        ec is reference error code object
 841             //! @return            write data size
 842             std::size_t write_some(boost::asio::mutable_buffers_1 buffers, boost::system::error_code& ec){
 843                 write_some_call_check = true;
 844                 write_some_buffers_size_in = boost::asio::buffer_size(*buffers.begin());
 845                 write_some_buffers_in = boost::asio::detail::buffer_cast_helper(*buffers.begin());
 846                 ec = write_some_ec;
 847                 return write_some_res;
 848             };
 849
 850             std::size_t write_some_res;
 851             boost::system::error_code write_some_ec;
 852             void* write_some_buffers_in;
 853             std::size_t write_some_buffers_size_in;
 854             bool write_some_call_check;
 855
 856             //! read socket
 857             //! @param[out]        buffers is read data buffer
 858             //! @param[out]        ec is reference error code object
 859             //! @return            read data size
 860             std::size_t read_some(boost::asio::mutable_buffers_1 buffers, boost::system::error_code& ec){
 861                 read_some_call_check = true;
 862                 read_some_buffers_size_in = boost::asio::buffer_size(*buffers.begin());
 863                 boost::array<char,MAX_BUFFER_SIZE>* pBuf = (boost::array<char,MAX_BUFFER_SIZE>*)boost::asio::detail::buffer_cast_helper(*buffers.begin());
 864                 for(int i = 0 ; i < (int)read_some_buffers_size_in ;i++){
 865                     if(i >= MAX_BUFFER_SIZE) break;
 866                     (*pBuf)[i] = read_some_buffers_out[i];
 867                 }
 868                 ec = read_some_ec;
 869                 return read_some_res;
 870             };
 871
 872             std::size_t read_some_res;
 873             boost::system::error_code read_some_ec;
 874             boost::array<char,MAX_BUFFER_SIZE> read_some_buffers_out;
 875             std::size_t read_some_buffers_size_in;
 876             bool read_some_call_check;
 877
 878             bool is_open(){
 879                 return is_open_res;
 880             };
 881             bool is_open_res;
 882
 883             void clear_socket() {}
 884
 885             bool is_handshake_error(){
 886                 return is_handshake_error_res;
 887             };
 888             bool is_handshake_error_res;
 889
 890
 891         //! handshake socket
 892         //! @param[out]        err code object
 893         //! @return         true is handshaked
 894         //! @return         false is handshake failure
 895         bool handshake(boost::system::error_code& ec){
 896                 handshake_call_check = true;
 897                 ec = handshake_set_ec;
 898                 return handshake_res;
 899         }
 900         bool handshake_call_check;
 901         bool handshake_res;
 902         boost::system::error_code handshake_set_ec;
 903
 904     };
 905
 906     bool tcp_ssl_socket::set_non_blocking_mode_res = true;
 907     boost::system::error_code tcp_ssl_socket::set_non_blocking_mode_ec;
 908     bool tcp_ssl_socket::is_connect = false;
 909
 910 }
 911
 912 int setsockopt_ret;
 913 int setsockopt_sock;
 914 int setsockopt_level;
 915 int setsockopt_optname;
 916 void* setsockopt_optval;
 917 socklen_t setsockopt_optlen;
 918 int setsockopt(int s, int level, int optname, void *optval, socklen_t optlen) {
 919     ::setsockopt_sock = s;
 920     ::setsockopt_level = level;
 921     ::setsockopt_optname = optname;
 922     ::setsockopt_optval = optval;
 923     ::setsockopt_optlen = optlen;
 924     return setsockopt_ret;
 925 }